Forem: Ivan Brcko

How our development team improved through mentorship 🧑🏼‍🏫📓🧑🏾‍💻

Ivan Brcko — Mon, 12 Jul 2021 16:07:27 +0000

Through my experience in the IT industry, I have experienced on my own that a high-quality mentorship is a key for rapid personal development.

Mentee me

Since I have initially turned my sails towards the web development island, I have been on the receiving end of some kind of mentorship relation. It has never been completely defined and it has more often than not lost its structure after a couple of months - closely related to the onboarding process.

Nevertheless, I have reaped the mentorship benefits greatly. The mentors I was assigned with served as an inspiration to me - both from the technical side and from the “way of thinking” side. I have tried to learn from them as much as possible, until one day I’ve started to feel confident enough to pave my own path.
As my skills developed, I have started to become more and more independent and started to discover things on my own.

And I was like:

Nice, I know everything now.

Oh boy, was I wrong…

The one thing I started to know more and more is that I know how much I don’t know.

‘me’ === ‘mentor’ ? 🤷🏻‍♂️ : 🤷🏻‍♂️

Once the mentorship has watered down, my mentors started to serve me more as guidelines, than a knowledge source. Over the years, I have become mostly independent in my work, as in my development, but mentors were still there. We have developed a healthy peer relationship.
From time to time, when I was stuck on something, I have developed a healthy habit of asking my mentors for their opinion and possible guidelines, which was enough to get unstuck but to solve my issues by myself.

With time, I started to feel like I wanted to share my knowledge with someone - I knew it was time.

Mentor me

I genuinely enjoy sharing my knowledge with others, especially the ones that seek it.
I have started to be more enrolled in the mentor position, but then, COVID struck and with it, the remote work era started.

The situation altogether was scary. Everyone was afraid of and for everyone, including themselves.
Time has shown that it could be worse, and life started to get back to normal, one small step at a time.

Our team was communicating very little, our knowledge wasn't being shared, interpersonal relationships were non-existent out of the daily work scope.

That was my time to shine and to try bringing our team back to its previous glory. Encouraged by my previous experience & my need to be a mentor, I’ve come up with some kind of a mentorship program which was highly accepted and greatly beneficial.

All hail Mentorship 2.0

The concept behind it is simple:

Everyone is assigned with a mentor
- Preferably a mentor that is working in a similar tool or technology - so, technology facing mentor
- Fallback is a soft skill mentor - i.e. CTO is a mentor to the iOS development team lead
- You can mentor max 3 people at a time
- It is not fixed - you can transfer to a new mentor
Every mentor-mentee combo is awarded a 30-minute weekly mentorship slot
- If they wish they can merge it into a single bi-weekly 1-hour slot
Topics are either predefined by the mentee or brought by the mentor
- If a mentee wants to learn something specific or needs help with an issue, he should announce it beforehand so the mentor can prepare for it
- If a mentee doesn’t have anything specific, the mentor can bring his own stuff to the table
- If no one has any knowledge related topics, a casual catching up is always a valid option - but try your best to learn something new from time to time
Evolve 😉

This program has resulted in knowledge sharing improvement, personal development boost, our work quality increase & interpersonal relationships forming.

I would suggest that every team invests a bit more in its mentoring program, the ROI is most definitely higher than expected.

Open your files with PhpStorm from iTerm2

Ivan Brcko — Mon, 22 Feb 2021 16:17:46 +0000

Did you ever CMD + click on a file path in your iTerm2 and expected that file to open in your beloved PhpStorm editor only to experience that exact file to open in TextEdit, Sublime, or something else?

Look no further, open your files in PhpStorm like a pro!

Here is the simplest of NodeJS index.js scripts:



// index.js

var http = require("http");

http.createServer(function(request, response) {
  response.writeHead(200, {"Content-Type": "text/plain"});
  response.write("Hello World. This page is running Node.js version: ");
  response.write(process.version);
  response.end();
}).listen(3000);

The road to hell,



// index.js

var http = require("http");

http.createServer(function(request, response) {
  ...
  throw new Error('Oops 🤷🏻‍♂️'); 
  ...
}).listen(3000);

...is paved with good intentions.

Firstly - you'll need to create a command-line launcher for your PhpStorm executable.

If you are not using JetBrains Toolbox:

Tools ➡️ Create Command-Line launcher

If you are using JetBrains Toolbox:

Open the Toolbox and click on the gear icon, and then on "Settings":

Configure your shell script name:

You might need to enable shell scripts, if so, do the following:

Secondly - you'll need to configure your iTerm2 to open files in PhpStorm

Open iTerm2 preferences
Go to:
Profiles ➡️ Advanced ➡️ Semantic history
Expand the dropdown menu:
Select "Run coprocess..." and paste in the following:
/usr/local/bin/phpstorm --line \2 \1
Or something else, depending on what you configured in the first step

Thirdly - reap the benefits

Voila, now when you CMD + click on a file path in iTerm2, the file will open in your beloved PhpStorm, with the selector at the respective line.

Happy file opening ✌🏻

Configure API Platform resources following DDD principles by using XML format

Ivan Brcko — Mon, 25 May 2020 09:47:33 +0000

API Platform is a powerful API building tool built on top of Symfony framework. By using it, it is almost trivial to bootstrap your API resources with CRUD functionalities by annotating your entities with @ApiResource() annotation. And this is amazing.

But as it turns out, there are some drawbacks to that approach.
By using it, you are coupling your domain entities with the API Platform resources, you are exposing your domain entities to the client, and don't even get me started on the DDD principles.

Luckily, amazing people behind API platform have thought about that, and have added to their framework a mechanism to decouple your entities from your API resources.

In this post, I'm going to show you how to configure your API resources in an XML format, decoupled from your domain models, and might add a cherry on top regarding serialization.

Let's make our entities/domain models

<?php

namespace App\Entity;

class Post
{
    private int $id;

    private string $title;

    private Comment $comment;

    public function getTitle(): string
    {
        return $this->title;
    }

    public function setTitle(string $title): void
    {
        $this->title = $title;
    }

    public function getComment(): Comment
    {
        return $this->comment;
    }

    public function setcomment(Comment $comment): void
    {
        $this->comment = $comment;
    }
}

<?php

namespace App\Entity;

class Comment
{
    private int $id;

    private string $text;

    public function getText(): string
    {
        return $this->text;
    }

    public function setText(string $text): void
    {
        $this->text = $text;
    }
}

Like so, now we have our domain models.

Let's repeat what we are aiming for:

Our domain models to be decoupled from the API platform configuration
Our domain models to not be the same as API resources

Let's configure our API resources in an XML format

First, let's tweak our API Platform configuration file to read mappings from our XML file:

// config/packages/api_platform.yaml
api_platform:
    mapping:
        paths: ['%kernel.project_dir%/config/api_platform/resources.xml']

Now after we have told the API Platform where to look for API resources configuration, the only thing left is to create our XML file.

// config/api_platform/resources.xml
<?xml version="1.0" encoding="UTF-8" ?>

<resources xmlns="https://api-platform.com/schema/metadata"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="https://api-platform.com/schema/metadata
           https://api-platform.com/schema/metadata/metadata-2.0.xsd">
    <resource class="App\Entity\Post">
        <attribute name="normalization_context">
            <attribute name="groups">post:read</attribute>
        </attribute>
        <attribute name="denormalization_context">
            <attribute name="groups">post:write</attribute>
        </attribute>
        <itemOperations>
            <itemOperation name="get">
                <attribute name="method">GET</attribute>
                <attribute name="output">App\Dto\PostDTO</attribute>
            </itemOperation>
        </itemOperations>
        <collectionOperations>
            <collectionOperation name="post">
                <attribute name="method">POST</attribute>
                <attribute name="input">App\Dto\PostDto</attribute>
                <attribute name="output">App\Dto\PostDto</attribute>
            </collectionOperation>
        </collectionOperations>
    </resource>

Our API resources configuration is pretty simple. We have made our model available as a resource, supporting a single item retrieval and item creation, but with a twist. We've also added input and output attributes to those operations.

Input and output attributes are saying which classes are accepted as objects for reading and creating a resource instance.
Or as the docs say:

The input attribute is used during the deserialization process, when transforming the user-provided data to a resource instance. Similarly, the output attribute is used during the serialization process.

We have also added attributes for serialization groups (denormalization and normalization contexts), which allow us to choose which resource attributes will be exposed during a serialization process.

Next, we should create our DTOs.

Let's create our DTOs.

<?php

namespace App\Dto;

final class PostDto
{
    public int $id;
    public string $title;
    public CommentDto $comment;
}

<?php

namespace App\Dto;

final class CommentDto
{
    public int $id;
    public string $text;
}

Great, that was easy.
Let's continue and create data transformers that will be in charge of converting our input DTO to the resource object and the other way around.

Creating data transformers

An input transformer:

<?php
namespace App\DataTransformer;

use ApiPlatform\Core\DataTransformer\DataTransformerInterface;
use ApiPlatform\Core\Validator\ValidatorInterface;
use App\Dto\PostDto;
use App\Entity\Post;

final class PostInputTransformer implements DataTransformerInterface
{
    /**
     * @var ValidatorInterface
     */
    private $validator;

    public function __construct(ValidatorInterface $validator)
    {
        $this->validator = $validator;
    }

    public function transform(PostDto $object, string $to, array $context = []): Post
    {
        $this->validator->validate($object);

        $post = new Post();
        $post->setTitle($object->title);
        $post->setComment($object->comment);
    }

    public function supportsTransformation($data, string $to, array $context = []): bool
    {
        if ($data instanceof Post) {
            return false;
        }

        return $to === Post::class && ($context['input']['class'] ?? null) !== null;
    }
}

And an output transformer:

<?php

namespace App\DataTransformer;

use ApiPlatform\Core\DataTransformer\DataTransformerInterface;
use App\Dto\PostDto;
use App\Entity\Post;

final class PostOutputTransformer implements DataTransformerInterface
{
    public function transform(Post $object, string $to, array $context = []): PostDto
    {
        $output = new PostDto();
        $output->title = $object->getTitle();
        $output->comment = $object->getComment();

        return $output;
    }

    public function supportsTransformation($data, string $to, array $context = []): bool
    {
        return $to === PostDto::class && $data instanceof Post;
    }
}

And we are done!!!
We have successfully achieved our goals:

Our models are decoupled from the API platform configuration
Our models are not resources exposed through the API

Congrats!

And as a cherry on top, let's make use of those aforementioned serialization groups.

Serialization groups configuration in XML format

Like we already did, let's update our framework configuration file first:

// config/packages/framework
framework:
    serializer:
        mapping:
           paths: ['%kernel.project_dir%/config/serializer/serialization.xml']

And now we can create that XML file and add groups to all attributes that we want to be serialized and deserialized:

<?xml version="1.0" ?>
<serializer xmlns="http://symfony.com/schema/dic/serializer-mapping"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://symfony.com/schema/dic/serializer-mapping
        https://symfony.com/schema/dic/serializer-mapping/serializer-mapping-1.0.xsd"
>
    <class name="App\Dto\PostDto">
        <attribute name="id">
            <group>post:read</group>
        </attribute>
        <attribute name="title">
            <group>post:read</group>
            <group>post:write</group>
        </attribute>
        <attribute name="comment">
            <group>post:read</group>
            <group>post:write</group>
        </attribute>
    </class>
    <class name="App\Dto\CommentDto">
        <attribute name="id">
            <group>post:read</group>
        </attribute>
        <attribute name="text">
            <group>post:read</group>
            <group>post:write</group>
        </attribute>
    </class>
</serializer>

What we configured in serialization.xml is:

When /GET request is sent to retrieve a Post, our API will expose:

{
    "id": 1,
    "title": "Title",
    "comment": {
        "id": 1,
        "text": "Text"
    }
}

When a /POST request is sent to create a new Post, we allow a Comment to be created together with it, and payload sent to the API should look like:

{
    "title": "Title",
    "comment": {
        "text": "Text"
    }
}

Thank you for sticking with me!
I hope that this post has helped you in any way.

Happy configuring!