DEV Community: Alessandro D'Orazio

Awesome Laravel: shift from legacy code to modern ✨

Alessandro D'Orazio — Sat, 28 Jan 2023 12:35:47 +0000

In this post, we will refactor a legacy, badly written code, in order to see an example of refactoring. As an example, we will refactor a function that generates a dynamic image from an array containing data about text to write, rectangles to draw, and images to insert.
We will send using a POST request:

An array of options containing the background color and the horizontal margin;
An array of items, for example, text or images.

Route::get('/', function() {
  $options = request()->post('options', [
    'bg_color' => '#1e2565',
    'margin_x' => 200
   ]);
   $img = Image::canvas(1200, 675, $options['bg_color']);
   $marginX = $options['margin_x'];
   $availableWidth = 1200 - $marginX;
   $items = request()->post('items', []);
   foreach($items as $item) {
    if($item['type'] === 'text' && isset($item['multiline']) && $item['multiline'] === true) {
     $perLineChars = $availableWidth / $item['size'] * 2.1;
     $exploded = explode(' ', $item['text']);
     $lines = [];
     $line = '';
     foreach($exploded as $word) {
      if(strlen($line) + strlen($word) < $perLineChars) {
       $line .= $word . ' ';
      } else {
       $lines[] = $line;
       $line = $word . ' ';
      }
     }
     $lines[] = $line;

     $currentY = $item['y'];
     $spaceBetweenLines = $item['size'] + ($item['space_between_lines'] ?? 15);
     foreach($lines as $line) {
      $img->text($line, $item['x'], $currentY, function($font) use ($item) {
       $font->file(base_path($item['font']));
       $font->size($item['size']);
       $font->color($item['color']);
       $font->align($item['align']);
       $font->valign($item['valign']);
      });
      $currentY += $spaceBetweenLines;
     }
    }
    if($item['type'] === 'text' && (!isset($item['multiline']) || $item['multiline'] === false)) {
     $img->text($item['text'], $item['x'], $item['y'], function($font) use ($item) {
      $font->file(base_path($item['font']));
      $font->size($item['size']);
      $font->color($item['color']);
      $font->valign($item['valign']);
      $font->align($item['align']);
     });
    }
    if($item['type'] === 'rectangle') {
     $img->rectangle($item['x1'], $item['y1'], $item['x2'], $item['y2'], function($draw) use ($item) {
      $draw->background($item['bg_color']);
     });
    }
    if($item['type'] === 'image') {
     $newImg = Image::make($item['base64']);
     if(isset($item['widen'])) {
      $newImg->widen($item['widen']);
     }
     $img->insert($newImg, $item['position'], $item['x'], $item['y']);
    }
   }
   return $img->encode('data-url');
});

As you can see, is hard to read, but we can improve it. The refactoring’s purpose is to make the code not only readable but more reliable and efficient.
Example of item array

[{
  'type': 'rectangle',
  'x1': 100,
  'y1': 490,
  'x2': 1100,
  'y2': 495,
  'bg_color': '#e4f1ff',
},
{
  'type': 'text',
  'text': 'Alessandro',
  'x': 160,
  'y': 572,
  'size': 36,
  'space_between_lines': 15,
  'color': '#e4f1ff',
  'align': 'left',
  'valign': 'bottom',
  'font': '/public/Lato-Bold.ttf'
}]

Note: I will omit imports, but consider that we are using the Laravel Intervention package to handle the image generation.

Step 1: Extract the logic

As the first step, we can create a new class, called ImageGenerator to generate a new image. So, we create the class and we do a simple copy-paste. This is good because we can generate a new image from outside the routing function without copy-paste the code every time.

class ImageGenerator extends Image {
  public static function generateImage($options, $items) {
   $img = Image::canvas(1200, 675, $options['bg_color']);
   $marginX = $options['margin_x'];
   $availableWidth = 1200 - $marginX;
   foreach($items as $item) {
    if($item['type'] === 'text' && isset($item['multiline']) && $item['multiline'] === true) {
     $perLineChars = $availableWidth / $item['size'] * 2.1;
     $exploded = explode(' ', $item['text']);
     $lines = [];
     $line = '';
     foreach($exploded as $word) {
      if(strlen($line) + strlen($word) < $perLineChars) {
       $line .= $word . ' ';
      } else {
       $lines[] = $line;
       $line = $word . ' ';
      }
     }
     $lines[] = $line;

     $currentY = $item['y'];
     $spaceBetweenLines = $item['size'] + ($item['space_between_lines'] ?? 15);
     foreach($lines as $line) {
      $img->text($line, $item['x'], $currentY, function($font) use ($item) {
       $font->file(base_path($item['font']));
       $font->size($item['size']);
       $font->color($item['color']);
       $font->align($item['align']);
       $font->valign($item['valign']);
      });
      $currentY += $spaceBetweenLines;
     }
    }
    if($item['type'] === 'text' && (!isset($item['multiline']) || $item['multiline'] === false)) {
     $img->text($item['text'], $item['x'], $item['y'], function($font) use ($item) {
      $font->file(base_path($item['font']));
      $font->size($item['size']);
      $font->color($item['color']);
      $font->valign($item['valign']);
      $font->align($item['align']);
     });
    }
    if($item['type'] === 'rectangle') {
     $img->rectangle($item['x1'], $item['y1'], $item['x2'], $item['y2'], function($draw) use ($item) {
      $draw->background($item['bg_color']);
     });
    }
    if($item['type'] === 'image') {
     $newImg = Image::make($item['base64']);
     if(isset($item['widen'])) {
      $newImg->widen($item['widen']);
     }
     $img->insert($newImg, $item['position'], $item['x'], $item['y']);
    }
   }
   return $img->encode('data-url');
  }
}

Now, we have to call it into the routing function

Route::get('/', function() {
  $options = request()->post('options', [    
    'bg_color' => '#1e2565',    
    'margin_x' => 200   
  ]);
  $items = request()->post('items', []);
  return ImageGenerator::generateImage($options, $items);
});

🎯 Goals achieved
✅ Reusability.

You can read the other steps (including a bonus step) here

Game theory in consensus

Alessandro D'Orazio — Wed, 21 Dec 2022 00:49:04 +0000

With the exponential growth of distributed systems (such as blockchains), consensus is definitely the problem of the century.

We can define the consensus problem as follows. Given a network in which each agent has its own preference over a set of possible decisions, the goal is to have a distributed protocol (e.g. set of rules agents must follow) that leads the network to a unique decision, without a central authority.

For example, imagine that the network should take a decision about a color. Each agent has a favorite color and wants it to be the color everyone will choose after the protocol (e.g. winning decision). That's it.

Formally, a protocol solves consensus if it satisfies three conditions:

Termination: every agent reaches a final state in a finite time
Agreement: all agents will support the same decision
Validity: the winning decision must be initially supported by at least one agent

These three conditions allow the network to stabilize to a common decision. But, this doesn't guarantee that each agent's preference has the same weight.

So, we introduce the concept of fair consensus, where the validity condition is replaced by fairness, e.g. the probability that a decision will be the winner is proportional to the number of agents that initially support it.
In this way, each agent has the same importance as the others.

Now, these conditions are sufficient if every agent is honest and doesn't try to improve their chances to win.
But in reality, this would never happen.

For this reason, we now argue about rational fair consensus, an extension of fair consensus in which there could be rational agents. A rational agent is a kind of agent that could decide to not follow protocol rules in order to gain an advantage over others in every possible way.

For example, imagine that every agent supporting the winning decision will get 100$. A rational agent could say it was supporting the winning decision also if it wasn't, only to get the reward. This is an educational example, but it isn't so different in reality as you might think. An example of "malicious" rational agents could be Byzantine agents.

Here comes game theory. Game theory studies how players (e.g. agents) would play a game (e.g. protocol) in order to have the best reward. The concept of "utility function" explains this. A utility function of an agent is a mapping of the reward (called payoff in game theory) with the final state of the game (e.g. winning decision).

In the last decades, mathematicians have been studying solutions of non-cooperative games using notions such as Nash Equilibrium to understand how players would act. A really famous problem is the Prisoner's dilemma. I suggest reading it to understand why game theory is so important.

This is the point of intersection. We don't have only to realize a consensus protocol, but we need to find a mathematical way to ensure rational agents will follow protocol rules.

If we can find it, distributed systems will be more reliable and secure for end users.

Technical Skills

Alessandro D'Orazio — Mon, 19 Dec 2022 15:52:18 +0000

Back end development

Languages: PHP (senior), Java, GoLang (junior)
Frameworks: Laravel, NodeJS

Front end development

Languages: Javascript, Typescript.
JS Frameworks: Alpine, React, Vue.
CSS Frameworks: Tailwind.
Mobile development: Ionic Framework.

Data Science and Artificial Intelligence

Languages: Python.
Libraries: Numpy, Pandas, Scikit, Tensorflow.
Tasks: Data preprocessing, data analysis, data visualization, classification and regression models.

Software Engineering

Microservices and service oriented architectures. Domain-driven design. Good knowledge on algorithms and data structures.

Web3

Languages: Solidity
Tasks: Deployed some smart contracts on Rinkeby test network. Created a DAO with Javascript and React.
Used Hardhat as development environment.