Forem: Rúdi Rocha

Stepping up in your career

Rúdi Rocha — Wed, 05 Apr 2023 21:12:13 +0000

You know… being a techie it’s not all about coding, design patterns, architecture, and funny memes while our project is being scrutinized by the CI/CD pipeline and running the tests. Part of it is also about progressing, evolving, and fulfilling our personal goals (and sometimes aiming for bigger salaries). So, if you’re working in tech, starting as an engineer, or having doubts about your career progression, I’ll dump here my honest and personal lessons. Take this as my personal changelog from my early days as a software engineer to currently managing engineering teams (let’s hope I don’t get aggressive comments on the PR [lol], this is just my contribution to your career repo!).

Understand what kind of software engineer you are

I don’t mean the stack but the way you know yourself. This topic impacts the way you face challenges as well as how you interact with others. You need to understand if you are (or want to be) a super development guru or simply have enough knowledge to stay within the development world. It seems a trivial/banal question, but especially when you’re younger or even facing imposters syndrome, it impacts the way you participate in discussions or simple tech talks. There is absolutely no problem saying “I don’t know” and it’s absolutely expected that you find people that know more than you (or pretend to). Ultimately, mastering your reactions and the awareness of your own engineering skills will help you make better decisions about the next step in your career.

Trends are something from the past

Back in my early days in tech, we were called everything but software engineers. Programmers, IT analysts, webmasters (my favorite), etc… our job wasn’t cool enough to deserve a decent name. Only after the IT market boomed, geeks began to be cool and soon the conversation topics weren’t which car is the best, but which programming language was the next big thing. I saw people fighting each other to prove their programming language of choice was the best (even when the same result could be equally achieved). Then JavaScript libraries are born every second, fattening projects all over the world (more trends to be googled if necessary). At the same time, I was debating with the same question as other engineers: “what technology shall I work with so I thrive in my career?”, not forgetting we were in a world where there weren’t yet end or other sorts of engineers… we were IT people. I ended up following down the line of having fun! When Java and C# was taken by big corporates, I was doing PHP. When e-commerce exploded and demanded huge amounts of engineers, I was doing business intelligence tools within a Microsoft environment. When JavaScript turned into a one-size-fits-all, I was advocating for different technologies for client and server-side applications. The main aspect for me was ensuring I was becoming a software engineer, not a language/framework expert (and there’s nothing wrong with that). With that in mind, I could try different worlds and apply my experience in different scopes, the best suitable techniques from other technologies. Whatever is the technology you’re working on, be sure you master it. It doesn’t matter if it is outdated… programming languages change and go! After all (private joke) PHP is, since 1994, a temporary programming language, meant to be replaced. Your everyday choices will decide where you'll be after 10 years of working in software development. The fact I didn't follow down the route of trending, even with great and profitable opportunities, allowed me to be a versatile software engineer and many years later to embrace bigger and more challenging projects, "almost" be a language-agnostic engineer, and therefore, have more open doors when looking for new projects.

Being a senior software engineer is not something you can buy

I have to say: "Senior" level is something you deserve, is something you earn from your peers. You achieve it by experiencing many failures, by delivering tons of bugs, by failing deadlines, and after all… learning from it, so tomorrow you know what to do so your project is a great success. In one way, it is a great feeling when we celebrate our successes or we try new architectures, and our code is shining in a production environment remaining untouched for many decades. On the other side, it is fantastic when our peers feel safe by having us on their team, other engineers ask us for expertise and advice, when our impact on the project sets it for success, and the business reaches success for many decades even after you left. But the truth is: Reaching all the above aspects takes time, personal commitment, and willingness to learn! It shouldn't be something you negotiate with a new job offer (because probably some company is desperate to hire a bunch of engineers). This sort of conversation gets harder when talking with young engineers (3/4 years of experience). With a very demanding and competitive industry, younger engineers are prioritizing the "senior" role title as their top objective and this can happen for multiple reasons: They want a way to distinguish themselves from their friends or peers in the same company, they want a bigger salary, they want recognition, or simply, because they know how to implement an if statement as no one else (once again, a private joke). As their manager, raising questions like "role title vs salary", "responsibility vs compensation", or "would the rest of the team respect your new role and are you prepared for it" in almost all the cases make them feel unsure and suddenly their awareness on the improvement points starts to pop up. So, if you want to become a senior engineer, please ensure all the above, and don't rush it!

Leaders or Managers are expectation traders

By avoiding micromanagement and allowing engineers to design, plan, decide, and implement the solution, we will be creating a mature and efficient team. But what's left? Leadership roles are basically the bridge between multiple parties. In this role, we are expected to (pick one or multiple) manage the project delivery, ensure technical excellence, manage people, manage roadmap execution, manage technical debt... and manage... and manage. That is why I summarise these roles as "expectation traders". The expectations are created from the starting point of any action: The first day a new engineer starts on your team, career path expectations are defined; A new performance review cycle will be defined by expectations your manager has from you and your team; When a new project is kicked off, business and tech expectations are defined. For all of these (and way more of them), you are managing the expectation of reaching success! Avoid focusing too much on your comfort zone, never assume something is obvious, be transparent in all the decision points, and be the first one triggering the difficult questions! In a leadership role, the expectation is that your team succeeds in delivering success and you take account of failures.

.Net Core for PHP engineers - Part I

Rúdi Rocha — Sun, 03 Jul 2022 13:34:41 +0000

Learning new technologies these days is becoming cheap and easy. Every day I see people of all ages, finding some content on the internet and quickly starting to build very interesting applications. Just like those “free-time-hobby-oriented engineers”, full-time engineers get comfortable with a couple of languages and frameworks and get specialized in them (even with the risk of turning to be framework experts rather than software experts). What happens then when we see other people getting specialized in other languages/frameworks and we start to wonder “should I…”? Or even realize the language/framework we know isn’t really the best for that project?
The more senior you are, the less time and patience you have to go through this. This might eventually happen because your daytime job is paying you to do so or just because you want to have some different training. Either way, in the end, we will end up applying the mindset of our favorite framework to the content we are learning (and sometimes this can go right).

In my previous working place, PHP was the dominant language. After supporting the transition from Silex to Symfony, looking forward to payments-oriented applications, PHP wasn’t our language of choice (dynamic casting, the memory usage per request, request performance, etc) compared with other languages such as Java or C#. Also, managing teams, we always need to think “how will the teams react if we ask them to develop in a different language?” and it’s not an easy conversation. Having a few conversations and “how-to’s” later, we were able to ship a few APIs to production using .Net Core, and the “should I…” feeling of engineers from other teams started to grow. So why not show everyone that, despite a few different things (language and framework topics), using .Net Core is quite easy for software engineers using Symfony?

What is .Net Core

Literally copying and pasting it’s “Free. Cross-platform. Open-source.
A developer platform for building all your apps.” (https://dotnet.microsoft.com/). With this framework, you can build desktop, web, mobile, cloud, and machine learning applications. This means that with .Net Core you can do the same thing as with Symfony using C# instead of PHP.
Also, C# is not PHP…
As a (PHP) software engineer, reading C# code can feel a bit odd. If you look to a PHP class, remove the dollar signs ($), and replace the arrows (->) with dots, it will start to become really similar to the C# code.

First things first — Differences between PHP and C

Code execution

This is probably the biggest difference between both languages.
PHP is interpreted: it means that when you write a .php* file, the PHP service can grab that file, “read” it, and execute the code.
C# is compiled: it means that you can’t just execute the code written on a .cs* file. C# is a high-level language (like PHP) that is then compiled into a CLR (common language runtime) and finally turned into native code during runtime.

Variables

Another difference: Loosely types language vs strongly typed language. PHP doesn’t require defining the variable’s type (even with recent upgrades allowing types to be defined) while using C#, there’s always a variable type.

PHP Variables example

<?php
    // this is an integer
    $numberOfHours = 12;

    // these are strings
    $firstName = 'John';
    $lastName = "Doe";
    $singleLetter = 'P';

    // these are booleans
    $truthyValue = true;
    $falseyValue = false;

    //this is a float / double
    $tirePressure = 45.4;

    //this is an Array of things
    $listOfThings = ['John', 'Jane', 'Bob', ];

    // this is the usage of a class
    $person = new Person('John', 'Doe', 'Eyq#4dsSd2234');

C# Variables equivalent

    // This is an integer
    int numberOfHours = 12;

    // This is a string - Notice usage of Quotes 
    string firstName = "John";

    // This is a Char - Notice usage of single Quotes
    Char firstLetter = 'C';

    // These are booleans
    bool truthy = true;
    bool falsey = false;

    // This is a Float
    float tirePressure = 45.4f;

    // This is a double
    double decimalVal = 23.7;

    // These are arrays of things
    // Notice that the array type and size needs to be defined
    int[] agesList = new int[5]; // array of 5 integers
    bool[] flagsList = new bool[3] { true, false, true };

    // this is the usage of a class
    User theUser = new Person("John", "Doe", "eR4jADEWer2");

The first difference we can notice is the missing “$” characters. Instead of using it to declare the variable, C# requires the variable type and then the name. Some nice to see differences:

There is a difference using integers, floats, and decimal (double) values.
Single or double quotation marks are used for different variable types. In C#, a Char is different from a String.
Arrays of data are not dynamic: there’s a fixed size and type.

C# version 3 introduced an approach of dynamic type assignment but differs from PHP when it comes to changing its own value for a different type. Consider the following example

<?php
    // PHP allows reassigning the variable with a different type
    $value = 2;
    $value = "This is now a string";

  // C# equivalent
   var value = 2;
    // the row below will trigger an exception
    value = "This is now a string";

Using var key word C# will, at compile-time, create the new variable in memory as the type of the first assignment. If the program tries to assign a new value, from a different type, an exception will be thrown like:

: error CS0029: Cannot implicitly convert type ‘string’ to ‘int’

IF statements and conditions

Both PHP and C# are very similar in many aspects. On the following examples, the only difference is in fact the way we use variables:

PHP example

<?php
    if (1 <= 3)
    {
        // execute if condition was met
    }
    else
    {
        // otherwise...
    }

    $result = 1 <= 3 ? 'Option1' : 'Option2';

C# equivalent

    if (1 <= 3)
    {
        // execute if condition was met
    }
    else
    {
        // otherwise...
    }
    var result = 1 <= 3 ? "Option1" : "Option2";

Loops

This is another topic where PHP and C# are very similar.

PHP examples

    // While
    while($flag == true) {
        // do something
    }

    // do..while
    do {

    } while($flag == true);


    // For
    for ($i = 0; $i <= 10; $i++) {
        // do Something
    }

    // Foreach 
    $names = array("John", "Jane", "Bob");

    foreach ($names as $name) {
    // do something with $name
    }

C# equivalent

    // While
    var flag = true;
    while(flag == true)
    {
        // do something
        flag = false;
    }

    // do..while
    do
    {
        // do something
    } while (flag == true);

    // for
    for(int i = 0; i<= 10; i++)
    {
        // do something
    }

    // foreach
    string[] names = {"John", "Jane", "Bob"};

    foreach(string name in names)
    {
        // do something with name
    }

Object-Oriented Programming

Both languages can be used in an OOP way. So, how can we create the same class in both languages?

PHP example

<?php
    namespace App;
    abstract class User {

        protected function disableUser()
        {
            // do something
        }
    }

    interface IPerson {
        public function doSomething();
    }

    class Person extends User implements IPerson {

        public $firstName;
        public $lastName;

        protected $createdAt;

        private $token;

        public function __construct($theFirstName, $theLastName, $token)
        {
            $this->firstName = $theFirstName;
            $this->lastName = $theLastName;
            $this->createdAt = date('Y-m-d H:i:s');
            $this->token = $token;
        }

        public function getToken() {
            return $this->token;
        }

        public function doSomething()
        {
            // something
        }
    }

c# equivalent

using System;

namespace dotNetForPHPDevelopers
{
    abstract class User
    {
        protected void disableUser()
        {
            // do something
        }
    }

    interface IPerson
    {
        public void doSomething();
    }

    class Person : User, IPerson
    {
        public string FirstName;
        public string LastName;

        protected DateTime createdAt;

        private string token;

        public Person()
        {
             createdAt = DateTime.Now;
        }

        public Person(string theFirstName, string theLastName)
        {
            FirstName = theFirstName;
            LastName = theLastName;
        }

        public Person(string theFirstName, string theLastName, string theToken)
        {
            FirstName = theFirstName;
            LastName = theLastName;
            createdAt = DateTime.Now;
            token = theToken;
        }

        public string GetToken()
        {
            return token;
        }

        public void doSomething()
        {
            // do something
        }
    }
}

Producing PHP or C# code is really similar. At this level, just a few things change, such as extending classes or implementing interfaces where the notation is a bit different.

However, C# can even give more flexibility. Notice the code regarding constructors: C# supports multiple constructors.

Still, around OOP, we can’t forget about namespaces. If PHP allows defining the class namespace by using the namespace … ; at the top of the PHP file, C# makes it possibly using:

namespace dotNetForPHPDeveloper
{
    class Person {
    ...    
    }
}

Conclusion

This is it for the first part! With this article, we can see the main similarities between both languages. The next step is to show how can we build a similar project between .Net Core and Symfony Framework! In the meantime, check this article’s code on github

Online payments :: the basics

Rúdi Rocha — Tue, 06 Jul 2021 12:23:57 +0000

Working with online payments can be challenging. From credit card payments to alternative payment methods such as Google Pay or Apple Pay, there are a few subjects you need to take in consideration beyond the technical implementation.
Check the article I made on Medium: https://rudirocha.medium.com/online-payments-the-basics-f56354caa613

Unit testing controllers with User dependency on .Net Core

Rúdi Rocha — Wed, 10 Feb 2021 02:33:47 +0000

Trying .Net Core 5.0, I’ve set some playground rules. One of them is “let’s do this with Test Driven Development”, cool right? But I've found a constraint when it comes to the authenticated users / claims dependencies.
Check the article on Medium!