Claudiu Persoiu

Blog-ul lui Claudiu Persoiu


The magic of programming

without comments

I feel there comes a time when I have to share some well kept trade secrets.

And today I will talk about the magic of programming.

I know there are a lot of newcomers that believe programming to be about learning how to code and practicing what you learn, while others just think it’s some sort of magic incantation that you need to know and recite in a special way to make things work.

I’m finally going to break the silence and make it clear once and for all. If I don’t write that much after this post it’s because I’m running for my life chased by the other programmers that don’t want to let the secret out.

The secret is magic! The spellwork is well hidden in programming books, in tutorials, buried deep in the code and covered by fancy phrases like “Refactoring” or “Code compilation”. All of this is just a charade to make you feel like you don’t understand programming, while everything depends on knowing how to cast the secret spell.

It’s like bodybuilders, we all know they don’t have big muscles because they go to the gym, they only go to the gym to showcase them! They have big muscles because they take steroids and protein powders. And you knew that all the time, that’s why you don’t go to the gym.

And you know how reading official documentation makes you sleepy? It’s because of the protection mechanisms they have in place. It makes you sleepy so you give up and live with the false idea that programming is boring.

That is why you were never able to understand programming, you didn’t know the spells and how to weave them to make your code work!

Ever wonder why not all answers from Stack Overflow work? Some are given by evil wizards that want to confuse newcomers and keep them out of the secret programming coven! Only experienced wizards can combine multiple answers from Stack Overflow and somehome make them work together.

That’s all there is to it, that’s why some people know programming and others don’t. It’s not that some study a lot and practice even more and write pointless code just to see if and how it is working, NO! It’s the magic of the spells! Now you don’t have to spend all that time going through tutorials or even buying courses or, in very extreme cases, buying AND reading books!

Enough is enough, we must stop this nonsense!

And now, I will be busy running for my life from the programming arch-wizards!

If you are not sure if this is a pamphlet, well… It could be… who am I to judge?

Written by Claudiu Persoiu

25 June 2020 at 7:12 PM

Posted in Diverse

Tagged with

Magento2 and the ugly truth

without comments

I’ve been working with Magento for a long time and I can say that the platform changed a lot over time and I would like to share my personal thoughts on it.

How Magento 2 learned from the past to make some brand-new mistakes

I had my first encounter with Magento in 2011 and, back then, all I knew about it was that it was based on Zend Framework and that it was doing e-commerce (obviously).

I was coming from the Symfony framework world, with a lot of documentation, a great community and a rock-solid implementation. This was still Symfony 1, Symfony 2 was just coming out.

By comparison, Magento had next to no documentation, barely any community and the implementation had a plethora of bugs. In my first few days on the job I was seeing a lot of people debugging deep in the Core, I was just perplexed, I almost never needed to debug Symfony, let alone actually find bugs.

Some may argue that Symfony is a framework and Magento is a platform and the argument is as solid as a guinea pig.

The reason for this situation was simple: they didn’t expect the platform to have so much success; but it did and the reason was simple – it was pretty much the only platform in the PHP world that was built with modularity in mind at that time, period! There were other platforms, but definitely not as versatile, fully featured and modular as Magento.

Moving forward, they’ve spent a lot of time and effort in building ample documentation for Magento1, focused on quality, rock-solid stability, all paired with exceptional support for enterprise partners!

Psych! No, they did not! The documentation for M1 was always sparse and of very poor quality. Basically, the best resource was Ben Marks’ “Fundamentals of Magento Development” course, a book (about which and not entitled to an opinion, since I didn’t read it), some blog posts from individuals or companies that worked with the platform and a lot of StackOverflow questions and answers. All this was paired with exceptionally bad support for enterprise users, extremely slow and low quality solutions and, to top it off, plenty of Core bugs. It wasn’t unusual to find non-standard, half-baked implementations and bugs in the Core. But the Core was simple enough that, with Xdebug and a lot of patience, everything was more or less fixable.

Fixes coming from their support team were close to a myth. If you didn’t want to fix a bug, or just didn’t feel like working, you could open a ticket and in most cases it took days or even weeks to get a proper response. By that time you would have usually fixed it already and (in some cases) even sent the fix to their support so they can also include it in the Core.

And along comes Magento 2

With the burden of the popularity-driven growth of Magento 1, Magento 2 came to the rescue.

It took a long time for Magento 2 to be ready, and I think that is more of a story in itself, but some actions were taken to prevent some of the issues that the first version had.

Let’s look on some of the platform issues:

  • classes could only be extended by overwriting;
  • the frontend was based on the Prototype framework.

There were many other changes but I think these were among the most important ones.

And now let’s see how Magento 2 managed to fix all these issues

It is a good practice to start with something nice, so I will start with the documentation, Magento2 had documentation from the start and it was both useful and well made!

Regarding the classes overwrite, there were implemented two approaches:

  • implementing dependency injection (from Symfony)
  • implementing plugins using interceptor pattern.

Dependency injection really helped with the ability to substitute classes and functionality, and the plugins helped a lot with a non-invasive way of extending the functionality. Before plugins, only observers were able to modify data in a non-invasive way, and the big problem was that (in many cases) there just weren’t observers everywhere you needed them to be.

Unfortunately, this created a lot of overhead. Maybe in M1 you could just put a breakpoint and look in the stacktrace to see what methods are changing what, but now… it is just a lot more complex, each method has an interceptor class that triggers the plugin mechanism. Each plugin can be triggered before, after or around the method, the around method can prevent the actual method from getting called. In short, it is a lot more code with a lot more methods and a lot more code to follow. When it is working is a lot more elegant, but when it doesn’t it is a lot worse to debug.

In a dramatic twist, many of the classes were not implemented properly in the Core. You see, when Magento2 was released, a lot of compromises had to be made, and some of the Core modules were just “made to work” in the new framework. Later when everyone was expecting the cleanup to be made… it wasn’t, the reason is simple, why fix the Core when you can break compatibility with the modules already created?

This issue even made Magento Core developers suggest that you should follow the guidelines, not use the Core as an example: do what we say, not what we do.

Frontend was fixed even better! You may ask yourself what is that “prototype” library and why would anyone in their right mind choose it? It made a lot of sense back then, when Magento1 was created and there were several popular js libraries, mainly: jQuery, Prototype and MooTools. There were a lot more than these 3, but these were the popular ones. There was a war between jQuery and Prototype, just like there is now between React, Angular and Vue. The first had a new approach with almost a new language, while the second was aiming at extending the browser capabilities in a more discrete fashion. We now know who won, but back then it wasn’t obvious. As a small note, I was also a fan of Prototype back then.

The Magento 2 team realized over time that it was a mistake and, to fix it, they promised to make something more flexible. The new more flexible solution didn’t involve the Prototype library, but instead included: jQuery, Knockout.js, and Require.js just at the top level, without taking dependencies into consideration.

The idea was to separate the frontend and the backend, to have the ability to make completely new frontend APPs. And, as before, this was never properly finished and now there is a highly complicated system, partially separated, partially single page App and partially… multi page, implemented in a variety of styles. And this is only on the store front, the store backend has a slightly different, more complex system of xml, phtml, html and js files.
As a backend developer I can truly say that it is a lot harder to debug (or just to understand how the frontend part works) now than before.

The XML part of generating grids is probably the hardest part, it is extremely difficult to debug anything in it and, if you mess something up, you get no warnings at all, you have to find the class that is building the grid and see if an exception is triggered there, but that is not an obvious solution at all…

And, of course, the entire thing is a lot slower because of all these “new engineering features”. When all the code is generated and the links to static resources and everything set to production mode, it isn’t slow; it isn’t exactly fast, but it isn’t terribly slow either. But when you don’t have cache, and didn’t deploy the static resources, and you are in developer mode, it is just awfully slow, it can take a few minutes to load a simple product page! It is just ridiculous if you ask me, it isn’t an operating system, or a video game, it is a shopping cart, why in the world would it take 5 minutes to display a page, even without a lot of new modules.

Keep in mind that Magento 2 didn’t come with a lot of new features, most of the functionality was in M1, only more “engineered”, so those 5 minutes of code generation and linking and whatever magic is going on in there aren’t adding a lot of new features, just a lot of refactoring of the old system.

The Magento Cloud

Magento offered a Cloud, I don’t know if they are anymore and I don’t care, nobody really cares about it anymore, mostly because it wasn’t what everybody wanted.

People want simple things, you have an app, you push it to the clouds and money starts raining down. That should be it, less things to worry about.

Demandware, who doesn’t have a nice open source core, is doing something exactly like this: you don’t have the same amount of control, but you don’t take care of your website, the gods in the clouds do! The developer only develops, doesn’t need to care about what magic operations are doing, because he is not ops, he is dev!

The Magento Commerce Cloud was aimed to do that, just push this monster in the cloud and some very smart ops will scale it for you! But it wasn’t like this, it was never easy, nor fast. And, on top of that, other hosting providers started making hosting solutions for Magento that were better at scaling then the official one, which is just ridiculous.

A positive note to end on

There is an interesting core underneath it all.There are plenty of very smart features that make the platform so popular. Now you also have tests, so you can even do TDD.

Even with all this (over) engineering challenges, there are still plenty of passionate developers out there that are able and willing to overcome them.

There are also a lot of tools developed by the community to overcome some of the shortcomings, like generate the huge amount of files required for a model, or MSP_DevTools to help with debugging the frontend, or n98-magerun2 to help with crons and lots and lots more.

And lastly, there are still a lot of very brilliant and passionate developers out there that are willing to figure out a way to develop, scale and make sales for one more day!

Written by Claudiu Persoiu

31 March 2020 at 4:24 PM

Posted in Magento,PHP

Tagged with , ,

A bit of PHP, Go, FFI and holiday spirit

without comments

Ah, the holiday spirit.

Inspired by a post in Perl Advent, I decided that it would be nice to see an example done with PHP and Go. Please note that this blog is heavily inspired by the post mentioned above.

Let’s say you want to wish upon others happy holiday using the speed of Go, but you are using PHP, what is there to be done?

This is a great time in the PHP world to do something like this, as the newly released PHP 7.4 comes with “Foreign Function Interface” (FFI for short).

Equipped with this new power, I installed PHP 7.4 and got to work.

Let’s start with the super incredible Go greeting part, let’s create a file “greeting.go”:

package main
 
import (
   "fmt"
)
 
func main() {
   WishMerryChristmas();
}
 
func WishMerryChristmas() {
   fmt.Println("We wish you a Merry Christmas!");
}

Now let’s run it with:

$ go run greeting.go

It should display:
We wish you a Merry Christmas!

Great stuff so far! Now this is nice and fast and everything, but it needs to be a service, let’s see how that would look like:

package main
 
import (
   "C"
   "fmt"
)
 
func main() {}
 
//export WishMerryChristmas
func WishMerryChristmas() {
   fmt.Println("We wish you a Merry Christmas!")
}

As you can see, there are several differences:

  • we also imported “C”,
  • we removed the function call from main()
  • we added a comment to export the function.

To compile the code, run:

$ go build -o greeting.so -buildmode=c-shared

Note that this should be run each time the Go file is modified.

The output should be two files: “greeting.so” and “greeting.h”.

The header file “greeting.h” file contains the types and functions definition. If you come from C world you are probably already familiar with this type of files. Normally, all we need to do now is to import the header file using FFI and use the function!

For this I’ve created a file titled “greeting.php”:

<?php
 
$ffi = FFI::load("greeting.h");
$ffi->WishMerryChristmas();

Sure looks simple enough, you just have to run it with:

$ php greeting.php 
PHP Fatal error:  Uncaught FFI\ParserException: undefined C type '__SIZE_TYPE__' at line 43 in /home/claudiu/php-go/greeting.php:3
Stack trace:
#0 /home/claudiu/php-go/greeting.php(3): FFI::load()
#1 {main}

Next FFI\Exception: Failed loading 'greeting.h' in /home/claudiu/php-go/greeting.php:3
Stack trace:
#0 /home/claudiu/php-go/greeting.php(3): FFI::load()
#1 {main}
  thrown in /home/claudiu/php-go/greeting.php on line 3

Not exactly the greeting that I was hoping for…

After some digging, I found this one on the manual page:
C preprocessor directives are not supported, i.e. #include, #define and CPP macros do not work.

Because of this, we unfortunately can’t really use the header file, or at least I don’t know how.

On the bright side, we can use FFI::cdef() which allows for function definition specification. If I lost you on the way, what I’m trying to do is just tell PHP which are the function definitions that it can use from “greeting.so”.

The new code will become:

<?php
$ffi = FFI::cdef("
void WishMerryChristmas();
", __DIR__ . "/greeting.so");

$ffi->WishMerryChristmas();

And if we run it:

$ php greeting.php
We wish you a Merry Christmas!

We are making great progress, the service is doing a great job!

Adding an int parameter

The greeting is nice and fast and all but it would be nice to be able to specify how many times to run it.

To achieve this, I’m modifying the previous example method to specify how many times to display the greeting in the file greeting.go:

//export WishMerryChristmas
func WishMerryChristmas(number int) {
   for i := 0; i < number; i++ {
       fmt.Println("We wish you a Merry Christmas!");
   }
}

Run the compilation as before and everything should be fine.

In the PHP script we need to modify the function definition. To see what we should use we can take a hint from the “greeting.h” file. The new function definition in my file is:

extern void WishMerryChristmas(GoInt p0);

“GoInt”? What magic is that? Well, if we look in the file, there are the following definitions:

...
typedef long long GoInt64;
...
typedef GoInt64 GoInt;
...

With this in mind, we can change the PHP file to:

<?php
$ffi = FFI::cdef("
void WishMerryChristmas(long);
", __DIR__ . "/greeting.so");
 
$ffi->WishMerryChristmas(3);

Run it and you should see:

$ php greeting.php 
We wish you a Merry Christmas!
We wish you a Merry Christmas!
We wish you a Merry Christmas!

Ah, it’s beginning to feel a lot like Christmas!

Adding a string parameter

Displaying a greeting multiple times is quite nice, but it would be nicer to add a name to it.

The new greeting function in go will be:

//export WishMerryChristmas
func WishMerryChristmas(name string, number int) {
   for i := 0; i < number; i++ {
       fmt.Printf("We wish you a Merry Christmas, %s!\n", name);
   }
}

Don’t forget to compile and let’s get to the interesting part.

Looking into the “greeting.h” file, the new function definition is:

extern void WishMerryChristmas(GoString p0, GoInt p1);

We already got GoInt, but GoString it is a bit trickier. After several substitutions I was able to see that the structure is:

typedef struct { char* p; long n } GoString;

It is essentially a pointer to a list of characters and a dimension.

This means that, in the PHP file, the new definition is going to be:

$ffi = FFI::cdef("
typedef struct { char* p; long n } GoString;
typedef long GoInt;
void WishMerryChristmas(GoString p0, GoInt p1);
", __DIR__ . "/greeting.so");

p0 and p1 are optional, but I’ve added them for a closer resemblance to the header file. On the same note, GoInt is basically a long, but I left the type there for the same reason.

Building a GoString was a bit of a challenge. The main reason is that I didn’t find a way to create a “char *” and initialize it. My alternative was to create an array of “char” and cast it, like this:

$name = "reader";
$strChar = str_split($name);
 
$c = FFI::new('char[' . count($strChar) . ']');
foreach ($strChar as $i => $char) {
   $c[$i] = $char;
}
 
$goStr = $ffi->new("GoString");
$goStr->p = FFI::cast(FFI::type('char *'), $c);
$goStr->n = count($strChar);
 
$ffi->WishMerryChristmas($goStr, 2);

And let’s try it out:

$ php greeting.php 
We wish you a Merry Christmas, reader!
We wish you a Merry Christmas, reader!

Success!

At this point I would like to move the GoString creation in a new function, just for the sake of code clean-up.

And the new code is:

$name = "reader";

$goStr = stringToGoString($ffi->new("GoString"), $name);

$ffi->WishMerryChristmas($goStr, 2);

function stringToGoString($goStr, $name) {
    $strChar = str_split($name);

    $c = FFI::new('char[' . count($strChar) . ']');
    foreach ($strChar as $i => $char) {
        $c[$i] = $char;
    }
    
    $goStr->p = FFI::cast(FFI::type('char *'), $c);
    $goStr->n = count($strChar);

    return $goStr;
}

And let’s try it:

$ php greeting.php 
We wish you a Merry Christmas, ��!
We wish you a Merry Christmas, ��!

That’s not right… it seems like it’s displaying some junk memory. But why?

Looking into the documentation for FFI::new I’ve seen a second parameter “bool $owned = TRUE”.
Whether to create owned (i.e. managed) or unmanaged data. Managed data lives together with the returned FFI\CData object, and is released when the last reference to that object is released by regular PHP reference counting or GC. Unmanaged data should be released by calling FFI::free(), when no longer needed.

This means that, when the function was returned, the GC is clearing the memory for the string. This is very likely a bug, but there is a very simple fix, just modify the char array creation to “false”:

$c = FFI::new('char[' . count($strChar) . ']', false);

Let’s try it again:

$ php greeting.php 
We wish you a Merry Christmas, reader!
We wish you a Merry Christmas, reader!

And it’s working!

Conclusion

Maybe it’s not as easy as importing a header file when trying to run Go libraries from PHP, but with a little patience it is certainly possible! A big advantage to this is that a library built in Go, or other programming languages that allow it, can be used by a language like PHP without the need to reimplement the logic!

And, on this last positive remark, I would like to wish you happy holidays!

Written by Claudiu Persoiu

23 December 2019 at 1:37 PM

Posted in GO,PHP

Tagged with , , ,

How to make use of the Xiaomi Air Conditioning Companion in Home Assistant in only 20 easy steps!

without comments

Xiaomi Air Conditioning Companion si Home assistant

Step 1:

Buy a Xiaomi Air Conditioning Companion without first researching how well it is supported by Home Assistant.

Step 2:

Realize that the Chinese power socket for 16A is different from the 10A one.

Step 3:

Realize that nobody is selling a 16A socket adapter for a 10A China power outlet in Romania.

Step 4:

Order a 16A power socket from China.

Step 5:

Wait 2 months for both the socket and the device to arrive from China.

Step 6:

Realize that there is no adapter for the wall outlet from China also.

Step 7:

Find the only seller that will sell a modular outlet that matches outlet box, probably by mistake

Step 8:

Wait for them to tell you that it will be delivered in a month

Step 9:

If it did not arrive yet, wait for a socket module to be delivered

Step 10:

Install the wall module and power socket

Step 11:

Connect the Xiaomi Air Conditioning Companion and AC for the first time

Step 12:

Realize that the Xiaomi Mi Home App has been updated in the meantime and there is no working tutorial on how to get the password for Home Assistant.

Step 13:

Figure out (after many tries) how to get the gateway password.

Step 14:

Add it to Home Assistant and realize that the gateway is not well supported and that the only things you can do from Home Assistant are sound the alarm and change its volume.

Step 15:

Find the xiaomi_airconditioningcompanion module and realize that you didn’t need the gateway password in the first place.

Step 16:

Downgrade the Xiaomi Mi Home App to get the token as specified in the instructions: https://www.home-assistant.io/integrations/vacuum.xiaomi_miio#retrieving-the-access-token

Step 17:

Realize that you don’t have the right version of Hass.io to use the module.

Step 18:

Move to Hassbian from Hass.io

Step 19:

Finally, install the extension and setup the module.

Step 20:

Now the only thing that remains is to enjoy the comfort of controlling your air conditioning from a few feet away, without ever using the remote!

Written by Claudiu Persoiu

13 October 2019 at 7:47 PM

Posted in Diverse

Tagged with

How I use Magento2 on my local with Docker and Docker Compose

without comments

Disclaimer

Please note that this solution is tailored specifically for my needs and, while your needs may vary, don’t worry, everything is on GitHub, so feel free to take what you need.

I would like to add that this is not a “you’ve been using Docker with Magento2 wrong, this is how it’s done” kind of blog, I just want to share what I’m using and how. It may not be the best fit for you, but maybe you will find something useful.

Intro

For almost 2 years I’ve been using Magento2 in Docker containers. I’ve been doing that before, but I must admit that it was because I had to, not because I’ve seen the light, I mean advantages.

As you may know Magento2 is not exactly a small and light app, it’s quite heavy on the resources, especially during development.

Compared to a VM, with Docker you get:

  • Speed: I think the speed is one of the biggest advantages, you can stop and start containers very fast, only the first build will take time, after that it will be very fast;
  • Light on resources: Compared to a VM, the container does not need to include the entire operating system, so it will not take a lot of space on disk and will not use a lot of processing power, because it’s not an entire OS doing… well… OS stuff, it’s just a server most of the time.

What you don’t get:

  • Learning curve: if you don’t know Docker and Docker Compose, it will be less intuitive at first;
  • First setup: harder to setup at first, if you have been using a VM for a long time, you will feel that you are going against the tide, but I assure you, in the long term it will be a lot simpler this way.

Taking the above into consideration, I would like to say that when I’ve started with this setup I was using Linux with 8G of RAM. One of my colleagues even wished me good luck on installing Magento2 on a ultraportable 8Gb RAM system. He wasn’t even sarcastic, more like pitying me for my bad workstation selection.

One of the requirements was that I needed some isolation and configuration between projects, I couldn’t just install a server and be done with it.

Previously I’ve been using Vagrant and VirtualBox, a great fit, very easy to use (most of the time). However, for Magento2 I’ve realised that it was heavy enough on its own, it was making me run out of resources fast.

Also, I wanted it to be easy to use, I don’t like to have to remember and type out a 3 word command, I just want to press some tabs and get it over with.

The requirements

There were some specific requirements:

  • nginx config – should work out of the box, Magento configuration isn’t very small, I wanted to make use of it with ease;
  • SSL – the domain has to also work with HTTPS, mostly because some APIs require it, the certificates don’t need to be valid;
  • bash – the Magento command should work as the system user, not as root (as containers usually do). This is required, because I don’t want the files generated by Magento to be generated as root (and therefore only removable with root rights);
  • xdebug – must work out of the box and be easily integrated with an IDE.

The implementation and usage

Magento2 offered a Docker container to work with. I will not say anything about it, since it wasn’t at all something I needed.

My main source of inspiration was: https://github.com/markoshust/docker-magento. The project changed a lot since I’ve started, so I definitely think you should check it out.

The starter point is: https://github.com/claudiu-persoiu/magento2-docker-compose

The relevant files are:

  • magento2 – it should contain a folder html with the project
  • dkc_short – it can reside anywhere, but it should be added to the files ~/.bash_profile or ~/.bashrc, this file contains shortcuts, it’s not necessary, but I like it because it make my life easier;
  • docker-compose.yml – it contains all the mappings and relevant containers.

NOTE: I think I should point out that the commands on the PHP container run in two ways, as the system user or as root. This is a limitation of the Linux implementation, please make a note of it, as I will refer to it later.

Step 1:

What you should do when starting a new project with an existing Magento2 repository:

$ git clone https://github.com/claudiu-persoiu/magento2-docker-compose.git project_name
$ cd project_name
$ git clone your_own_magento2_repository magento2/html

Step 2 (optional):

Copy the shortcuts to your bash console:

$ cp dkc_short ~/
$ echo ~/dkc_short >> ~/.bash_profile
$ source ~/.bash_profile

NOTE: If you don’t have the file ~/.bash_profile on your computer, just use ~/.bashrc

Step 3:

Start the setup:

$ dkc-up -d

It will take a bit of time the first time, but it will be a lot faster next time you run it.

Step 4:

Run composer install:

$ dkc-php-run composer install

That’s about it.

What is this dkc stuff?

Well, I like to use tabs when running a command, so I added some aliases that allow me to run a Magento command without typing everything, I just type dkc[tab]p[tab]-[tab] and the command. I just love bash autocomplete.

The command list is very simple:

  • dkc-up -d – start the containers in the background
  • dkc-down – stop all containers
  • dkc-mag [command] – run a Magento2 command
  • dkc-clean – clear the cache
  • dkc-php-run – run a bash command inside the php container, like composer in the previous example. NOTE: This command is running as the system user, not as root.
  • dkc-exec phpfpm [command] – this is same as above, but running as root. You should almost always use the command above.
  • dkc-exec [container] [command] – this command needs a bit more explanation:
    • container can be:
      • app – for Nginx server,
      • phpfrm – for php container,
      • db – for database,
      • cache or fpc – for cache containers;
  • the command can be anything that applies to that container, like “bash” or “bash composer”, etc.

I know the commands seem like “one more thing to learn”, but most of the time you will only use the first 4 commands.

How does the magic work?

Well, to see what the above commands translate to, just check the “dkc_short” file.

There are only 2 other interesting repositories:

The repositories are pretty small and not very hard to understand.

If you need to modify anything, just feel free to fork the repositories.

The conclusion

That’s about all you need to know about it, I’ve been using this setup for almost 2 years.

For me, it’s working as a charm and I was able to use Magento2 on ultraportable laptop with 8Gb RAM without any issues.

The (happy) end!

Written by Claudiu Persoiu

29 November 2018 at 3:00 PM

About passion, programming and heating systems

without comments

Don’t be fooled, this post is about programming, system architecture but mostly about using a heating system.

If you don’t know how can you talk about programming without programming you should check out the “The Passionate Programmer” book by Chad Fowler, a great read. The Jazz stories from this book inspired me to write this blog.

The story begins with a new apartment in an old building. Or at least it’s new to me.

The building has its own heating system, very old and extremely inefficient. After a long consideration I’ve decided that it was time to install my own heating system and disconnect from the main building one.

So far, nothing interesting, there are many people that do this, partly because of the added comfort and partly to optimize expenses.

With this being said, I had a project and needed a developer. Or in other words, I had a heating system to build and I was in need of somebody to do it.

I’ve asked around for that “good” developer.

Like in anything else, there are a lot of people that come up with bad solutions. There are devs that make great offers but are unable to finish the project, or they write very bad code that is not scalable and even worst, unmaintainable.

Since what I know about heating systems can be covered by anyone with the patience to google the subject for a couple of hours or so, I wanted somebody I could trust, so I was looking for the passionate kind of developer!

I had a couple of recommendations. The first one told me that he had to put all the pipes close to the ceiling. After convincing him that I don’t want my house to look like a factory full of pipes he said that he will definitely need to replace one of the radiators (at least) because he could not fit a pipe behind it. I could fit my palm behind that radiator, with this in mind I knew I wanted somebody that could fit a pipe behind my radiator.

It was clear that he wasn’t a good developer. A good developer must work with the requirements, the very least a project should be able to respect most of the client requirements, if it doesn’t, there can be several explanations: he can’t because he doesn’t know how or he doesn’t want because he knows it’s hard and doesn’t want to go that extra mile. In some cases that’s not a tragedy, maybe it will be cheaper and faster, and in his case it was. Unfortunately for him, I aimed for quality.

Then there was the passionate developer. He never mentioned anything about not being able to do something, it was always a cost and maybe a consequence. The deal with better developers is that they are more expensive and everything about them is expensive, they will want better servers for hosting, better tools and sometimes more time for things like testing and maintenance. In other words, sometimes the cost is bigger not just then, but also in the log run. A quality project takes time and money.

This is my resulting project:

If you never seen an apartment heating system before you should know that except for the pipes, nothing else is actually required.

It’s all just passion!

For instance: the pump on the lower right, it’s there just to force the water to move faster in the system. Think of it as Redis, it will have a good effect on your system but most systems will happily work without it. Of course, at some point there may be maintenance for that pump and can even result in issues, like this Magento 2 issue: https://github.com/magento/magento2/issues/10002. Every system has its own cost.

The expansion tank in the lower left was unnecessary (in the sense that the system already has one built-in), but it’s not a bad idea to have an extra. Think of it as that extra storage space, ram or CPU that you don’t actually use. Your server should never go above certain server loads, that’s the expansion tank you should take into consideration.

The water intake filter is like your firewall, you need it, it’s your protection, maybe most of the time will be useless but when there will be issues, then you will be glad you have it, because he will have filtered them out.

The good thing with passionate developers is that other developers understand and appreciate their work. That is very important, no matter the industry of the “developer”.

The only one that had anything to comment on the system was the ISCIR certified technician that initialized the heating system (ISCIR in Romania is a special authorization needed for this exact thing). You can tell that he wasn’t passionate, he just wanted to say something bad about it because he wanted to make a good impression on me.

Unfortunately for him, he made some very stupid comments and then he made me a maintenance offer. This guy was the consultant, he didn’t do the project and he doesn’t want to work on it but he definitely wants to make some money on it without actually doing anything.

I guess the conclusion is that no matter the developer, the quality and passion transcends the industry.

Written by Claudiu Persoiu

8 August 2018 at 8:47 PM

Posted in Diverse,Web stuff

Tagged with

The Books for Zend Certified Engineer 2017

without comments

I have recently passed the Zend Certified Engineer 2017, certification offered by Rogue Wave.

While experience is the most important thing for a certification, books are the best way to expand your knowledge, in my opinion.

Since a certification is something very specific, there aren’t a lot of books.

Before we begin, keep in mind that the most exhaustive resource for learning PHP is the manual, always take a look on all the classes and functions available.

Zend Certified Engineer Exam Study Guide $20

I’ve bought this book just so I can review it and earn my right to have an opinion about it.

The study guide was introduced with the certification for PHP 5.3 and it was a free resource. The quality of the book has updated continually, but never by a lot and at some point it was no longer a free resource.

Over time I kept hoping that it will become better and better, but it didn’t. It’s a short book with a big font and lots and lots of misspellings and errors.

The only good part about it is that it has several questions for each chapter, other then that it’s not a very good resources and it’s not worth the $20, probably about $5 would be closer to a fair price since with every version they just update it a bit and adding the new features of the language. The questions don’t even seem to change a lot over time.

So if it’s the only book you are going to buy, go for the next one.

PHP 7 Zend Certification Study Guide – Andrew Beak – Apress 2017 – $19.99

The book is exploring all the sections for the certification in more depth, it has over 300 pages.

It feels more like a programming book and less like a guilde. The quality of the book is way better than the official guide, but that’s not hard at all considering that the guide set such a low bar.

There are also questions on all the chapters which is a good way to practice your knowledge in an exam format. The questions just feel a bit more soft than the guide, the exam itself has a lot of very tricky questions.

Of course this book is not exhaustive, you can’t really cover all the subjects in depth in a single book, and even if it did, then you would probably not have time to read it anyway.

If you are going to buy a single book, I would recommend this one, since it’s an actual book, not a very high level (and low quality) guide.

Zend PHP 5 Certification Study Guide, Third Edition – php[architect] – $22

If you think that I’ve got the version wrong, well, what can I say? you are right!

I wanted to add this book here because for me it was the best Study Guide. Over the years there were various study guides but this one I liked the most.

For the PHP 5 certification there wasn’t an official certification from Zend, only the first edition of this book. It was just a nice programming book to read. Sometimes, when I want to remember something that I haven’t used a lot, or at all, I will read the chapter in this book.

When I took the PHP 5.5 certification, (because I just had to collect them all) I was happy to find out that there is a new version of the book.

It’s basically the same book but updated to cover the new certification. It may be that I like Davey Shafik’s style of writing.

The book feels a bit more dense in terms of information, for me it just feels more like a study guide then the previous book.

However this book does not have questions and is no longer up to date.

If you have the time you can give it a read anyway, I think it is a good general PHP book.

Conclusion

Not a lot of books for this certification, but if I had to pick only one, it would be the “PHP 7 Zend Certification Study Guide” from Apress.

Unfortunately there isn’t a lot of competition, because the “Zend PHP 5 Certification Study Guide, Third Edition” from PHP Arch is no longer up to date and the official guide just isn’t worth the $20 price tag.

If your boss will buy the books, I say go all in! After all, the cost is: $20 + $19.99 + $22 = $61.99! Not bad for three programming books!

Written by Claudiu Persoiu

12 June 2018 at 8:44 PM

Posted in PHP

Tagged with , , , ,

Why is a language like PHP so popular?

without comments

Yes, PHP is probably the most popular programming language on the server side for the web at the moment. And it’s probably going to be for a long while…

It’s probably the best!

That’s not really it, just read on…

Why is it so easy to learn?

First of all, it’s the syntax. It’s not the best syntax out there, the reason is actually that it’s the most popular! I knew most of the syntax before I even looked at a “hello world” example, why? I’ve studied C in school, and people coming from Java had the same feeling.

Let’s see a few programming languages that are using this syntax: Java, C#, JavaScript, Perl, Go, PHP and, of course, C and C++, and between them you have most of the market and platforms.

Unlike (most) other languages listed above, it’s a lot easier to get started! You don’t have to create a main function, a class or anything else to get started, you just get down to it!

The good part is that you can make it as complex as you want (or need) to, these days there are Java-like classes and interfaces, horizontal inheritance with traits, functional programming with closures and anonymous functions, generators and, if you really are a hipster, even goto.

But PHP doesn’t sound so bad…

Now, there is an important detail that must be mentioned, PHP didn’t become popular because of the features mentioned above, but the features came to it because of its popularity, even “goto”. I don’t know why somebody would add goto to a language more than 10 years after its creation but that’s none of my business, nor is it important for the subject at hand.

The language became really popular with versions 3 and 4. By the time a decent OOP model is introduced, it had already gained a lot of popularity! Now, especially more so since PHP 7 is looking a whole lot more like a decent programming language, but 10 years ago it wasn’t the same story.

But node.js will probably surpass it!

Right… remember Ruby? Python? And others…

If you think about PHP, it has a major advantage and disadvantage, is very much as stateless as it can be.

With PHP you feel like it doesn’t know anything about the world, you have to bootstrap everything all the time. The advantage is that if you have a memory leak, most of the time, it’s ok. The current user will finish and everything will get cleared and nobody will have to care. And PHP had a lot of memory leaks when it started to became very popular and nobody seemed to mind.

When people started making cron jobs and other long running processes, this becomes a big issue and the need for features like explicit garbage collection became a must. That was added with version 5.3, which was released in 2009.

Normally, continuous running should not be a disadvantage, so the moral of this story is that it’s not necessarily an advantage either.

Nobody is going to build the next Google on it, but how about some blogs? Or even better, some shopping carts?

It just doesn’t have what it takes for something like the Google search engine and that’s ok because it was just not designed for that.

Another example for “not necessarily the best will win” is that WordPress is the most popular blogging platform.

Even more, people are using WordPress for all kind of weird things, basically you can do anything with it! And you should not blame the people using it, it’s not like you look what’s in your microwave when you buy it, you just want to have a warm meal. People forcing the limit of WordPress are doing the same, they can do what they need, so there is no good reason not to.

Should I ever use it?

Let’s take a couple of positive examples: Yahoo! and Facebook.
Yahoo! has been using it for a very long time on some of their products and in combination with other programming languages.

Facebook has been using it since the beginning because it is so easy to learn. They have been pushing the limit of the language in several occasions with: HipHop for PHP and more recently Hack, which was a very important motivational drive and a big influence for PHP 7.

Why all that trouble for a language? Because it’s just so easy to learn and use!

Usually, it’s a lot more important to release “now” then to have something “perfect” later, especially on the world wide web.

There is a very good reason why a language that is definitely not “the best”, but it is easy to learn is so popular online, while a programming language like C, which is way harder to learn, is more popular offline than online.

In other words, while definitely not being the best, PHP is most of the time just good enough.

Written by Claudiu Persoiu

19 October 2017 at 8:46 PM

Posted in PHP

Tagged with

Guide to motivating programmers OR How to provide coders with a real challenge

without comments

motivationIT is probably one of the most dynamic fields in the job market and people are a very important yet limited resource.

And yet people come and go quite often, and most of them are complaining about the lack of motivation.

This problem will end now with this simple guide for motivating programmers and not only them!

Programmers need challenging problems, they keep saying all the time that they need more challenges, don’t they?

Give your coder a true challenge! Make him get specifications from a client that doesn’t know what he wants, let him struggle, you could even try leaving him do this by himself, let him feel the adrenaline of a true challenge!

It must be noted that a programmer is nothing more than a repressed Project Manager, give him a chance to express!

However, you should not stop with that, because there is no greater challenge than to work on multiple assignments at the same time. A good idea for raising complexity is to offer him the chance to work on multiple projects in parallel. Give him the opportunity to have his mind busy with different things, diversity is always good, isn’t it?

A little secret for exploring diversity at its fullest is for him to have different roles on different projects, maybe have him alternate a project that requires management with one that requires maintenance. It’s a shame to not have enough diversity!

Is he writing a lot of code? You have to do something about it! When a programmer is focused working on something, keep in mind that he’s actually desperately crying for attention. You have to do something to break this vicious circle, it’s your duty as a manager to save him!

You have to find a way to interrupt him: try with a few meeting, they always help. If he is looking eager to get out of a meeting, it’s just a sign that he wants to get into the next one!

In time, you’ll see that the better a developer is at writing code, the more he’ll wish not to have time for it anymore. However, he’s not going to tell you this, or, even if he does, it’s because he really doesn’t know what he truly desires.

And eventually, if he likes to write code so much, maybe you should take it to the next level and get him to test it on his own. After all, if he wrote it, who would know better how to test it?
There is one more thing to mention in the context of a challenge. When a programmer is coming to an interview, he will always say “I want to learn new things”. How do you apply in real life this desire? Simple, you have to make him work on something that he doesn’t know anything about! This way you will present him with something that’s at the same time new and challenging. Is he a PHP programmer? Good for him, now give him a Java project! Is he a Java programmer? Nothing could be simpler, give him something to do in Objective-C! Maybe sometimes it will be hard to find new technologies the are completely unfamiliar to him, but a programmer’s happiness is not an easy thing to obtain!

Try not to fall in the trap of offering salaries that are correlated with the position he applied for. Don’t worry, the salary is confidential, nobody talks about it. Especially not when he recommends a friend, he will definitely not inquire about the salary that was offered to said friend, if confidential. It would be a lack of professional ethics to try to find out, you really don’t have to worry about it.

And speaking of interviews, maybe you think that hiring processes should lead to meaningful results and qualified candidates. You couldn’t be more wrong, because what do you truly need? Like I’ve said before: Diversity! Not long ago I’ve read an article about some chinese companies hiring beautiful women to make the work environment more enjoyable and stimulating. You have to always find ways to integrate the new tendencies, and if the only open positions that you have are for technical jobs, you have to work with what you have. Maybe you think hiring based on looks can be problematic sometimes, especially when the jobs are technical. In this cases you have to realise that motivation has to be designed at a large scale. Yes, maybe some teams will require more time to adapt to this kind of new team members, however if that person has done something worth mentioning in any way, it means you’ve done a great job!

Let’s not forget about trainings and conferences. When did you last talk with a programmer saying that he doesn’t want to go to trainings or specialised conferences?

Motivation has to be maintained like any other desire. There are two components to it: wishing for something, and not least, not getting the something that is desired. If you wish for something it’s because you don’t have it yet, right?

If you didn’t already understand, the solution is simple: don’t let him have the something that he wants, so that he will be perpetually motivated to work hard in order to get it. He wants a training? Organise the training then make sure you are sending there the persons that are the least interested in it. He will see that he has a chance, but it wasn’t his turn right now.

Maybe this will sometimes be a challenge for management, but with a lot of carefulness it can be made possible! Keep the desire alive!

Another advice in regards to trainings: to keep the desire alive it is useful to send him to trainings in which he isn’t interested, but in which somebody else is interested. This way you will always have employees interested in trainings and having trainings, and also motivated!

When he is working he shouldn’t be able to see the usefulness of his work, it is very important. If he will see it, how can he be motivated still? It’s like climbing a mountain, no climber is motivated to go on if he knows how high he already is. You must be careful not to let him know where he is standing: keep those statistics and progress reports well hidden, because if he gets to have a feeling of ending, of target reached, of goal achieved, how would it be a true challenge then?

And don’t forget to not show him trust, he must build it for himself. You should provide him with a target and then keep it just a target. Indeed, a target achieved provokes pleasure and the satisfaction of a job well done, but is that what you want to show? Think about it, each time you congratulate him for his work will he be more motivated? Why try to stimulate him to improve when you can stimulate him to reach a target that he can’t. Don’t show him you trust him, let him struggle, let him feel the challenge.

In Romania we have a saying: “the known road is the shortest”. Regardless, some try to automate rudimentary tasks. Basically they are trying to eliminate the known road. Actually, if you prevent him from automating processes you are helping him remain busy, to have a busy mind, and a busy mind is an active mind!

And, secondly, with this approach you are helping him maintain his work place. Maybe he doesn’t realise it, but he will lose his purpose when he will remove exactly the tasks which, eventually, he knew so well, because he made them so many times… Programmer or not, he mustn’t be replaced by a robot!

Thirdly, it’s the satisfaction you get of walking the known road – don’t let him divert from it, because, it’s so well known that it should be finished quickly enough.

And never forget that you must teach him the importance of management. He must see that you can help him, that you are the key to his success and happiness. To show this it is very important to trust yourself. Try to organise a party and don’t invite him. Nothing says more “I could’ve been there” than not being there.

Another way is to organise a business trip in an exotic location. Don’t worry, it’s not important to actually have something to do there. While you’re there, don’t forget to have fun, it is very important for him to know that you’re enjoying yourself. When it gets though, you have to remember that you’re not doing this for you, you are doing your best to have fun for his and his imagination’s benefit!

Maybe some suggestions will not work for everybody, but you have to combine as many of them as possible to have a real success and keep your programmers truly motivated!

Don’t try to identify this utopian world, because any resemblance with the daily reality is purely coincidental.

Written by Claudiu Persoiu

4 April 2016 at 9:39 PM

Posted in Diverse

Tagged with ,

PHP6, just another story… (PHP6 and the books)

without comments

It’s finally over, the war has ended. PHP7 was released, and PHP6 will remain only a legend, a story of the version that never was.

After a while I don’t think anybody expected it to be released anymore. Afterall, it’s been almost 10 years, out of the entire lifetime of 20 years for PHP.

But how can such a highly anticipated version never show up?

Let’s begin from the start, when, almost 10 years ago, PHP was becoming a “serious” language. After the PHP5 version, the object module was finally having specific visibility for methods and properties, objects were no longer copied, but sent by reference. These changes triggered a multitude of object oriented frameworks, which were now also targeting the enterprise environment, not only small websites.

In all this context there was a problem, internationalisation.

This is how PHP6 appeared, it should have used natively Unicode, more specifically UTF-16. This way everything would have been processed in a unique and international format.

The project was started and maintained by Andrei Zmievski. Maybe today not many people know much about Andrei, but 10 years ago he was very popular for projects like Smarty and PHP-GTK.

After a few years the project got stuck, and then PHP5.3 appeared. Even though it was bringing important changes, it wasn’t a major version because there was still hope that one day there will be a PHP6.

There were however some people full of hope! And even more, they were ready to cash in on this bright hope!

Either authors or editors, they knew one thing when it came to books (especially technical ones) that they have two properties: a target audience and a period of relevance.

Let’s analyse the results.

PHP_6_and_MySQL_5_for_Dynamic_Web_Sites_Visual_QuickPro_GuidePHP 6 and MySQL 5 for Dynamic Web Sites: Visual QuickPro Guide (3rd Edition) (Peachpit Press – 2008) – Larry Ullman

Larry wrote several books, including: “PHP and MySQL for Dynamic Web Sites: Visual QuickPro Guide (2nd Edition)” and of course “PHP and MySQL for Dynamic Web Sites: Visual QuickPro Guide”.
Coincidentally, I had the opportunity to flick through all three books, but not in chronological order, I just randomly started with “PHP and MySQL for Dynamic Web Sites: Visual QuickPro Guide (2nd Edition)”. What is interesting is the striking resemblance, basically a 6 was added to the title and the rest is almost the same.

In general, all books from Visual QuickPro Guide collection are targeting beginners, and from an edition to the next things don’t change too much, they are only adjusted.

Professional_PHP6_Wrox_Programmer_to_ProgrammerProfessional PHP6 (Wrox 2009) – Ed Lecky-Thompson, Steven D. Nowicki (Thomas Myer)

It’s interesting that in the cover image there are three authors, but on Amazon.com and on Wrox there are only two names, that’s why I wanted to single Thomas Myer out.

This makes me wonder if Thomas Myer purposely asked to be removed or were there other factors at play? It’s strange to have your name on the book but not in the author listing of the publisher’s website.

Not coincidentally there is also a “Professional PHP5” – Ed Lecky-Thompson, Heow Eide-Goodman, Steven D. Nowicki, Alec Cove.

PHP_6_MySQL_Programming_for_the_Absolute_BeginnerPHP 6/MySQL Programming for the Absolute Beginner (Cengage Learning PTR – 2008) – Andrew B. Harris

It’s truly a strange book, there isn’t a PHP5 equivalent, and even more, on the writter’s website there isn’t any other PHP book.

Could there be a reason for that? In Larry Ullman’s case it’s just another covered subject, additional audiences targeted, but in this case it’s just strange, a single author, a single PHP book for a ghost version, published in 2008.

PHP_6_Fast_and_Easy_Web_DevelopmentPHP 6 Fast and Easy Web Development (Cengage Learning PTR – 2008) – Matt Telles, Julie C. Meloni

It wasn’t very difficult to also find: “PHP Fast & Easy Web Development” – Julie C. Meloni.

What is strange about this book is that Matt Telles doesn’t have any other PHP books, even though he wrote some for Python, C# and C++.

Something tells me he was brought in just to adjust the original book for the new context. I thought it was just a personal supposition, but upon searching on Google I found he is also Technical Reviewer for “PHP 6/MySQL Programming for the Absolute Beginner (Cengage Learning PTR)”, book that I covered above.

Beginning_PHP_6_Apache_MySQL_6_Web_DevelopmentBeginning PHP 6, Apache, MySQL 6 Web Development (Wrox – 2009) – Timothy Boronczyk, Elizabeth Naramore, Jason Gerner, Yann Le Scouarnec, Jeremy Stolz

The original book was obviously: “Beginning PHP, Apache, MySQL Web Development” – Michael K. Glass, Yann Le Scouarnec, Elizabeth Naramore, Gary Mailer, Jeremy Stolz, Jason Gerner.

Michael K. Glass and Gary Mailer got out and in their place Timothy Boronczyk went in.

PHP was a very fashionable language in that period, and PHP6 was very awaited.

But how can something like this be? How can there be some many books from important publishers for a programming language that never existed? The answer is simple: greed.

There are two possible explanations: either the author tried to seize the market with a new version, or the publisher wanted to force it, in the hope of coining the market. Probably the hope was that when PHP6 was coming out, they would have already have the books ready for shipping.

This was another reason for not to rename PHP NG version into PHP6, it would have meant that a PHP version would have come out with a series of books already published, and what’s more, they were published for several years already.

I bet that when the vote between PHP6 and PHP7 was happening there were some very hopeful editors.

And now I wish you all, a pleasant reading!

Written by Claudiu Persoiu

22 February 2016 at 9:11 PM

Posted in PHP

Tagged with ,