DEV Community: Maroje Macola

Beware of PHP’s strcmp() function when sorting

Maroje Macola — Mon, 16 Aug 2021 12:15:46 +0000

I was looking for a way to sort an array of objects via multiple properties, which are calculated on the fly. As usual, quick googling navigated me to the Stack Overflow, where I found the same question and, most importantly, answers for it.

Problem with suggested solution

Even though everything seems good at first when comparing one-digit numbers, it doesn't go well when multi-digit numbers come into play:

echo strcmp('7', '111'); // 6 (expected -104)
echo strcmp('18', '9'); // -8 (expected 9)

What happened here? Numbers are not being compared as a whole.
In the first example, number 7 is compared with the first digit of the value 111, and their difference is 6.
In the second example, first digit of the number 18 is compared with number 9, and their difference is -8.

To be precise, a binary comparison is being done in the background. strcmp is one of many functions which are taken from the C language.

Implemented solution

To solve this problem, we don't need strcmp or any other helper function. If we are sure that compared arguments will be integers, we can simply use good ol' subtraction to get the needed result (negative, 0 or positive):

usort($arrayOfElements, function ($firstElement, $secondElement) {
  return $firstElement->getSize() - $secondElement->getSize();
});

Additionally, if you need to sort values in a descending order, just swap the subtrahend and minuend:

return $secondElement->getSize() - $firstElement->getSize();

Conclusion

Copy-pasting solutions from Stack Overflow without enough research can result in big damage.
In my case, the problem was not visible for a few days because of the values being used for testing.

Make sure to check the documentation and spend more time testing solutions.

If you have encountered similar problems by doing c/p from SO, let us know in the comments :)

Transferring files between local machine and AWS instance

Maroje Macola — Mon, 22 Mar 2021 15:35:44 +0000

Hello fellow dev.to readers!

Intro

Recently, I needed to transfer files from local machine to the remote AWS instance. Since I haven't done this before, after a quick googling, I stumbled upon a cool bash command scp (secure copy). After seeing secure keyword in its name, I didn't waste time on looking for other solutions, although I believe there are many. Therefore, let's take a look at how can we use it.

`scp` command

Generally, with this command, we are able to do 3 types of file transfers:

from local to remote machine
from remote to local machine
between two remote machines, by using local machine

In this post, we will cover first 2 cases.

To get a list of available options for scp command, we can run scp help:

$ scp help
usage: scp [-346BCpqrv] [-c cipher] [-F ssh_config] [-i identity_file] [-l limit] [-o ssh_option] [-P port] [-S program] source ... target

A comprehensive list with detailed explanations can be found here.

[-i identity_file] parameter will be of use for our case of communicating with AWS instances, since we need to use private key which is also used for ssh connection with the server.

[-r Recursively copy entire directories] parameter will be of help to transfer whole directory.

Local -> remote file transfer

Scenario - transferring an image from the local machine's Downloads folder to AWS server, which has ec2-user and IP address 192.168.1.1:

scp -i ~/.ssh/key ~/Downloads/image.png ec2-user@192.168.1.1:~/deployment/current/public

Let's segment command for easier understanding:

-i ~/.ssh/key specifying path to the identity_file, key which you also use for ssh connection with your AWS instance
~/Downloads/image.png specifying path to the file which we want to transfer from local machine
ec2-user@192.168.1.1 specifying AWS user and IP address of the remote instance
~/deployment/current/public specifying path to the destination directory on the remote instance (where transferred file will exist after execution)

Remote -> local file transfer

Scenario - transferring src directory from AWS server, to the local Downloads folder:

scp -i ~/.ssh/key -r ec2-user@192.168.1.1:~/deployment/current/src ~/Downloads

Let's segment command for easier understanding:

-i ~/.ssh/key specifying path to the identity_file, key which you also use for ssh connection with your AWS instance
-r ec2-user@192.168.1.1 specifying AWS user and IP address of the remote instance, this time with -r option we say that we want to transfer directory recursively
~/deployment/current/src specifying path to the directory which we want to transfer to from AWS server
~/Downloads specifying path to the destination directory on the local machine (where transferred file will exist after execution)

Conclusion

scp is a very powerful command which allows us to easily transfer files between local and remote AWS server. As mentioned in one of the paragraphs, it has many additional options to be used, but we only need a few of them to be able to do a basic data transfer.

How do you transfer files between your servers? 🙃

Cover image source

Consequences of updating cron jobs within Ansible's playbook

Maroje Macola — Mon, 14 Dec 2020 13:20:53 +0000

Hello fellow dev.to readers!

Should you read this?

Today, I am writing about a smaller issue which occurred to us recently. More precisely, I will show you the pitfall and how we dealt with it.
If you have written a cron job within Ansible's playbook, but have never updated its values afterwards, you are a perfect reader for this post. Other than that, if you are interested in Ansible and want to learn something new, read on!

Cron job example

---
- hosts: all
  tasks:
    - name: Send emails about expiry dates
      cron:
        name: "Send expiry date emails (runs each day, 15 minutes after midnight)"
        minute: "15"
        hour: "0"
        job: "php path/to/console email-expiry-dates/send-email"

So, what do we have here?
It's a simple job which runs every day at 00:15 per server's time and executes a command which sends some emails.

If we would want to get a list of all cron's on the server, we could execute crontab -l on the server, and get something like this:

#Ansible: Send expiry date emails (runs each day, 15 minutes after midnight)
15 0 * * * php path/to/console email-expiry-dates/send-email

Updating cron job

Let's say that server's current time zone is UTC+00:00, and a change request comes up for the existing cron job, something like:

Emails should be delivered right after midnight in New York's time zone

What did we do to implement necessary changes? Updated cron job's execution time, but also its name (or we can say, the description):

---
- hosts: all
  tasks:
    - name: Send emails about expiry dates
      cron:
        name: "Send expiry date emails (runs each day, 15 minutes after midnight in New York's time zone)"
        minute: "15"
        hour: "5"
        job: "php path/to/console email-expiry-dates/send-email"

After deploying and listing server's cron jobs, we expected to have a single job as before, but with updated values, respectively. This was the actual result:

#Ansible: Send expiry date emails (runs each day, 15 minutes after midnight)
15 0 * * * php path/to/console email-expiry-dates/send-email

#Ansible: Send expiry date emails (runs each day, 15 minutes after midnight in New York's time zone)"
15 5 * * * php path/to/console email-expiry-dates/send-email

What happened after update?

The result was 2 cron jobs. The old one stayed as is and the new one, with different parameters, was added to the list. Therefore, the same command was being executed 2 times a day, which definitely was not part of the acceptance criteria.

Since the name was changed, Ansible recognised this as a new cron job. This resulted in an unsynchronised state between server's and playbook's cron jobs.

Fixing the unexpected problem

---
- hosts: all
  tasks:
    - name: Old (Send emails about expiry dates)
      cron:
        name: "Send expiry date emails (runs each day, 15 minutes after midnight)"
        minute: "15"
        hour: "0"
        job: "php path/to/console email-expiry-dates/send-email"
        state: absent
    - name: Send emails about expiry dates
      cron:
        name: "Send expiry date emails (runs each day, 15 minutes after midnight in New York's time zone)"
        minute: "15"
        hour: "5"
        job: "php path/to/console email-expiry-dates/send-email"

As visible above, we tried to be in sync with the server, by adding another cron job (with old values). Besides that, we added an additional parameter to the old cron job - state: absent, which disabled its execution by removing it from the list of cron jobs on the server.

After deploying this fix to the server, this was a final result after listing cron jobs:

#Ansible: Send expiry date emails (runs each day, 15 minutes after midnight in New York's time zone)"
15 5 * * * php path/to/console email-expiry-dates/send-email

Yaay! A single cron job with all parameters set correctly 🎉

Conclusion

Changing a cron job's name will not result in an update of the existing cron job. Its name is some sort of an ID, and therefore should not be changed (in most cases). But, what we can do, is play around with tasks' name property, since it will not lead to the problem we occurred :)

Do you have any tips regarding this topic? I would be glad to hear them!

Journey from Junior to Mid Software Developer

Maroje Macola — Mon, 09 Nov 2020 20:27:53 +0000

Hello fellow dev.to readers!

Motivation & inspiration

I was inspired by my colleague @shockwavee, who wrote a great post about his journey to mastering React. Since I was recently promoted to (mid) Software Developer position, I wanted to reflect on some of the most important parts of the journey from junior position to the new one, in Bornfight. Why am I explicitly saying "in Bornfight"? Because every company has its own understanding & vision of seniority levels. This is just one of many things I’ve learned, and which I want to share with others, who might find it helpful, motivational or just interesting to read.

Prior experience / background

Before coming to Bornfight, as a student in my final year, I worked full-time for 6 months in a small company (there were 2 of us, me and the boss). Projects were both interesting and more complex (e.g. enterprise softwares for banks). This opportunity allowed me to get hands-on experience with a PHP framework I’ve been learning in my free time - Laravel. I look at that period as a great start for someone new in the industry.

Since both of us in the company were not very experienced developers, I quickly realised that my growth could not be fast as I wanted to.

I was longing for experienced surroundings.

For a moment, I even thought that getting a raise could fill that gap, but it couldn’t.

Changing job

Naturally, I started to look for another job. Knowledge and confidence gained here helped me in the interviews, technical questions and job assignments, which ended in getting 2 job offers:

Working on a custom software products with Symfony framework, lower salary than current, 50+ sized local agency (out of which are 15+ people in development department)
Working with Drupal (CMS) on a websites, much better salary than current, 20+ sized international agency with only 1 person in the local country with whom I would be working with

To be honest, the second offer (or “higher salary & international company”) sounded amazing, at first. After some rethinking and discussion with others, everything was pointing to the question of why did I even start to look for other opportunities? It definitely wasn’t about the money. Even though the second option had some great perks, it didn’t offer the most important one. I wanted to be surrounded with a bigger development team, with much more experience than me.

An overwhelming feeling

In late April of 2019, I started to work at Bornfight.

Fun fact: it was exactly one day after my birthday, so it increased that “new chapter in life” feeling, which I usually have after birthdays.

The first month was quite incredible. So many new things, modern working place, new faces (and forgotten names), a lot of meetings in different rooms, various departments and colleagues with different energies, new technologies and tools to work with… yes, it was overwhelming. To sum it up, it was a professional environment which included a lot of new working aspects all at once.

Project challenges

Less than 2 weeks later, I was put on a completely new project. That challenge brought a lot of smaller ones with itself. To name a few:

working in a team hierarchy with different responsibilities
collaborating with different departments (frontend, design & PM)
separating backend’s tasks & responsibilities in my mindset from frontend ones (since I previously did everything)
communicating with clients in foreign language
giving estimates for tasks, etc.

Giving extra and comparing with others

Depending on the person, moments in life like this one can go in different directions. In order to feel more comfortable in day-to-day tasks, a junior should spend some of the free time to learn more about the vast number of challenges in front of him/her. Especially if your goal is to distinguish yourself from the others or to get a promotion quicker.

But, do you need to? It took me longer than I would want, to realise that everyone has a different path (and therefore different speed of getting to specific outcome). It's normal to compare yourself with your peers, and I'm not saying that everything will always be fair, but try to be as objective as possible when comparing. Bear in mind that you might not even have a clear picture of how good or bad someone is, or that the seniors might not be aware of some of the good things you've done. After all that, even after doing your best, promotion might come just because your colleague(s) left the company and a spot with new responsibilities opens up!

Burnout

I believe that most (if not all) developers get to this point in their career, at least once.

This happened to me a few times so far. Mostly, it was because I've created an unnecessary burden for myself with a few misconceptions and bad practices:

giving an estimate which PM wants to hear, instead of the one which is correct (i.e. higher estimate)
giving a wrong estimate means that I need to work overtime for free, just so I could continue the next day without being late with my tasks
delivered code needs to be the best possible, without taking into matter the effort and value behind each solution
being wrong is bad (it isn't, just communicate it on time and be careful not to repeat it again)
expecting that every process in the workflow is already set and it's working smoothly

A combination of things mentioned throughout the whole post and bad organisational skills in terms of balancing work & private life, led to losing focus and worse health. When that happens, things can go down even faster. Company was also in the process of rearranging many processes and responsible people at the moment. To be honest, I felt so bad mentally, not only that I wanted to leave my job, but not to work at all for some time...

In that state, quitting wouldn't be a bad call. In the meantime, the actual pandemic started and changing jobs wasn't an easy option as it might be earlier. Circumstances were changing often, I started to work remotely (which I discovered to be great for me), had more time to be in nature and have quality time with others... and I've managed to get through it all! 💪🏻 🎉

Focus on what's important

Even though it seems like a unique experience, I've realised that I've learned a lot in between, and that learning part was actually the key. When I got to the state that I feel confident in my knowledge and that I'm able to solve most of the tasks by myself, my focus improved. When focus came back, I could finally involve myself in some other things than just writing code, and use other abilities as well. Sooner than later, others started to recognise it, and step by step, things fell into place.
So, in the beginning, maybe I just needed to focus mostly on bettering my core skills needed in the job, instead of focusing on many aspects just a little bit?

Take care of your health

Additional personal advice for avoiding burnout would also be to stay both physically and mentally in shape. Our job requires our focus to be in a very good condition, and we often forget that accumulated stress should be thrown out of the system through different kinds of activities & good habits, based on personal preferences (e.g. sport, meditation, socialising/having fun, good sleep, etc.).

Summary

Since the post is already long enough, and I could write about this 1.5 year journey in the company much longer, I've decided to sum it up, with possibility to extend it through new post(s).

I cannot think of any life experience from which I grew personally, that did not include both good & bad moments. If you find yourself in some of the situations above, embrace them, focus on the most important things you need to do (and are expected from you), and take care of your health. Then, everything will fall into place. And be patient.

Thanks again for reading my story. If you have any questions or would like to read more about it, let me know in the comments below. I really like to hear others' stories and experiences as well. Any additional advice for everyone would be greatly appreciated. Cheers!

How to improve your code quality with Psalm — a static analysis tool

Maroje Macola — Mon, 29 Jun 2020 11:43:37 +0000

Intro

Before going into the main topic, let’s clarify some things. “Psalm” might be hinting at something religious, but it’s just a tool name, which is short for PHP Static Analysis Linting Machine. It is meant for PHP developers — and it was made by the crew from Vimeo, who have realised some 5 years ago that they could really use a tool which will help them find unspotted bugs and/or errors before releasing their code to production.

Code quality tools

Any tool which improves our code can be classified as a code quality tool. At Bornfight, we use several of them when developing with PHP:

PHPCSFixer — coding standards fixer, for enforcing single coding standard throughout the project
PHPCPD — copy/paste detector, for detecting duplicate code
PHPMD — mess detector, for enforcing rules in areas like clean code, code size, naming etc.
PHPStan — static analysis tool, similar to Psalm

After reading the last bullet from the list, you may be asking yourself why is this post talking about Psalm, a static analysis tool that we don’t use (since it’s not on the list), and not about a similar tool, PHPStan, which we actually use. Well, my dear reader, I find that the best way to force yourself to research a topic is by writing a post or holding an education for someone. More so, if the tool proves itself useful, it can be a great addition to the existing CI pipeline or maybe even a replacement for PHPStan. Anyway, let’s go deeper into it.

Static… what?!

So, “Static Analysis Linting Machine”? Those are some quite powerful words. Static analysis obviously means that it analyses something, in this case our code, but without executing it. Word “lint” has multiple definitions online, and one of the non-software-related ones I found is “clinging fuzzy fluff that accumulates in one's pockets or navel”. Okay, it doesn’t feel like it’s helping in explanation, but I will try to use it anyway. While writing code, we (should) try our best not to make bugs. Still, no matter how hard we try, over time, before releasing it to the production, codebase (pocket) accumulates unspotted bugs (clinging fuzzy fluff). And we should strive to have both our codebase and pockets clean.

That's where Psalm steps in and helps us in achieving so (at least for codebase, we still have to clean pockets ourselves).

Give me some features

After cleaning up some questions around Psalm and static analysis tools, we are still asking ourselves, what kind of bugs or possible errors does it discover? Well, even though development with PHP can be enjoyable, it is important to be aware of its pros and cons. Since it’s an interpreted language, rather than compiled, it does not enforce type safety.

Here’s a simple example of working code:

function doubleTheNumber($number) {
  return $number * 2;
}

$number = 5;
echo doubleTheNumber($number);

But, it can also be written with type hints:

function doubleTheNumber(int $number): int {
  return $number * 2;
}

$number = 5;
echo doubleTheNumber($number);

The second way is much safer because, with type hints, we don’t allow passing non-integer values to the function, but also if we need to use the function's return value, we are sure that it will be an integer.

If we passed an empty array, running Psalm would tell us something like:

ERROR: InvalidArgument - 8:22 - Argument 1 of doubleTheNumber expects int,
array<empty, empty> provided - https://psalm.dev/004

Cool, right? Type-checking is its most important feature. Issues also contain links to the dedicated page (psalm.dev/004 in this case), with its explanation and help in fixing. By investigating and resolving an error, we are actually learning how to write better code and what are some of the bad practices in PHP and programming in general.

If you think about adding Psalm to an existing codebase, but feel like it will throw too many type-related errors, there is also a solution. One of the features is called Psalter (nope, we are still not talking about anything religious). It can fix a number of issues it finds, like adding missing type-hints, or even removing dead code, like unused variables or functions.

Another scenario could be that the codebase is massive and there is no time to fix all of the issues. But that does not mean that you should continue writing buggy code. And that’s where the Baseline feature steps in — it allows you to grandfather-in all the errors found. It stores all the errors in a file and does not mention them ever again, but it will show every new error which is produced with new code written after activating Baseline.

Since Psalm checks for many types of errors, depending on the developers knowledge and other factors, it can be overwhelming to deal with all of them. That’s where level strictness comes in handy. There are 8 levels of strictness, where number 1 is the most strict. The stricter the level, the more error types are included, and vice versa.

Sometimes, there is a need to exclude a whole directory from being analysed, or just a specific type error on a specific method. This can be done by suppressing the errors either within the configuration file or via a docblock.

Here’s an example for the latter:

class Foo {
    private string $bar = 'bar';

    public function getBar() : string {
        return $this->bar;
    }
}

$a = new Foo();
/** @psalm-suppress UnusedMethodCall */
$a->getBar();

Any level of strictness would usually throw something like:

ERROR: UnusedMethodCall - 12:5 - The call to Foo::getBar is not used

but it will not be mentioned as long as it’s suppressed.

Since Psalm supports a large number of docblock annotations, it’s important to use them in order to utilize the most out of Psalm’s type-checking feature. It even has its own annotations, called template and assert annotations. Through research so far, I feel like they are a vital part of this tool, and maybe they will deserve their own blog post, after I manage to test them out more.

Conclusion

Having non-typed code might be working at the moment, but working as a developer means to always think ahead. Writing any new code in such a codebase can be more stressful and scary, especially for a new developer on a project. As codebase gets larger and larger, and unpredicted bugs pop-up more often, introducing a static analysis tool, such as Psalm, can be very helpful in tackling those problems.

Also, through dealing with Psalms issues and warnings in the codebase, developers are learning how to write better and maintainable code, which is something that every developer should strive for. Don’t forget, less bugs means happier clients, and there’s no need to say how important that is in business!

If this post was useful to you and you’d like to know more about Psalm, let me know. After having some more practice with Psalm, I think I could write about more in-depth usage of it, or compare it with PHPStan and see where it goes.

What about you?

What are your thoughts on the subject? If you have experience with Psalm in particular, or with any other static analysis tool, I would be glad to hear your opinion about it, so feel free to leave a comment below :)

Switching between multiple Node versions with Node Version Manager

Maroje Macola — Mon, 16 Mar 2020 08:06:25 +0000

Hello dev.to readers!

Intro

This is my very first post here and hopefully many more will be written. Even though I've worked only on PHP projects, it turned out that my first post here is about switching between Node versions by using the handy tool called Node Version Manager.

Setup

Package usage is intended for MacOS or Linux, but there are some alternatives for Windows, like nvm-windows and nodist. Those alternatives are created by other developers, so there may be some similarities with features, but carry on with reading at your own risk 😁

To keep this post shorter and focused more on NVM's features, I will skip steps for installation. Nevertheless, here is a link for setup, if you're using Homebrew (it helped me!).

Tool usage

After installation, you can check which Node versions you have installed by running:

$ nvm ls

There should be none, at first. So, let's install newest Node version:

$ nvm install node
...
Now using node v13.10.0 (npm v6.13.7)
Creating default alias: default -> node (-> v13.10.0)

As we can see, when installing first Node version, it also automatically creates an alias for default version.
To install specific Node version, run:

$ nvm install 8.0.0

We can change the default Node version for every new terminal session by running:

$ nvm alias default 8.0.0

Now that we have multiple Node versions installed, we can start switching between them by simply running:

$ nvm use node
Now using node v13.10.1 (npm v6.13.7)
$ nvm use 8.0.0
Now using node v8.0.0 (npm v5.0.0)

Simple, right? Do you see some potential benefits from this? Like running different Node versions in multiple terminals at the same time? It's really awesome.

Tips

For those reading all the way down here, here is a tip regarding aliases: how about naming them after your project’s name? So you don’t need to think of, or search for project’s specific version. For example, here is an example of my alias:

$ nvm alias eotg 8.0.0
eotg -> 8.0.0 (-> v8.0.0)
$ nvm use eotg
Now using node v8.0.0 (npm v5.0.0)

Another extra tip/warning if you're using PHPStorm (or probably any other IDE):
If you need to run npm install while running specific Node version, it's not enough to just set Node version with nvm use 10.1.2. It's also necessary to set the correct Node version in your PHPStorm's preferences, for its Node interpreter. This bugged me longer than expected, so I'm writing it in hope that it might save someone the trouble 😌

Conclusion

Node Version Manager is a simple, yet powerful tool which can save us a lot of time & trouble. Here are only a number of commands to get you started and make you see the value behind it.

If you have some other tips, suggestions and/or experiences to share about Node Version Manager, let everyone else know in the comments below!

DEV Community: Maroje Macola

Beware of PHP’s strcmp() function when sorting

Suggested solution from SO

Problem with suggested solution

Implemented solution

Conclusion

Transferring files between local machine and AWS instance

Intro

scp command

Local -> remote file transfer

Remote -> local file transfer

Conclusion

Consequences of updating cron jobs within Ansible's playbook

Should you read this?

Cron job example

Updating cron job

What happened after update?

Fixing the unexpected problem

Conclusion

Journey from Junior to Mid Software Developer

Motivation & inspiration

Prior experience / background

Changing job

An overwhelming feeling

Project challenges

Giving extra and comparing with others

Burnout

Focus on what's important

Take care of your health

Summary

How to improve your code quality with Psalm — a static analysis tool

Intro

Code quality tools

Static… what?!

Give me some features

Conclusion

What about you?

Switching between multiple Node versions with Node Version Manager

Intro

Setup

Tool usage

Tips

Conclusion

Cover image source - https://miro.medium.com/max/1050/0*csTuUtvi1VdLS4le.jpg

`scp` command