---
title: Change your perspective on code review
summary: What is code review and how to adapt your team to it, how to approach a code review, what to look for and how other big companies do it.
tags: ["code review", "learning", "developer"]
date: 2023-08-20
cover: programming_cover.jpg
---


# What is code review?

Code review is a process where an author submits their work to be reviewed by other developers and vice versa.
This process is used to ensure that the code is of high quality and it follows the standards set by the team.   
Besides helping to keep a high-quality codebase and having clean code organization,
it also helps with something more important, which is **learning** and knowledge sharing.

I have worked on different teams and I have seen places where there are no Code Review processes, at other times developers use Code Review as a way to prove that they are right and the other person is wrong.
Later in the article, we will see which approach is the best that big companies developers do it. 


> If there is no harmony in the team, no good result will come from it.

# Real-world scenario

There are 8 steps in a code review process that developers go through in companies before it gets to production, these steps differ from company to company but most of them are as follows.  

1. The author submits the code for review
2. The reviewer reviews the code
3. The reviewer gives feedback
4. The author makes the changes
5. The reviewer approves the changes
6. The code is merged into the main branch
7. The changes are deployed into staging or pre-production for testing.
8. The changes are deployed to production

Some companies do it that at least two people review the new Pull Request before accepting it.
Others do it by randomly selecting team members.
Bigger companies did put more effort into this and they build AI tools that decides who can review the code for your Pull Request.

# How to approach a code review

The majority of the developers are used to reading PRs from top to bottom because that's how we read everything, some try to do it from bottom to top, but neither worked for me.
After reading about how other companies do it, I found out that identifying the most important part of the PR first is the best way to go.   
The best approach is to look with a Broad overview, then find out the Important parts, then focus on details.     


## 1. Broad overview

Although to identify the important part most of the time you need to know the project, but for small projects should be more straightforward.  
While scanning for the changes and identifying the more important parts, there are many tools that help you mark them or collapse them so you can focus on the important parts.


## 2. The important part

Once you have a good idea of what is being changed you should focus on the important parts of the code.
Here you take your time to check if everything is correct by focusing on the business logic and requirements and not the details.
This is the difference from the details part, here you should not focus on the code quality, but on the business logic and requirements.


## 3. Details

While you made sure that the important parts are correct, you can now focus on the details.
This is the part where you should check if the code is well organized if the code is easy to read and understand, if the code is following the standards of the team, and if the code is well documented.
Make sure the tests are covering the new code, and that the tests are easy to understand and maintain.
Make sure that the code is improving the codebase quality and not making it worse.

# The checklist

I will write a checklist that you can use to go through a PR and make sure that you are not missing anything.  
```
# Broad overview
[] Identify the important parts

# The important part
[] Are the requirements implemented correctly?
[] Is the business logic correct?
[] Is there any edge case that is not covered?
[] Are the tests covering the new code?

# Details
[] Is the code well organized? 
[] Is the code easy to read and understand?
[] Is the code following the standards of the team?
[] Is the documentation updated?
[] Are the tests easy to understand and maintain?
[] Is the code improving the codebase quality and not making it worse?
[] Do the names make sense?
```

# Automating the process

Automating the Code Review process is also something that helps you with the **Checklist** above, for example if you look for tools that do static analysis of your code, bug finders, etc.
Then you can configure and set up in a way which your team has agreed upon.

Checkout this [Github Repot](https://github.com/exakat/php-static-analysis-tools) to see a thorough list of tools you can use for PHP projects.
After implementing tools like above you will end up having a very simple checklist where it lets you focus only on the important parts.

```
# Broad overview
[] Identify the important parts

# The important part
[] Are the requirements implemented correctly?
[] Is the business logic correct?
[] Is there any edge case that is not covered?

# Details
[] Is the documentation explained well?
[] Are the tests easy to understand and maintain?
[] Do the names make sense?
```


# Commenting on a PR

Before giving feedback you should make sure that you understand the code, and that you have a good idea of what is being changed, but most importantly be curious about why the author made the changes.
When giving feedback you need to be polite and respectful, keep in mind that the author of the code is a human and your teammate.
Also, be clear and specific, and try to explain why you are suggesting the changes, be open to feedback as well, and you should be willing to discuss the changes.



# Changing the team's perspective

This is important that if you trying to do a change in the team, you need to be on the same level as the team, you need to understand how they feel about the topic, and what they know about it.    
By making sure everyone is on the same page and is on the same level, then you try to build a plan together.

### Checklist

```
[] Gather feedback from the team.
[] Make a detailed plan.
[] Present the plan to the team and ask for feedback.
[] Keep track of the team following the plan.
```

Below you will find a list of resources where you can also read more in detail about code review processes on how they affect the team speed and team morale.     

Consider this as an orientation and not a goal, because there is always room for improvement.     



**TIP:** [Google has found](https://google.github.io/eng-practices/review/reviewer/speed.html#responses) that it's very important for the individual responses to come quickly than it is for the whole process to happen rapidly, so instead of keeping the author waiting to write a comment when you will review it.

**TIP:** When creating a Pull-request, that is fixing a bug or adding a feature, don't make a lot of refactoring on top of that PR.
1. It delays the changes that might be urgent to deploy.
2. It adds more pressure on the reviewer and harder to review.
3. This should not stop you from doing refactoring changes, just add them on a different Pull-request.
> When adding a feature just add the feature and nothing out of that context. - <br/> The smaller the better.

# References 

- [Google Engineering Practices Documentation](https://google.github.io/eng-practices/review/reviewer/)
- [Meta Engineering on Improoving Code Review](https://engineering.fb.com/2022/11/16/culture/meta-code-review-time-improving/)
- [Github on Code Review]()
- [Microsoft on Code Review](https://microsoft.github.io/code-with-engineering-playbook/code-reviews/inclusion-in-code-review/)
- [Code review tools](https://blog.jetbrains.com/space/2021/12/15/best-code-review-tools/)



What is code review and how to adapt your team to it, how to approach a code review, what to look for and how other big companies do it.

Change your perspective on code review

---
title: Step-by-step Guide to Deploy Your PHP API on Google Cloud using Kubernetes and Docker
summary: Learn how to deploy your API using Kubernetes and Google Cloud, using free tier services you will be able to deploy your own code in a instance.
date: 2023-05-13
tags: [google-cloud, kubernetes, api, php, symfony, docker]
cover: kubernetes_cover.png
---

# Introduction

In this article, you will learn how to deploy a PHP API on Google Cloud using Kubernetes and Docker. You will learn how to:

* Containerize your application in a Docker image
* Create a basic Kubernetes configuration for your API
* Deploy your Kubernetes configuration to Google Cloud
* Expose your API to the internet


Before we start you need to have some things ready if you are planning to deploy your own API into Google Cloud.

1. Have a [Google Cloud account](https://console.cloud.google.com/), which you can have it as free trial.
2. Have an account on [Docker Hub](https://hub.docker.com/) where you are going to push your image into.
3. Have your API ready or just create a simple `index.php` file with a `Hello World` message,    
or use symfony skeleton by running `composer create-project symfony/skeleton simple_api`


**Optional**  

4. Have [Docker installed](https://docs.docker.com/get-docker/) in your machine.   
5. Have [kubernetes cli](https://www.docker.com/products/kubernetes/) installed in your machine, this is only if you want to try your configuration locally.

# Step 1: Containerize your application
In this step we will prepare a docker image with our code, which we will later use to deploy our API.    

Create a `Dockerfile` in the root of your project, and add the following content.

```yaml
FROM composer:latest as composer

WORKDIR /app
COPY . /app

RUN composer install

FROM php:8.2-fpm-alpine

WORKDIR /var/www/html
COPY --from=composer /app /var/www/html
```

Amazing! Let's build our docker file.
```bash
docker build -t username/simple-api:1.0.0 .
```
Next, we login into docker by running 
```bash
docker login
```
We push our built image into docker hub by running 
```bash
docker push username/simple-api:1.0.0
```


# Step 2: Create a Kubernetes configuration

The next image is trying to give you an overview of how kubernetes will communicate with different components.    
![Kubernetes cluster](/image/articles/kubernetes_overview.jpg)

The current project structure that I am using looks like the following, its a simple symfony API project.

```txt
├── composer.json
├── config
├── public
│   └── index.php
├── src
│   ├── Controller
│   └── Kernel.php
```

And for kubernetes I have the following files, which are the ones that I will explain in the next section.
```txt
├── nginx_configMap.yaml
├── nginx_deployment.yaml
├── php_deployment.yaml
├── php_service.yaml
└── projectStorage.yaml
```

![Kubernetes_components](/image/articles/kubernetes_components.jpg)

This is [the link to the github repo](https://github.com/didslm/kubernetes-template) containing the files,
this is a basic configuration of a kubernetes cluster with a php and nginx deployment.


## ConfigMap 

**ConfigMap** is a kubernetes object that allows you to store non-confidential data in key-value pairs, 
and in my case it will be used to store the nginx configuration file.   
You need to keep in mind that names and labels are important in kubernetes, 
you always refer to them in other files. [See file](https://github.com/didslm/kubernetes-template/blob/main/nginx_configMap.yaml)

## Deployment 

**Deployment** is a kubernetes object that allows you to deploy your application,
in my case I have two deployments, one for nginx and one for php.
They will be deployed in different pods, and they will be able to communicate with each other.   
[See PHP Deployment file](https://github.com/didslm/kubernetes-template/blob/main/php_deployment.yaml) and 
[See Nginx Deployment file](https://github.com/didslm/kubernetes-template/blob/main/nginx_deployment.yaml).   

Here is a part of `php_deployment` file, where I am using an initContainer to copy my code into a volume,
and then I am mounting that volume into my php container.

```yaml
# ...
spec:
  replicas: 1
  selector:
    matchLabels:
      tier: backend
  template:
    metadata:
      labels:
        app: php
        tier: backend
    spec:
      initContainers:
        - name: copy-project-files
          image: diarselimi/php-sample-api:1.0.6
          command: ["/bin/sh", "-c"]
          args:
            - cp -R /var/www/html /mnt
          volumeMounts:
            - name: tvc
              mountPath: /mnt
      containers:
        - name: php
          image: diarselimi/php-sample-api:1.0.6
          command: ["/bin/sh", "-c"]
          args:
            - chmod -R 777 /var/www/html/var
          ports:
            - containerPort: 9000
          volumeMounts:
            - name: tvc
              mountPath: /var/www
      volumes:
        - name: tvc
          persistentVolumeClaim:
            claimName: project-storage
```

## Service

**Service** is a kubernetes object that allows you to expose your application to the internet,
in my case I have one service for PHP and for exposing it to the internet I am using the command that you will see at the end of this article.   
[See PHP Service file](https://github.com/didslm/kubernetes-template/blob/main/manifest/php_services.yaml).

## Volume

**Volume** is a kubernetes object that allows you to store data in a persistent way,
in my case I have one volume for PHP and inside of PHP deployment I am mounting it to the `/var/www/html` directory.   
[See Volume file](https://github.com/didslm/kubernetes-template/blob/main/manifest/sample-volume.yaml).

Last step is to add the new image to our `php_deployment.yaml` file, by changing the line 
```diff
- image: <your-docker-hub-username>/<your-image-name>:<tag>
+ image: username/simple-api:1.0.0
```

This line is the one containing our codebase, so we need to add this to our kubernetes.


# Step 3: Deploy your Kubernetes configuration to Google Cloud

In this step we will setup our Google Cloud account, 
we will create a cluster and upload our kubernetes files in the cluster.   
Here is a short video for on google cloud platform.   

<Youtube src={"https://www.youtube.com/embed/zvM7VbNezzg"} />

After uploading my kubernetes configurations into google cloud platform, you will be able to run the following commands.

1. Apply the configurations by running 
```bash
kubectl apply -f .
```

2. You need to wait when the pods are both running, you can check that by running
```bash
kubectl get pods
```

3. Expose your external IP address so that it is accessible from everyone.
```bash
kubectl expose deployment nginx-deployment --type=LoadBalancer --port=80
``` 

4. You can get your external IP address by running
```bash
kubectl get svc
```

```bash
NAME          TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)        AGE
kubernetes    ClusterIP      10.51.128.1     <none>         443/TCP        3d19h
nginx         LoadBalancer   10.51.130.146   34.75.23.208   80:31852/TCP   27h
php-service   ClusterIP      10.51.131.237   <none>         9000/TCP       29h
```

# Cleaning up 

If you want to stop and clean up your cluster so that it doesn't spend your credits, first you need to delete your uploaded config files.
```bash
rm nginx_configMap.yaml nginx_deployment.yaml php_deployment.yaml php_services.yaml sample-volume.yaml
```
then you need to run the following command to stop everything
```bash 
kubectl delete pvc,pv,deployment,pods,configmap --all 
```
You can also delete the cluster and that way everything is deleted.
![Delete cluster in google cloud](/image/articles/delete_a_cluster.png)

### Conclusion

In this article, you learned how to deploy a PHP API microservice on Google Cloud using Kubernetes and Docker.   
You can use these steps to deploy any type of application on Google Cloud.


Learn how to deploy your API using Kubernetes and Google Cloud, using free tier services you will be able to deploy your own code in a instance.

Step-by-step Guide to Deploy Your PHP API on Google Cloud using Kubernetes and Docker

---
title: "The PHP library for smoother file uploads"
summary: "This library will let you handle file uploads in your PHP projects as an expert, no matter the framework you use."
date: 2023-04-30
tags: ["php", "file-upload", "library"]
---

# File Upload Wrapper

The File Upload Wrapper is a PHP library that simplifies file uploads by providing a set of easy-to-use classes that handle common validation and processing tasks. 
With this library, you can:

- Validate uploaded files with ease
- Process uploaded files with targeted validations for specific fields
- Simplify the file upload process with a set of easy-to-use classes

# Getting Started

To use the library, follow these steps:

1. Install the library using Composer:

```sh
composer require didslm/file-upload-wrapper
```

2. Import the classes you need:

```php
use Didslm\FileUpload\Uploader;
use Didslm\FileUpload\UploaderInterface;
use Didslm\FileUpload\File;
use Didslm\FileUpload\Validation\FileSize;
use Didslm\FileUpload\Validation\FileType;
use Didslm\FileUpload\Validation\Dimension;
use Didslm\FileUpload\FieldValidation;
use Didslm\FileUpload\Attributes\Image;
use Didslm\FileUpload\Attributes\Document;
use Didslm\FileUpload\Exceptions\FileUploadException;
```

3. Use the `upload()` method to handle file uploads for your entity:

```php
class Product {
    #[Image(requestField: "request_field", dir: "/public")]
    private string $image;
    
    #[Image(requestField: "profile_field", dir: "/public")]
    private string $profile;
    
    // ...
}

$product = new Product();

Uploader::upload($product, [
    new FileType([File::JPEG]),
    new FileSize(2, File::MB)
]);

```

4. The same exmaple you can do via Dependency Injection:

```php
class ProductController {
    public function __construct(private UploaderInterface $uploader){}
    
    public function upload(Request $request)
    {
        $product = new Product();
        
        $this->uploader->upload($product, [
            new FileType([File::IMAGES]),
            new FileSize(2, File::MB)
        ]);
    }
}
```

At the end of this document you can see how to configure in Laravel or Symfony.

----

# Examples

### Handling File Uploads for an Entity

The following code shows an example of how to use the library to handle file uploads for an entity:

```php
class Product {
    //...
    #[Image(requestField: "request_field", dir: "/public")]
    private string $image;
    
    #[Image(requestField: "profile_field", dir: "/public")]
    private string $profile;
    
    public function getImageFilename(): string
    {
        return $this->image;
    }
    
    public function getProfileFilename(): string
    {
        return $this->profile;
    }
}

```

In this example, the `Product` class has two properties `image` and `profile` that are decorated with the `Image` attribute. 

### Types

In the following example you will see a list of available Attribute types:

```php
#[new Image(requestName: 'file_upload_field', dir: '/upload/dir')]
#[new Document(requestName: 'cv_file', dir: '/upload/dir')]
#[new Video(requestName: 'video_file', dir: '/upload/dir')]
```

The `Image` attribute provides metadata to the library to process the files correctly during the upload.

The `Document` attribute provides metadata to the library to process the files correctly during the upload.

The `Video` attribute provides metadata to the library to process the files correctly during the upload.

The `upload()` method is then called on the `Uploader` class with the `Product` object and an array of validation rules as its parameters.

```php
$product = new Product();

Uploader::upload($product, [
    new FileType([File::JPEG]),
    new FileSize(2, File::MB)
]);

echo $product->getImageFilename();

```

# Handling Exceptions

The library provides a `FileUploadException` class that all exceptions thrown by the library extend. This means that you can catch all exceptions using `FileUploadException` in a try-catch block, as shown below:
```php
try {
    Uploader::upload($product, [
        new FileType([File::PNG]),
        new FileSize(2, File::MB)
    ]);
} catch (FileUploadException $e) {
    // handle exception
}
```

# Validation

The library provides several validation classes that you can use to validate uploaded files. These classes can be passed as parameters to the `upload()` method to specify the validation rules for the files being uploaded.


### Type

The `FileType` class is used to check the file type. You can specify the types of files allowed by passing an array of file types to the constructor. For example:

```php
new FileType([File::PNG, File::JPEG, File::GIF])
```

### Size

The `FileSize` class is used to validate the file size. You can specify the maximum file size allowed by passing the size in bytes to the constructor. Alternatively, you can use the Size class to specify the size in a more readable format. For example:
```php
new FileSize(2, File::MB)
new FileSize(200, File::KB)

```

### Dimension

The `Dimension` class is used to validate the dimensions of images. You can specify the maximum width and height of the image by passing them as parameters to the constructor. For example:
```php
new Dimension(200, 200)
```

### Targeted Validations

You can also target specific fields in your entity with a set of validations. 
To do this, you can use the `FieldValidations` class, which takes the request field name as it's first parameter and an array of validation rules as its second parameter. Here's an example:

```php
$profileValidations = new FieldValidations("profile_field", [
    new Dimension(200, 200),
    new FileSize(2, File::MB)
]);

Uploader::upload($product, [
    new FileType([File::PNG, File::JPEG, File::GIF]),
    $profileValidations,
]);
```

In the example above, we are specifying a set of validation checks that apply to the profile field in the Product entity. These checks will only be applied to the profile image uploaded by the user.

# Frameworks Implementation 

The library is framework agnostic, which means that you can use it with any framework.

The following sections show how to configure the library in some of the most popular frameworks.

## Symfony 

In your Symfony app you can easily configure the library in your `services.yaml` file:

```yaml
services:
    Didslm\FileUpload\:
        resource: '../vendor/didslm/file-upload-wrapper/src/*'
```

## Laravel

In your Laravel app you can easily configure the library in your `AppServiceProvider.php` file:

```php
public function register()
{
    $this->app->bind(UploaderInterface::class, function (){
         return UploaderFactory::create();
    });
}
```

-----
Handling file uploads can be a complicated and error-prone task, but with this library, you can simplify the process and focus on building the features that matter. If you have any questions or feedback, feel free to reach out to the author on [Twitter](https://twitter.com/slmdiar) or [LinkedIn](https://linkedin.com/in/diarselimi).

This library will let you handle file uploads in your PHP projects as an expert, no matter the framework you use.

The PHP library for smoother file uploads

---
title: How to start contributing in open-source.
summary: This article is meant to tell you how easy it is to start contributing on public repositories and get feedback from people with a lot of experience.
date: 2023-02-02
tags:
  - opensource
  - php
  - career
---

# Find a project

First and foremost to contribute to an open source you need to decide on what language you want to work in.
After that at least we have something to search for which gives us a sense of direction.

# Let's start

**1. First, we choose a project we want to contribute.**

I've chosen a project I want to contribute, and that is [PHPUnit library](https://github.com/sebastianbergmann/phpunit),
you can also navigate to the [issues tab](https://github.com/sebastianbergmann/phpunit/issues) and see what you can help with.

**2. Find something to fix.**

You can either go through open issues or just go into the project and explore where you could improve the code as much as a
piece of code moving it out of a big method into a separate method.

**3. Fork the repository and clone it in your machine.**

To actually start changing things you first need to fork the repo and clone it into your local machine.
As you can see I have [forked the PHPUnit repo](https://github.com/didslm/phpunit), now I need to clone it and start changing code.

```terminal
git clone git@github.com:didslm/phpunit.git
```

**4. Do the changes you want to do and push.**

Before doing changes, create a new branch

```terminal
git checkout -b docs-improovements
```

In this code I have decided I want to improve the class and initialization, you can see it in this [Pull-Request](https://github.com/sebastianbergmann/phpunit/pull/5156).

**5. Create the Pull-request but make sure to read the rules if there are any.**

After this, some people are going to review and either accept or decline your Pull-request but for the purpose of this article, I will create a pull request like this and send it.

# Where to go from here

You can either go on [github.com/trending](https://github.com/trending) and explore projects that people have created or go to [dev.to](https://dev.to).
I will make a list that you can start working on if you feel positive that you want to do this.

1. [PHP project github.com/phpunit](https://github.com/sebastianbergmann/phpunit)
2. [PHP project github.com/env](https://github.com/didslm/php-env)
3. [GO project github.com/env](https://github.com/didslm/env)
4. [C++ project github.com/json](https://github.com/nlohmann/json)
5. [Learning for begginers project github.com/web-dev-for-begginers](https://microsoft.github.io/Web-Dev-For-Beginners/#/)
6. [PHP project github.com/uuid](https://github.com/ramsey/uuid-doctrine)
7. [Docker project github.com/nginx-php](https://github.com/didslm/nginx-php-skeleton)

Happy coding 👩🏻‍💻 🧑🏼‍💻


This article is meant to tell you how easy it is to start contributing on public repositories and get feedback from people with a lot of experience.

How to start contributing in open-source.

---
title: Loading environment values into PHP classes
summary: Load environment variables with this library into php classes, easy to use and test, you can easily contribute to this open source project, code logic is very small and there is no learning curve.
tags:
  - library
  - php
  - opensource
date: 2023-02-01
---


### **The Env library**

The goal of this library is to be able to load Environment values into PHP Objects.

This library is a simple one where it loads basic types of values and does not cover arrays or any other logic except what is explained here.

### **Installation**

If you have already set up your project in PHP and you want to install the library, then all you need to do is execute the following.

```console
$ composer require didslm/env
```

### **Basic usage**

After installing this library you can simply use it by importing it and passing the **object**.

The following example will show you, how you can use this with a simple object which contains attributes as a reference to the environment variable name.

```php

<?php

use Env\EnvName;


class SomeApiClientConfig
{
    #[EnvName('EXAMPLE_API_BASE_URL')]
    public string $baseUrl;

    #[EnvName('EXAMPLE_API_ACCESS_TOKEN')]
    public string $accessToken;

    #[EnvName('EXAMPLE_API_SECRET_TOKEN')]
    public string $secretToken;
}

```

### Advanced usage

In this other example you will see how you can use this library by having one central place for all your environment variables, distributed into their own objects.

The most important part here is the attribute inside objects which is named **`EnvName`** .

```php

<?php

use Env\EnvName;
use Env\EnvObj;

class Config
{
    #[EnvObj]
    public DbConfig $mysqlConfig;

    #[EnvObj]
    public SomeApiClientConfig $apiExampleConfig
}

class SomeApiClientConfig
{
    #[EnvName('EXAMPLE_API_BASE_URL')]
    public string $baseUrl;
    #[EnvName('EXAMPLE_API_ACCESS_TOKEN')]
    public string $accessToken;
    #[EnvName('EXAMPLE_API_SECRET_TOKEN')]
    public string $secretToken;
}

class DbConfig
{
    #[EnvName('DB_HOST')]
    public string $dbHost;
    #[EnvName('DB_USER')]
    public string $username;
    #[EnvName('DB_PASSWORD')]
    public string $password;
    #[EnvName('DB_DATABASE')]
    public string $database;

}

$config = new Config();
Env::populate($config);

echo $config->mysqlConfig->dbHost;
```

```console
$ some_host_123
```

Now you can see the attributes types in the objects which contain **`EnvObj`** and **`EnvName`** , the library will look and fill them with necessary data.

### Contribution

The library is very new and does not contain much logic, if you are new into PHP and want to contribute to this project feel free to create a pull request and I will review your code.

Your chance to start contributing when a project is small are way higher because there is no learning curve there is just one method that does the job.

You can support by writing test scenarios which also help a lot on making the library more stable on future functionalities.

If you are not ready to contribute then I would appreciate any other support [GitHub repository](https://github.com/didslm/php-env) like give it a star ⭐ if you think it's worth it.

### Conclusion

The env library will provide you with a simple functionality which can help you load your environment values into PHP objects.

You can easily start contributing into this library, by adding functionalities for supporting arrays.


Load environment variables with this library into php classes, easy to use and test, you can easily contribute to this open source project, code logic is very small and there is no learning curve.

Loading environment values into PHP classes

---
title: Loading environment values into go Structs
summary: Load environment variables with this library into go structs, easy to use and test, you can easily contribute to this open source project, code logic is very small and there is no learning curve.
tags:
  - library
  - go
  - opensource
date: 2023-01-25
---

### **The Env library**

The goal of this library is to be able to load Environment values into GO structs.

This library is a simple one where it loads four types of values and does not cover arrays or any other logic except what is explained here.

Supported types are **`string,int,int32,int64,float32,float64,bool`** .

### **Installation**

If you have already set up your project in GO and you want to install the library, then all you need to do is execute the following.

```terminal
go get github.com/didslm/env
```

### **Basic usage**

After installing this library you can simply use it by importing it and passing the **struct by reference**.

The following example will show you, how you can use this with a simple struct which contains tags as a reference to the environment variable.

```go
package main

import (
	"fmt"
	"github.com/didslm/env"
)

type ClientConfig struct {
    BaseUrl string `env:"API_BASE_URL"`
    ClientId string `env:"API_CLIENT_ID"`
    Secret string `env:"API_SECRET"`
}

func main() {
    config := ClientConfig{}
    env.PopulateWithEnv(&config)

    fmt.Println(config)
}
```

### Advanced usage

In this other example you will see how you can use this library by having one central place for all your environment variables, distributed into their own structs.

The most important part here is the tag type inside structs which is named **`obj`** .

```go
package main

import (
	"fmt"
	"github.com/didslm/env"
)

type Config struct {
    SomeApiConfig ClientConfig 'obj:""'
    MysqlConfig SqlConfig 'obj:""'
}

type ClientConfig struct {
    BaseUrl string `env:"API_BASE_URL"`
    ClientId string `env:"API_CLIENT_ID"`
    Secret string `env:"API_SECRET"`
}

type SqlConfig struct {
    Host string 'env:"MYSQL_HOST"'
    User string 'env:"MYSQL_USER"'
}

func main() {
    config := Config{}
    env.PopulateWithEnv(&config)

    fmt.Println(config)
}
```

Now you can see the tag types in the structs which contain **`env`** and **`obj`** , the library will look and fill them with necessary data.

### Contribution

The library is very new and does not contain much logic, if you are new into GO and want to contribute to this project feel free to create a pull request and I will review your code.

Your chance to start contributing when a project is small are way higher because there is no learning curve there are just three methods that do the job.

You can support by writing test scenarios which also help a lot on making the library more stable on future functionalities.

If you are not ready to contribute then I would appreciate any other support [GitHub repository](https://github.com/didslm/env) like give it a star ⭐ if you think it's worth it.

### Conclusion

The env library will provide you with a simple functionality which can help you load your environment values into go structs.

If you were thinking to contribute in open source then this is your chance to do so.

You can use this library for your project or you can contribute by adding support for other types like arrays etc.


Load environment variables with this library into go structs, easy to use and test, you can easily contribute to this open source project, code logic is very small and there is no learning curve.

Loading environment values into go Structs

---
title: CQRS explained with examples
summary: CQRS architecture allows for the separation of command and query logic, enabling independent optimization and potentially improving system performance and scalability.
date: 2022-12-23
cover: cqrs-cqs-cover.png
tags:
  - architecture
  - CQRS
  - software
---

### What is CQRS?

CQRS stands for **Command Query Responsibility Segregation**, the idea of this pattern is to have a separation
of models for updating and reading the data.

This architecture usually works well with event sourcing, as well as **Domain Driven Design** architecture.
It is fairly common to confuse this pattern with CQS and Event Sourcing, but the following diagrams and conclusion attempt to explain the differences.

Now the following is a simple Controller-service-repository diagram, which will show a simple use-case, fetching data of the order and returning it.
![Normal crud process](../../static/images/normal_crud_process.jpg)

Next is a transformed model trying to achieve CQRS, notice how the separation extends all the way to storage.
![Separate storage CQRS](../../static/images/cqrs_separate_storage.jpg)

There are cases where you can apply this pattern, but you have one storage in that case, it would be **CQS** since we are not segregating Responsibility instead just the Command and Query.
A diagram would look something like this.
![Same storage CQRS](../../static/images/cqrs_same_storage.jpg)

### Real-world scenario

Suppose you have an online store where you can browse items, select some items, and confirm your order.
Your system in the background will execute something like in the following diagram, after you click the purchase button.
![Order command model](../../static/images/order_command_model.jpg)
After the write, the data or the event will trigger a DB sync listener.

### Benefits

- Better visibility: Distinguishing between read and write models.
- Simplified development: easier for developers to implement complex business logic and data access patterns because it provides a clear and well-defined way of separating read and write operations.
  This can help reduce the complexity of the code and make it easier to understand and maintain.
- Better consistency: CQRS can help ensure that data is always consistent because it forces all write operations to be processed through a single, well-defined command interface. This can help prevent conflicting updates and other inconsistencies that can occur when multiple writers are allowed to access the same data.

### Drawbacks

- Increased complexity for simple systems: CQRS may be overkill for simple systems that do not require the additional separation of read and write models.
- Performance overhead: CQRS architectures may introduce additional overhead when reading and writing data, as the system needs to route requests to the appropriate model and possibly perform additional processing.
- Lack of consistency: CQRS architectures can make it more difficult to maintain consistency between the read and write models, as changes made through the write model may not be immediately reflected in the read model.

### Conclusion

**CQRS** can be used in any project small or big, usually it provides more benefits like having a full separation of objects, data transformers, services, etc.

Sometimes just **CQS** would do the trick on helping you have a nice separation of commands and queries, this way you would not slow down on having a fully separated system,
although you should be careful in doing that and start the planning for transitioning to the **CQRS** architecture as soon as you know the business expectations.

**CQRS** is good when you are dealing with a lot of writes and reads, if your application is starting to get traction and grow in terms of users, you should already start considering.

If you are starting a new project and want to implement CQRS, which will be relatively straightforward and easy, the difficult part will be refactoring an existing project to follow a CQRS design.

To successfully refactor an existing project to follow a CQRS design, it is necessary to thoroughly investigate the current system and make careful decisions about the best approach. A plan will need to be developed to guide the refactoring process.


CQRS architecture allows for the separation of command and query logic, enabling independent optimization and potentially improving system performance and scalability.

CQRS explained with examples

---
title: How to make a one-year plan to become a developer
summary: Step by step plan on how to achieve and become a developer ending up having a job.
date: 2022-12-09
archive: false
tags:
  - learning
  - beginner
  - path
---

### 1 Learn the Basics

Start by learning the basics of that specific programming language.  
This includes understanding the syntax, data types, classes, objects, and other fundamentals.  
You can find plenty of online tutorials and resources to help you get started.

### 2 Get Familiar with the libraries and tools

Get familiar with what the language offers and what kind of frameworks are there already.  
Get familiar with the tools offered to work with that language, they will help you along the way.  
Try experimenting with some of the tools and libraries of that language, to get familiar with how to include them in your projects.

### 3 Learn Object-Oriented Programming (OOP)

OOP is a programming paradigm that uses objects and classes to create applications.
It is an important concept to understand when learning an Object-Oriented programming language.
Try to watch as many videos and different perspectives of explanations.

### 4 Practice Writing Code

Once you have a basic understanding of that language, start writing code.
Practice writing small programs and applications to get a better understanding of the language.

### 5 Learn Advanced Topics

Once you have a good understanding of the basics, start learning more advanced topics such as multithreading, collections, and networking.

### 6 Get Certified

Getting certified in that language is a great way to demonstrate your knowledge and skills.
There are several certifications available.
One place where you could get certified is [LinkedIn](https://linkedin.com), Coursera, etc.

### 7 Join a Community

Joining a community is a great way to stay up-to-date on the latest trends and technologies.
It also provides an opportunity to network with other developers and get feedback on your work.

### 8 Build Projects

Building projects are a great way to apply your knowledge and skills.
You can create small applications or work on larger projects.
This will help you gain experience and build a portfolio.

### 9 Stay Up-to-Date

Technology is constantly changing, so it’s important to stay up-to-date on the latest trends and technologies.
Read blogs, attend conferences, and take online courses to stay ahead of the curve.

### 10 Get a Job

Once you have the necessary skills and experience, start applying for jobs.
You can find plenty of job postings online or reach out to companies directly.


Step by step plan on how to achieve and become a developer ending up having a job.

How to make a one-year plan to become a developer

---
title: Serverless architecture
archive: false
summary: Serverless architecture is used for easy tasks that you don't have to have the whole process of deployement and maintainance.
date: 2022-12-07
tags:
  - architecture
  - serverless
  - pattern
---

### What is Serverless

These types of architecture are usually used for fast deployment and efficient scaling.
There is a Backend as a Service (**BaaS**), which you can use as a normal backend with API.
The other type is Functions as a Service (**FaaS**), in which they have one job, understandably they are smaller since they are doing one job.
It is recommended to keep them as small as possible, you need to avoid growing them large, as you will start facing limitations that will prevent
you from solving issues and doing special operations.

#### Backend as a service (BaaS)

BaaS is a pre-built backend with an API so that developers can use it to build their applications.
BaaS can be larger than Faas, or a group of FaaS make one BaaS, it's a group of functions that are accessible through some API.
You need to be careful to not add a lot of functionality, if a BaaS took 3 months to develop, you need to assume you will need 9 months to switch it to a microservice.

#### Function as a service (FaaS)

FaaS are usually small and they do one job.
This is just a function where it will be executed for you in the cloud, they are called lambda functions.
You can do anything within this function, the platform itself will handle scaling and library dependencies.
One of the first cloud computing platforms to provide this was amazon with [AWS lambda](https://aws.amazon.com/lambda/).

### Real-world example

At one of my previous jobs, we utilized a FaaS to retrieve files from an FTP server, save them, and process them.  
This helped us because we did not need an extra service just for this functionality, and we did not need any custom steps for this.  
Another case is to use the BaaS for analytics, authentication, or notifications.

### Benefits

- One main benefit of this architecture is that you don't need to worry about deployment and scaling servers on demand, this is done automatically.
- **Simplicity**: You can focus on writing code and not worry about deployment and not worry about infrastructure.
- Another benefit is that you don't need to worry about libraries and language support.
- **Cost saving**: Because you don't have to scale up or down manually, everything is done automatically so it is more cost-efficient.

### Drawbacks

- BaaS can change unexpectedly, so you need to make sure the versioning is not changing and breaking your functionality.
- You should be careful of the trap which it allows you to build very easily but usually the
  very special changes you want to do, you will not be allowed.
- If your company works with sensitive data this type of architecture is not recommended for that.
- Different platforms have different limits and delay ex: Execution duration and [cold start](https://azure.microsoft.com/de-de/blog/understanding-serverless-cold-start/).

### Conclusion

Serverless architecture is very useful for a small functionality in which you don't want any cost in deployment, maintenance, and scalability.
Cloud services will provide you with the best response time and handle the scaling.  
You need to be careful to only expand on them a little, otherwise, you might end up asking something that is not possible.
Overall, if your project involves writing and deploying small, single-purpose functions, then FaaS could be a good fit.


Serverless architecture is used for easy tasks that you don't have to have the whole process of deployement and maintainance.

Serverless architecture

---
title: Layered Architecture Style
summary: Layered Architecture Style is used where you want to have separations of concers.
date: 2022-12-06
archive: false
tags:
  - architecture
  - design
  - pattern
---

Layered architecture, is an architecture pattern that helps for having a more
organized and structured codebase.

Each layer has its distinct job and all the layers communicate via well-defined interfaces.

This architecture helps us with maintainability and scalability and is often used on enterprise applications.

You should be strict about not letting these layers have direct dependencies with each other, otherwise, you will lose the benefits of this architectural style.

Usually, the communication or interaction between layers is top-down at higher levels of the application such as user interaction using lower parts of the application such as the Database.

The key idea of this architectural style is to have a clear separation of concerns.


Layered Architecture Style is used where you want to have separations of concers.

Layered Architecture Style

---
title: Using Mutex in GO on a real world project.
summary: You will learn how the mutex library helps you prevent some of the issues in concurrent world.
date: 2022-11-14
layout: PostSimple
tags:
  - GO
  - Mutex
  - Concurrency
cover: reddit_war.jpg
---

### What will I learn?

I will be able to understand what is a Mutex,
and how it works in concurrent processes.
I will apply a mutex on a real-world project to see how we can benefit from it.

### What is a Mutex?

Mutex is a library which works on locking methods to not be accessible from other concurrent processes,
until the mutex says that it's open.
Think of a mutex as the traffic police, and when the police blocks a road thats a `Lock()`, no car will pass until the Police opens `Unlock()` the road.
[!](https://kanbanzone.com/wp-content/uploads/2020/01/blocked-road.jpg)

### How does it work?

As I would read in the [Go docs](https://pkg.go.dev/sync#Mutex) a Mutex must not be copied,
if I call the `Lock()` method then the mutex is locked and any other lock call will be waiting for it to be `Unlock()`-ed.
If I call the `Unlock()` method then the mutex will unblock itself and tell the lock method that `Mutex` is open.
Every time I copy a mutex then the state is unlocked, meaning it will have no effect.

> Before I describe how to apply on a project, try to set up [this project](https://github.com/Diarselimi/giftem#readme) in your maching, and see how it works.

### How do I apply it on a project?

This is a project that I was working on, it's about assigning gifs to employees, and each employee has to have one gift,
first come first serve.
I have employees and gifts in two json files and they look like this:

```json
//gifts json
[{
    "name": "netflix card",
    "categories": ["music", "film", "pets", "scifi"]
    }, {
        "name": "gold plated water bottle",
        "categories": ["power lifting", "triathlons", "football", "crossfit", "handball", "running"]
    }
]

//employees json
[{
    "id": 1,
    "name": "severin",
    "interests": ["high end audio", "photography", "sitting comfortably"]
    }, {
        "id": 2,
        "name": "oliver",
        "interests": ["pets", "scifi", "music making"]
    }
]
```

As beautiful as this looks I have to move on.

Next you will see the project structure [in github](https://github.com/Diarselimi/giftem).
The main.go file has the following content

```go
///...
var mutex = sync.Mutex{} //here we initialise Mutex, keep in mind this is outside of the methods.

func handler(w http.ResponseWriter, r *http.Request) {
    employeeId, err := strconv.Atoi(r.URL.Path[1:])
    if err != nil {
        fmt.Fprintf(w, "Employee with id %s not found", r.URL.Path[1:])
        return
    }
    mediator := application.CommandMediator{Mu: &mutex} //here we pass the mutex by reference
    mediator.Add(command.NewAssignGiftToEmployeeCommand(employeeId))

    mediator.Run()
}

func main() {
    http.HandleFunc("/", handler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}
```

If I go ahead and open `CommandMediator` I will see that I use the mutex there to `Lock()` and `defer Unlock()`,
and `defer` is like saying execute this when you are done.

```go
type CommandMediator struct {
    Mu       *sync.Mutex // important
    commands []Command
}
///...
func (cm *CommandMediator) Run() {
    cm.Mu.Lock() //locking
    defer cm.Mu.Unlock() //unlocking when job is done

    for _, command := range cm.commands {
        command.Execute() // executing the commands
    }
}

```

As I can see in the method `Run()` above, I am calling the mutex that is being passed from main file, and then locking it.
So that means that the mutex that I am getting it's the same mutex that every one else is getting when doing the request.

So that makes sense, since we are pasing mutex by reference and other people have the same instance of it,
someone might be faster than me in locking it then I must wait for the `Unlock()`.

### How long do I have to wait for my request?

Turns out it all depends on how your project is organised, in my small project I have blocked the whole command,
meaning no one can execute the command until you are done with it.

To make the change more obvious I have added a `time.Sleep(5 * time.Second)` which will sleep for 5 seconds,
this is for me to try to simulate two request at the same time.
So every time I run the command it will be blocked for 5 seconds.

### How do I see the effect?

Since I have the project in my machine, I can open two terminal windows and execute this command in both of them,
`curl http://localhost:8080/1` this will try to assign a gift to employee 1,
you will see that one of the responses will wait until the other one is done.


You will learn how the mutex library helps you prevent some of the issues in concurrent world.

Using Mutex in GO on a real world project.

---
title: Kodi i pastër dhe çka duhet të konsideroni
summary: Çka është kodi i pastër dhe si e efekton karrieren tënde si një programer profesional.
date: 2022-07-26
tags: [karriera, programim, mesime]
---

### Hyrje

Në fushën e programimit gjithmonë është një gjë me rëndësi Kodi i pastër, por çka domethënë kodi i pastër?   

Kodi i pastër do të thotë kur një person përpos teje e lexon atë që ti e ke shkruar dhe e kupton pa pasur nevojë të pyes ty se çfar pune bën një program një klasë apo një metodë.

Një programer profesional shpenzon më shumë kohë duke analizuar ose lexuar kodin që të tjerët e shkruajnë.

Diferenca në mes të një programeri të menqur dhe ati profesional është që, i menquri mund të mbaj në mend shumë gjëra.

p.sh Ai e din që variabla **r** në klasën **Processor** e përmban vlerën e **url path**, por nëse një programer tjetër dëshiron të punoj në atë klasë atëher ai duhet ta pyes programerin e menqur (do e lexoni më poshtë artikullit se pse kjo nuk është mirë).

Ndërsa ai profesionali shpenzon kohë në emërtimin dhe organizimin e kodit që të tjerët ta kenë më të lehtë ta kuptojnë dhe të bëjnë ndryshime.

> Bëhu profesional.    

![Pro coder](/image/coding-pro.gif)    
    

### Rregullat me shembuj

Sikur në gjuhën që e flasim dhe komunikojmë, ekzistojnë rregulla që të gjithë i mësojmë në shkollë.

Në programim këto rregulla askush nuk të shtynë ti mësosh, por mundësia për të u pranuar në një punë është më e madhe nëse i mëson këto rregulla.

Nuk do ti listoj të gjitha rregullat por disa më të thjeshta do të mundohem ti shpjegoj me disa pjesë të kodit.

p.sh Jeni duke punuar në një API dhe doni të ktheni të gjitha blerjet të listuara.

```php

class OrdersController {
//Emri i klasës duhet të jetë i përshkueshëm në nivelin ku
//programeri i radhës kur e sheh klasën e kupton se çfar pune bën pa e hapur atë.
//GetOrdersWithFiltersController do të ishte më e përshkrueshme
// ose GetFilteredOrdersController
	

	public function get(Request $request) : Response {
        
        if (!$this->auth->getUser()->isAuthenticated()) {
            //Në këtë rast thehet rregulli ku metoda ka njohuri 
            //se çka përmban getUser()
            //idealisht duhet të duket si në vijim
            //$this->auth->isUserAuthenticated() 
            //..
            return new UnauthorizedResponse();
        }
        
        $filters = [
            'order_by' => $request->get('order_by'),
            'order_direction' => $request->get('order_direction'),
            'search' => $request->get('search'),
            ...
        ];
        //konstruktimi i filterave mbrenda controllerit nuk është ideale
        //metoda duhet të lexohet pastër dhe jo të shohim strukturen e filterave
        //pra kjo mund të bartet në një Factory ose DTO objekt ku do të duket si në vijim
        //RequestFiltersFactory::create($request->getParams())
        
        
        if (!in_array($filters['order_direction'], ['asc', 'desc'])) {
        //asc dhe desc duhesh ti deklarosh si konstante 
        //apo ti fusesh mbrenda objektit / DTO objektit qe e kemi përmendur më lartë
        
            throw new SortingIsNotSupported();
        }
        
        $list = $this->orders->findAll($filters);
        //Emertimi i variablës në këtë rast nuk është aq i vetë shpjegueshëm
        //$filteredOrders do të ishte më e përshkrueshme ose
        //$orders është e mjaftueshme
		
        $isPagination = str_contains('/count', $request->getUri()->getPath());
        //Në këtë rresht kjo metodë po qaset në path për ta gjetur nëse 
        //egziston /count në url
        //por kjo është një shtresë më e thellë e aplikacionit prandaj 
        //edhe kjo e then rregullin që metoda duhet të qaset gjithmonë në të njejtën shtresë
        //$request->isPaginated()
        
        if ($isPagination) {
            return new PaginatedResponse($list);
        }
        
        return new Response($list);
	}
}
```

I njejti funksionalitet por me rregulla të konsideruara dhe me funksionalitet të fshehur në objekte.    


```php
class GetOrdersWithFiltersController {
    
    public function get(Request $request): Response
    {
        if ($this->authorization->isAuthorized()) {
            throw new NotAuthorized();
        }
        
        $getOrdersRequest = $this->prepareQuery($request->getParams());
        
        $orders = $this->query->execute($query);
        return $this->buildResponse($orders);
    }
}
```

Pra siç e shihni në këtë shembull, kodi i pastër do të thotë duhet të lexohet lehtë, që nëse dikush përpos teje e lexon këtë metodë dhe e sheh se çka po shkruan dhe e kupton se çfar pune po kryen.

[Një përmbledhje e rregullave të librit Clean Code - R. Martin mund ti gjeni në këtë link.](https://gist.github.com/wojteklu/73c6914cc446146b8b533c0988cf8d29)     
      



### Një kalkulim


Nëse projekti me të cilin po punoni përmban 8000 rreshta kodi.

Le të supozojmë se ju do të punoni në atë kompani për 1 vit = 230 ditë pune.

Nëse çdo ditë përpiqeni të përmirësoni projektin për vetëm 0.43% në ditë, kjo bën 34 rreshta në ditë.

Në fund të vitit ju do të ndryshoni plotësisht kodin në atë projekt.

Në fillim kur të vendosni të zbatoni rregullat në kodin që po shkruani do të jetë më e vështirë sepse po mbillni shprehi të reja, por kjo do të ndryshojë në mënyrë lineare, pas disa muajsh nuk do të duhet të mendoni aq shumë.        


 
### Efekti brenda ekipit

* Ju dhe ekipi juaj do të shpenzoni 70% të kohës tuaj duke lexuar kodin dhe jo duke shkruar, për të shkruar kod duhet të lexoni.
* Puna e të gjithë ekipit do të lehtësohet nëse dakordoheni të aplikoni rregullat.
* Ju do të jeni pika qendrore që të gjithë do të referohen për pyetje ose këshilla.
* Çdo ekip do të dëshirojë që ju të jeni pjesë e ekipit sepse kjo e bën punën e ekipit më të lehtë kur ata lexojnë lehtësisht kodin tuaj.

Një efekt negativ është se në fillim ndoshta do të hasni në rezistencë nga anëtarët e ekipit, por nëse i paraqisni faktet dhe referencat në libra dhe artikuj, atëherë argumentet mbarojnë.

> Sigurohu që ta lexosh **Mbani mend** në fund të artikullit.


### Efekt afatgjatë

Nëse shefi juaj pyet për sa kohë mund të përfundoni një projekt me x kërkesa.

Ju paraqisni një diagram si më poshtë:

![Diagrami i kohes dhe kompleksitetit](/image/code-quality.png)    



I shpjegon se nëse doni rezultate të shpejta, pasojat do të jenë më vonë, dhe anasjelltas.

Kjo, përveçse ndikon në të ardhmen e projektit, ndikon edhe ju si programues në dy mënyra:

1. Fuqia e shprehisë
2. Madhësia e projektit

     


#### Fuqia e shprehisë

Ju jeni programuesi që jeni për shkak të shprehive që keni adaptuar me kalimin e kohës.

Prandaj, duhet të jeni shumë të kujdesshëm se çfarë dhe si punoni në fillim të karrierës suaj.

Nëse punoni në projekte ku ju shtyjnë të adaptosh shprehi të kqija sikur

* Thyerja e kodit duke thyer rregullat e përmendura në artikullin e mësipërm
* Injorimi i formateve
* Injorimi i shkrimit të testeve

dhe i bën të gjitha këto pa asnjë përfitim për ty, atëherë duhet të mendoni mirë për atë vend pune.

Duke punuar në këtë mënyrë për një vit, ju do t'i mbillni ato shprehi në memorien ose përvojën tuaj.

Në të ardhmen, nëse doni të aplikoni në një kompani më të mirë, atëherë duhet të harroni shprehitë e këqija dhe të mësoni shprehi të mira.     

Pra, siç mund ta shihni që nuk ka asnjë përfitim për ju si programues nga ajo kompani, duhet të mendoni gjithmonë në të ardhmen se çfarë përfitimesh do të mbeten për ju si programues.

Dikush zgjedh të sakrifikojë standardet për një përfitim që është më i vlefshëm se cilësia e kodit dhe kjo nuk është një zgjedhje e gabuar.    


#### Madhësia e projektit

Nëse vendosni për të mos i aplikuar formatet dhe rregullat e përmendura në projekt, atëherë pas një viti projekti për të cilin po punoni do të bëhet aq i madh sa nuk mund të përballoni të punoni vetëm me të.

Shefi vendos të punësojë një programues të ri në projekt, por për shkak se nuk arritët ta bindni shefin për kodin e pastër, vendosët të mos ndiqni standardet dhe pa teste, programuesi i ri e ka shumë të vështirë të mësojë dhe të kontribuojë në projekt.

Prandaj koha juaj tani është e ndarë në dy pjesë,

* Vazhdimi i punës për aplikimin e gjërave të reja në projekt
* Ndihmon programuesin e ri për të kuptuar se çfarë po bëhet në kodin me të cilin po punon.

Pas kësaj i thoni shefit se keni nevojë për një programues me më shumë përvojë, sepse ai nuk po bën shumë punë.

Dhe kështu përfundon deri në dështimin e projektit.

Në fund, ju do të jeni ai që e bëri projektin të dështojë, sepse jeni ai që shkroi kodin, dhe shefi juaj ju pushon nga puna dhe ia jep punën një programuesi më me përvojë.

Përfitimi i vetëm që keni marrë nga ai vend pune është përvoja se si një projekt dështon.      
      

### Aplikimi i rregullave

Për të aplikuar të gjitha rregullat, një shprehi e mirë është kur jeni duke shkruar kod, përpiquni t'i shpjegoni vetes me fjalë se çfarë po bën ky kod.

Mundohuni ta adaptoni këtë mentalitet

1. Shkruani kodin për ta bërë atë të funksionojë
2. Shkruani disa teste që ju lejojnë të ndryshoni kodin pa prishur funksionalitetin
3. Fillon me riemërtimin e metodave dhe klasave
4. Fillon ndarjen e klasave në klasa të veçanta
5. Ndarja e metodave që përmbajtja të është më e lexueshme.
6. E lexon disa herë
7. Kthehuni në hapin 3.
8. Nëse mendoni se gjithçka është në rregull, atëherë vazhdoni.      


### Automatizimi i rregullave

Ka disa vegla që ju ndihmojnë dhe ju tregojnë nëse keni probleme me standarde të ndryshme në kod.

Por në një pikë veglat nuk mund ta rishkruajnë kodin për ty.

Veglat:
1. [https://phpstan.org/try](https://phpstan.org/try)
2. [https://www.npmjs.com/package/phplint](https://www.npmjs.com/package/phplint)
3. [snyk.io](https://snyk.io/lp/snyk-code-checker/?utm_medium=Paid-Search&utm_source=google&utm_campaign=nb_lg_snyk-code&utm_content=code_analysis&utm_term=code%20analysis%20tools&gclid=CjwKCAjw5s6WBhA4EiwACGncZWBRlgUwVS6fGws6nsb3dD1yQZ0iCzuN5neSZZEiM3UhbXxzl7SeJBoCf5AQAvD_BwE)
4. [https://www.sonarqube.org/](https://www.sonarqube.org/)    
5. [https://phpinsights.com/](https://phpinsights.com/)


       
### Përfundim

Në librin “Clean Code – R. Martin” ka një rregull interesant që më ka mbetur në mendje dhe është si më poshtë, “Lëre kodin ku po punon pak më mirë se sa e gjete”.

Pra, përmbledhja e të gjithë tekstit në këtë artikull flet për kodin e pastër.
Nëse shkruani kod të pastër, je ti që përfiton nga përvoja dhe je ai që përfiton nga zakonet e mira që do t'ju shtyjnë përpara në karrierën tuaj.

Fillimi nuk është i lehtë për të shkruar kod të pastër, por pas ca kohësh do të bëhet intuitive.

Nëse dikush tjetër do ta lexojë atë klasë ose funksion që keni shkruar, ai do të jetë mirënjohës sepse ju keni kursyer kohën e tyre.
     
Mos e merrni kodin e pastër si rregull dhe ndiqni atë pa u menduar, përdorni intuitën tuaj dhe konsiderojeni atë si një rrugë që ju bën të mendoni për atë që shkruani në një këndvështrim unik.         

#### Mbani mend 🧠
Duhet të komunikoni gjithmonë me ekipin dhe kolegët, të arrini në një përfundim së bashku, në fund të fundit, ju jeni një ekip dhe që një ekip të funksionojë, komunikimi duhet të jetë i rëndësishëm.


Çka është kodi i pastër dhe si e efekton karrieren tënde si një programer profesional.

Kodi i pastër dhe çka duhet të konsideroni

---
title:  "Principet SOLID dhe si të aplikojmë ato në kod"
date:   2021-11-17
summary: Krijoni një bazë të fortë në programim duke mësuar SOLID principet, me shembuj ne PHP.
tags: [SOLID, OO, PHP, PROGRAMERAT]
---

E pyeta një të afërm timin pse duhet ti mësojmë SOLID principet?
Ja si përgjigjet ai...
> Dallimi në mes fillestareve dhe profesinistëve që kërkohen nga cdo kompani, perfshir: Tesla, Google, Apple, SpaceX etj gjendet tek aplikimi i principeve të ndryshme.

Pasi të lexoni këtë artikull, si dhe të analizoni shembujt që janë në këtë artikull, ju do të kuptoni principet SOLID dhe do të jeni të gatshëm ti aplikoni ato.

Çdo kompani në Gjermani që do të aplikoni si zhvillues softveri, do të ju parashtrojn pytje në intervistë në lidhje me principet SOLID.

Principet SOLID në OO programim do të ndihmojnë shumë në karrierën tuaj si programer.
Do të kesh një bazë stabile për të ecur përpara, pa pasur parasysh produktin që ti e ndërton.

### Prezantimi i problemit
Para se të fillojm, do ta prezantoj problemin që do të punoj gjatë të gjithë shembujve që i marr. 

### Problemi
Të marrim shembull një klient i juaj do të ju kërkoj me zhvillu një aplikacion. Ky aplikacion do ti digjitalizoj porosit në restaurantin e tij _Villa Natyra_ që vetëm bën piza dhe hamburgera.
Ne si programera të mirë që jem ja ndërtojm aplikacionin, tash ai po e përdor dhe është i kënaqur.

Në rregull, masi e kem ndërtu produktin tash hajde të flasim për principet.

### Principi i parë - Një klasë, një përgjegjësi
> Një klasë duhet të këtë vetëm një përgjegjësi dhe një arsyje të ndryshoj.

Një shembull ku ky princip nuk respektohet

```php
class Hamburgeri
{
   private string $kategoria;
   private array $shtesat;
   private string $llojiIMishit;
 
   public function __constructor(string $llojiIMishit, array $shtesat)
   {
       $this->kategoria = $this->percaktoKategorine($llojiIMishit);
       $this->shtesat = $shtesat;
       $this->llojiIMishit = $llojiIMishit;
   }
 
   private function përcaktoKategorine(string $llojiIMishit): string
   {
       if (in_array($llojiIMishit, ['file_pule', 'mish_lope'])) {
           return 'zgare';
       }
 
       return 'furre';
   }
 
   public function llogaritShumen(): double
   {
       double $shuma = 0;
       foreach($this->shtesat as $shtesa) {
           $shuma += $shtesa->merrQmimin();
       }
 
       return $this->llojiIMishit + $shuma;
   }
 
   public function ruajFakturen(): void
   {
       //ktu ruhet faktura në databazë
   }
}
```

Nëse e kemi një klasë vetëm për hamburgerin edhe kjo klasë pranon shtesa sikur sallatë, domate etj.
Gjithashtu e përcaktojmë kategorinë mbrenda klasës, i ruajm të dhënat në databazë dhe e kalkulojmë shumën.
Atëher kjo klasë do të ndryshoj sa herë që mënyra e ruajtjës në databazë ose mënyra e kalkulimit ose mënyra e përcaktimit të kategorise ndryshojnë.

```php
interface Ushqim {}
 
class Hamburgeri implements Ushqim
{
   private const KATEGORIA = 'furre';
   public array $shtesat;
   public string $llojiIMishit;
   public double $shuma;
 
   public function __constructor(string $llojiIMishit, array $shtesat)
   {
       $this->kategoria = $this->percaktoKategorine($llojiIMishit);
       $this->shtesat = $shtesat;
       $this->llojiIMishit = $llojiIMishit;
   }
 
   public function merrKategorine(): string
   {
       return self::KATEGORIA;
   }
}
 
class KalkulatoriUshqimit
{
   public function __constructor(Ushqim $ushqimi){}
 
   public function merrShumen(): double
   {
       return 0.0; //ktu  kalkulohet shuma.
   }
}
 
class RuajtjaFaktures
{
   public function ruaj(Faktura $faktura): void
   {
       $this->save($faktura);
   }
}
 
class Faktura
{
   public function __constructor(Ushqim $ushqimi, double $shuma)
}

```
Kurse këtu siç edhe shihet që i kemi ndarë klasat me përgjegjësi të ndryshme, sa herë që kalkulimi i çmimit ndryshon atëher klasa `KalkulatoriUshqimit` po ashtu ndryshon. 
Nëse vendosim ta ndrrojmë mënyrën se si i ruajmë të dhënat atëher klasa `RuajtjaFaktures` ndryshon.

### Principi i dytë - E hapur për zgjatje, e mbyllur për ndryshime.
> Një klasë duhet të jete e mbyllur për ndryshime ndërsa e hapur për zgjatje.

Ta marrim shembull klasën që i bën kalkulimet `KalkulatoriUshqimit` dhe ta shohim si do të ndryshoj nëse një kërkes e re na vjen, shembull “Po me duhet që për studente çmimi final të dal 20% më lirë”

Tash na si programera pa dijeni për këtë princip “E mbyllur për ndryshime” do ta bëjme një ndryshim si në vijim

```php
interface Ushqim {}
 
class KalkulatoriUshqimit
{
   public function merrShumen(Ushqim $ushqim): double
   {
       $shuma = $ushqimi->merrLlojinEMishit()->merrShumen();
       foreach($ushqimi->merrShtesat() as $shtesa) {
           $shuma += $shtesa->merrShumen();
       }
 
       return $shuma;
   }
 
   public function merrShumenPerStudente(Ushqim $ushqim): double
   {
       $shuma = $this->merrShumen($ushqim);
 
       return $shuma - ($shuma * 0.2);
   }
 
}
```
Nëse bëjme diçka si kjo atëher së pari klasa ka jo një arsye por dy për të ndryshuar, që e then edhe principin e parë, shohim që po e kalkulon shumën e ushqimit dhe zbritjen për studenta. 
Tash nëse ndryshon mënyra e kalkulimit të ushqimit ose përqindja për studenta, atëher kjo klasë duhet të modifikohet.

Nëse e konsiderojm Principin e parë, zbritja duhet të jete në një klas ndamas dhe në bazë të principit të dytë, klasa e re mund ta përdor klasën që kalkulon por nuk duhet ta ndryshoj atë.

Si rezultat kemi bërë një ndryshim si në vijim.

```php
interface Ushqim {}
 
class KalkulatoriUshqimit
{
   public function merrShumen(Ushqim $ushqim): double
   {
       $shuma = $ushqimi->merrLlojinEMishit()->merrShumen();
       foreach($ushqimi->merrShtesat() as $shtesa) {
           $shuma += $shtesa->merrShumen();
       }
 
       return $shuma;
   }
 
}
 
class KalkulatoriUshqimitPerStudente extends KalkulatoriUshqimit
{
   private const ZBRITJE_NE_PERQINDJE = 0.2;
 
   public function merrShumen(Ushqim $ushqimi): double
   {
       return $this->zbritShumen(parent::merrShumen($ushqimi));
   }
 
   private function zbritShumen(double $shuma): double
   {
       return $shuma - ($shuma * self::ZBRITJE_NE_PERQINDJE);
   }
 
}

```
Siç edhe pe shihni i kemi ndarë përgjegjsit në klasa të ndryshme, tash nëse mënyra e kalkulimit të ushqimit ndryshon atëher do të ndryshoj vetem `KalkulatoriUshqimit` dhe nëse zbritja për student ndryshon atëher do të ndryshoj vetëm klasa `KalkulatoriUshqimitPerStudente`.

### Principi i tretë - Zëvendesimi Liskov
> Ky princip thot që nëse funksioni f(x) punon me objektet e tipit T. Atëher funksioni f(y) duhet të punoj me objektet y të tipit S ku S është nën tip i T.

Ndoshta shembulli që e then këtë princip do ta lehtsoj kuptimin e ketij principi.

```php
interface Ushqim {}
 
class KalkulatoriUshqimit
{
   public function merrShumen(Ushqim $ushqim): double
   {
       $shuma = $ushqimi->merrLlojinEMishit()->merrShumen();
       foreach($ushqimi->merrShtesat() as $shtesa) {
           $shuma += $shtesa->merrShumen();
       }
 
       return $shuma;
   }
 
}
 
class KalkulatoriUshqimitPerStudente extends KalkulatoriUshqimit
{
   private const ZBRITJE_NE_PERQINDJE = 0.2;
 
   public function merrShumen(Ushqim $ushqimi): double
   {
       return $this->zbritShumen(parent::merrShumen($ushqimi));
   }
 
   private function zbritShumen(double $shuma): double
   {
       return $shuma - ($shuma * self::ZBRITJE_NE_PERQINDJE);
   }
 
}

```
Kjo pjese e kodit është pjesë e principit të dytë ku e kem zgjatur klasën `KalkulatoriUshqimit`, me këtë ndryshim të metodës `merrShumen` e kemi thyer rregullin e principit të tretë.
Nëse i referohemi definicionit i bjen që e njëjta metodë nuk duhet të kthen vlera të ndryshme edhe pse është klasë tjeter.

Do ta rregullojme këtë klasë si në vijim.

```php
interface Ushqim {}
 
class KalkulatoriUshqimit
{
   public function merrShumen(Ushqim $ushqim): double
   {
       $shuma = $ushqimi->merrLlojinEMishit()->merrShumen();
       foreach($ushqimi->merrShtesat() as $shtesa) {
           $shuma += $shtesa->merrShumen();
       }
 
       return $shuma;
   }
 
}
 
class KalkulatoriUshqimitPerStudente extends KalkulatoriUshqimit
{
   private const ZBRITJE_NE_PERQINDJE = 0.2;
 
   public function merrShumenEZbritur(): double
   {
       $this->zbritShumen($this->merrShumen());
   }
 
   private function zbritShumen(double $shuma): double
   {
       return $shuma - ($shuma * self::ZBRITJE_NE_PERQINDJE);
   }
 
}

```
Në vend që ta modifikojm metodën e klasës origjinale, do ta përdorim atë në klasën për studente dhe do të shtojmë metoda në klasën për studente.

### Principi i katert - Ndarja e kontratave
> Një klasë nuk duhet ta implementoj një metodë që nuk i nëvojitet.

Shembull shtesat e ushqimeve, siq e kemi parë me lartë secila shtesë e ka çmimin e vet, po çka nëse kemi shtesa që nuk kushtojn?
Shembull: 

```php
interface Ushqim {}
interface Shtesa {
   public function merrShumen(): double;
}
 
class Sallate implements Shtesa {
   public const QMIMI = 0.50;
 
   public function merrShumen() {
       return self::QMIMI;
   }
}
 
class BbqSos implements Shtesa {
   public const QMIMI = 0.20;
 
   public function merrShumen() {
       return self::QMIMI;
   }
}
 
class Ketchup implements Shtesa {
   public const QMIMI = 0.00;
 
   public function merrShumen() {
       return self::QMIMI;
   }
}
 
class Hamburger implements Ushqim {
   private const QMIMI = 2.00;
 
   public function merrQmimin():double
   {
       return self::QMIMI;
   }
}

```
Siç e shohim në shembullin më lart, shtesa  `Ketchup` edhe pse është falas  duhet ta implementoj metodën `merrShumen` dhe kjo nuk e respekton principin e katërt, një klasë nuk duhet ta implementoj një metodë që nuk i nevojitet.

Kështu duhet  ta ndryshojm kodin që ta respektojme principin e katërt.

```php
interface Ushqim {}
interface Shtesa {
   public function merrSasine(): int;
}
interface ShtesaMePages implements Shtesa {
   public function merrShumen(): double;
}
 
class Sallate implements ShtesaMePages {
   public const QMIMI = 0.50;
 
   public function merrShumen() {
       return self::QMIMI;
   }
}
 
class Ketchup implements Shtesa {
   private int $sasia = 1;
 
   public function merrSasine(): int
   {
       return $this->sasia;
   }
}
 
class Hamburger implements Ushqim {
   private const QMIMI = 2.00;
 
   public function merrQmimin():double
   {
       return self::QMIMI;
   }
}
 
class KalkulatoriUshqimit
{
   public function merrShumen(Ushqim $ushqim): double
   {
       $shuma = $ushqimi->merrLlojinEMishit()->merrShumen();
       foreach($ushqimi->merrShtesat() as $shtesa) {
           if ($shtesa instanceof ShtesaMePages) {
               $shuma += $shtesa->merrShumen();  
           }
       }
 
       return $shuma;
   }
 
}
```
Ky është një shembull ku ndahet kontrata për shtesat me  çmime dhe ato pa  çmime, për arsye që shtesat pa çmime nuk kan nevoj ta implementojnë metodën `merrQmimin()`.

### Principi i pestë - Inversioni i varësisë
> Një klasë që kryen një punë asnjëherë nuk duhet të varet në mjetin që e përdor por në kontratë.

Një shembull do të ishte ta ruajm fakturen në MySQL databazë si në shembullin në vijim.
E mbani mend si klasa `RuajtjaFaktures` varet direkt në klasën `Databaza` që është edhe implementimi mbrenda.
Tani klasa `RuajtjaFaktures` e then principin e parë sepse nëse e ndryshojme databazën  atëher duhet ta ndryshojm edhe klasën `RuajtjaFaktures`.

```php
class Databaza
{
   public function ruaj(Faktura $faktura): void
   {
       $sql = "INSERT into FAKTURAT (val1, val2, val3) VALUES (1,2,3);"
       $this->db->executeSql($sql);
   }
}
 
class RuajtjaFaktures
{
   public function __constructor(Databaza $databaza){}
 
   public function ruaj(Faktura $faktura): void
   {
       $this->databaza->ruaj($faktura);
   }
}
 
class Faktura
{
   public function __constructor(Ushqim $ushqimi, double $shuma)
}
```
Një shembull  që do ta respektonte principin e pestë do të ishte si në vijim.

```php
interface Databaza {
   public function ruaj(Faktura $faktura): void;
}
 
class HapsiraRuajtjesSeFakturave implements Databaza
{
   public function ruaj(Faktura $faktura): void
   {
       $sql = "INSERT into FAKTURAT (val1, val2, val3) VALUES (1,2,3);"
       $this->db->executeSql($sql);
   }
}
 
class RuajtjaFaktures
{
   public function __constructor(Databaza $databaza){}
 
   public function ruaj(Faktura $faktura): void
   {
       $this->databaza->ruaj($faktura);
   }
}
 
 
 
class Faktura
{
   public function __constructor(Ushqim $ushqimi, double $shuma)
}

```
Ne këtë shembull e shohim që tani kemi një kontratë `Databaza` dhe një klasë ku gjendet implementimi i ruajtjes së fakturave `HapsiraRuajtjesSeFakturave`, tash nëse vendosim ta ndryshojm databazën në MongoDB, NoSQL ose çkado qoft nuk kemi nevoj ta ndryshojm klasën `RuajtjaFaktures` sepse ajo varet në kontrat e jo në implementim.

### Finalizimi dhe hapat e tjerë
Këto janë pra pesë principet në OO të cilat shikohen në secilën intervistë se sa mirë i ke kuptuar dhe a din si ti përdorni ato.
Hapat e radhës janë: 
Që të provosh ti aplikosh këto principe duhet startuar një projekt të vogël ose edhe në punën ku punon.
Kur e shikon një kod në fillim të merr kohe ti shikosh të gjitha principet, por pas ca kohe bëhet më e leht.
Përserite këtë proces disa here.

Nëse keni ndonjë koment, kritike ose   vetëm don të kemi një bised rreth OO atëher me kontakto në rrjetet sociale.
[Github](https://github.com/didslm)




Krijoni një bazë të fortë në programim duke mësuar SOLID principet, me shembuj ne PHP.