Forem: Amr Saeed

Symmetric vs. Asymmetric Encryption

Amr Saeed — Thu, 03 Feb 2022 16:02:19 +0000

In the past, when two persons wanted to send messages to each other in a secure way, they resorted to something called Symmetric Encryption. Symmetric encryption is a type of encryption that uses one secret key to encrypt and decrypt messages. Hence, the two parties must have this key to communicate.

The issue with this approach is that saving and protecting the keys is very difficult because these two persons have to know the key. So, if one of them has been hacked, the key could be stolen easily. Moreover, even if the two persons decided to send the key directly on the network and change it periodically, someone could be intercepting the network to get the key; this is commonly known as a Man-in-the-middle attack.

This type of encryption in its simple form has caused many problems until a new type of encryption arose, which is Asymmetric Encryption, also known as Public-key Cryptography.

In this type of encryption, each device generates a key pair, one is public, and the other is private. Both of the two keys are connected mathematically in a way that if you encrypt a message with a public key, it can only be decrypted by the private key and vice versa.

The main idea is that if you want to send me an encrypted message, I'll have to generate a public and private key pair. After that, I'll send you the public key then you can use it to encrypt your message and send it over the network. If anyone tried to intercept your message, they wouldn't understand it because it's encrypted. Also, if they tried to decrypt it, they wouldn't be able to do so because they need the private key. Luckily in this approach, the private key only resides on my machine and is never sent over the network.

The same idea would apply to me if I decided to reply to your message. You've to send me your public key to decrypt my response and send it.

Notice that there is no danger in sending the public key over the network or even uploading it to the internet as this is its main purpose. Additionally, the current machines' limited capabilities make it difficult to derive the private key from the public key. This operation can take a huge amount of time.

Till now, you should have understood the core difference between symmetric and asymmetric encryption. Follow the coming articles if you want to understand their applications and their essential to you as a software engineer.

Some Reasons Why You Should Follow Naming Conventions

Amr Saeed — Fri, 15 Jan 2021 10:57:49 +0000

Writing clean and readable code is not an easy task. It requires you to keep reading about good practices and apply them as much as you can to avoid the bad ones.

Today we're going to talk about the benefits of one of those practices to understand their importance. But before touching upon this, let's understand what does naming conventions mean.

Naming conventions are some rules that help you to name things in your code such as variables, functions, and classes.

One of the common naming conventions which are adopted by many programming languages such as Java is the Camel Case. In Camel Case, you name your variables and functions in the following way myNameIsAwesome. The first word starts with a lower case letter followed by as many words as you want but they start with upper case letters.

Python and similar languages such as Ruby adopt another naming convention which is Snake Case my_name_is_awesome. You can clearly tell the difference between Camel Case and Snake Case.

Now it's time to understand why naming things in your code is very important. You might see it as a trivial task with no benefits at all and you don't have to care about it. But believe me, it is not a waste of time as it looks like.

Unified Style Enhances Readability

Imagine a large project with hundreds of developers who participate. If every developer decided to name variables and functions with their own style, the project is going to be a mess.

Developers who follow the same naming convention across the project contribute to its readability. The project will look as if it was written by a single person.

Differentiate Items by Their Names

Another advantage of following naming conventions that also contributes to the project readability is that you can differentiate items easily by their names. If in Java, for example, you find an item that is named in Camel Case myItem, that means it's a variable, object, or method. If it's named in Pascal Case MyItem, that means it's a class. If it's named in Screaming Snake Case MY_ITEM, that means it's a constant.

public class Circle {
    private static final double PI = 3.14;
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double getArea() {
        return PI * radius * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle(5);
        double area = circle.getArea();
        System.out.println(area);
    }
}

Search Becomes Easier

Following a naming convention makes it easy for you to search for items in the project. If for example, you want to find the method that is responsible for authenticating users, you'll be expecting to find it with the name login or signIn for the Camel Case convention.

The same idea applies when you're using a built-in class such as ArrayList in Java. If you want to find the size of an ArrayList object, you'll be expecting to find a method with the name length or size.

More Focus on the Necessary Details

Time is one of the most valuable resources, if not the most valuable. When it comes to software projects, we always want to achieve more in less time. To do that, we've to make repetitive tasks such as naming things much faster. As you can see, following the naming convention of the programming language we use can contribute to that. By doing so, we're reducing the debates among the developers about the best naming convention to follow, because we're following the standard. In other words, we let the developers focus on the necessary details.

Convention Over Configuration

Convention over configuration is a software design paradigm used by software frameworks that attempts to decrease the number of decisions that a developer using the framework is required to make without necessarily losing flexibility. Wikipedia

Simply, Convention Over Configuration is an approach that is used by modern frameworks. It makes a deal with you. If you follow the conventions that the framework adopts, the framework will automatically do configuration tasks for you. Otherwise, you'll have to do them manually by yourself and lose this advantage.

For example, the framework may till you to name your classes in the Pascal Case naming convention User so that it can automatically create a corresponding table in the database with the name users for you. If you decided to name the class with another naming convention __user the framework won't do the mapping task for you and you've to write some configurations to create the table correctly. That's because you didn't follow the conventions that the framework adopts.

Now you understand why following naming conventions is essential, and although it seems like a trivial task, it really contributes to your projects.

If you know any other advantage for following naming conventions, please share it with us.

Soft Deletion in Database

Amr Saeed — Sat, 26 Dec 2020 18:15:21 +0000

One of the common problems you may face when you design your database is that you want to delete a row from some table in the database without actually deleting it.

The name of this concept is called Soft Deletion. You can apply soft deletion by creating a column called IS_DELETED in the table you want. This column is of the type Boolean. If its value is True, then the row has been deleted or invisible to be accurate.

It's a straightforward concept to apply, but it comes with costs. You may face problems where you are building complex queries on this table; then later, you discover by coincidence that you forgot to consider this column in your queries from the wrong data they produce. At this moment, you discover that you have to include IS_DELETED in nearly every single query you build which has this table.

That's why some people try to avoid this method to apply soft deletion by creating an archive table. When you delete some row from the original table, just insert it into the archive table. Hence, no query mistakes on the original table and no IS_DELETED overhead.

Try to avoid soft deletion as much as you can, and try not to use it unless there is a real need to do so. Notice that soft deletion has nothing to do with backups. Backups have to be done regardless you're applying soft deletion or not. They have to be applied periodically, and the period itself depends on your application.

Countries Data

Amr Saeed — Fri, 27 Nov 2020 15:33:29 +0000

For the last couple of months, I was working on a large project in which I needed to use the list of countries in both English and Arabic languages. At first glance, I thought finding this list was going to be easy as it looks like a common problem, right? But unfortunately, it wasn't.

Most of the data I've found weren't organized properly, and it was too hard to extract the necessary data without putting in a huge effort.

I decided to use some API having this data already, but I faced some problems. Most of the APIs provide you with a limited number of requests per month. If you want more requests, you've to pay more and more. Unfortunately, the free ones weren't reliable.

Despite all of that, I had two major problems. The first one, we may have situations in which we want to relate some data to some countries in our database with foreign keys. So, the APIs won't be useful, and I have to store the data in the database. For the second one, all the solutions I've found weren't providing Arabic data.

So, I decided to build the data on my own. With the help of GeoNames public data and with some extra effort to translate the data and add extra fields, I created amrsaeedhosny/countries repository on GitHub.

Country Data

Each country has the following data:

English Name.
Arabic Name.
ISO 3166-1 Alpha-2 Code.
ISO 3166-1 Alpha-3 Code.
Phone Code.

Available File Formats

The countries data are stored in multiple file formats:

CSV:

English Name	Arabic Name	Alpha-2 Code	Alpha-3 Code	Phone Code
Egypt	مصر	EG	EGY	20

JSON:

{
 "english_name": "Egypt",
 "arabic_name": "مصر",
 "alpha2_code": "EG",
 "alpha3_code": "EGY",
 "phone_code": "20"
}

SQL:

INSERT INTO COUNTRY (ENGLISH_NAME, ARABIC_NAME, ALPHA2_CODE, ALPHA3_CODE, PHONE_CODE) VALUES('Egypt', 'مصر', 'EG', 'EGY', '20');

Custom File Format

There is also a simple python script that you can use to build your own file format:

import csv

my_file = open("my_file.txt", "w")

with open('countries.csv') as csv_file:
    csv_reader = csv.reader(csv_file)
    csv_reader.next()
    for row in csv_reader:
        for column in row:
            my_file.write(column + ",")
        my_file.write("\n")

my_file.close()

Now the problem has been solved once, and I can use the data easily whenever I need it.

By reaching this, you've to know that you're free to use this data in your own projects. Actually, that was the whole point of this article. So, enjoy!

How to Choose Your First Programming Language?

Amr Saeed — Sun, 15 Nov 2020 16:13:18 +0000

One of the questions that are frequently asked by new programmers is:

There are tons of programming languages, how to make sure I am starting with the most appropriate one?

The answer to this question has been a debate for a long time. Some experts may tell you to start with C++. Other experts may prefer Python over C++ for beginners. You also may hear different opinions from people in the industry to start with a programming language like C# or Java.

“I’m confused, is there only one correct approach?”

The answer is no. The fact is that most experts prefer some approaches based on their personalities and perspectives. You’ll find that most of the people who suggest C++ tend to start with the details first. Learning C++ first is like trying to drive a manual car. On the contrary, python is very easy to learn, so some people prefer to start with it for that reason. It’s like trying to drive an automatic car. Some other people like to learn programming through projects as they get bored so quickly. So, they try to start with a language like Java to create Android applications or start with a language like PHP to create web applications.

Now, after knowing the secret behind those different opinions, we’ve to choose your first programming language. To do that, we’re going to divide people into three groups. You’ve to determine which group you fall into and start with one of the suggested languages under this group.

The three groups are:

You’re a computer science student or have a long-term plan.
You want to get a job as soon as possible or have a short-term plan.
You want to do programming as a hobby or to teach your child.

You’re a Computer Science Student or Have a Long-Term Plan

If you’re a computer science student or a person who decided to enter this field with a long-term plan that can take more than one year, your objective has to become focusing on the basics of computer science. You’ve to become a person who can learn any technology easily regardless of its complexity. The languages that help you to achieve that objective are languages like C++, Java, and C#. Those languages help you to learn the basics of computer science such as Object-Oriented Programming, Data Structures, and Algorithms in a detailed manner. Learning those types of programming languages makes it very easy for you to learn modern programming languages such as Python in the future. That’s because you’ve already started with the hardest and most detailed ones.

Personally, I prefer C++, and it’s the one I’ve started with when I was in college. It’s fast, flexible, and has some important features that don’t exist in many languages. It also teaches you several concepts that are related to memory. But it’s okay if you’re a student whose college decided to start with Java or C#, you won’t miss a lot as they have similar syntax.

You Want to Get a Job as Soon as Possible or Have a Short-Term Plan

If your first priority is to get a job as soon as possible or you have a very tight time plan which may take less than a year, the best option for you is to study a language which is related to some track of your interest.

For example, if you’re interested in Mobile Development, you can learn languages like Java or Kotiln. If you’re interested in Web Development, you can learn languages like JavaScript, PHP, Python, or Ruby. Notice that languages like JavaScript or PHP are not the most suitable languages to learn programming concepts such as OOP and Data Structures comparing to C++ or Java. So, when you start learning any one of them, you’ve to make sure you’re following the best practices and not writing a bad code.

Also, you’ve to know that even if you’re focusing on a specific track, you’ve to focus on the programming concepts as much as you can. The difference between you and the person who decided to follow a long-term plan is that you’re learning the concepts through your specialization directly. You may not face all the programming concepts they will but, you’ve to make sure you understand the concepts you study. And if you have time in the future, try to learn those concepts separately.

You Want to Do Programming as a Hobby or to Teach Your Child

If you want to do programming as a hobby or you want to teach your child programming, python is the clear winner for that purpose. The basics of this programming language are very easy to grasp. It will help you to learn the fundamentals of programming without facing the syntax complexity of other programming languages such as C++.

This is an example of a code written in C++ which prints “Hello World” on the screen:

#include <iostream>

using namespace std;

int main()
{
    cout << "Hello World";

    return 0;
}

This is the equivalent code but written in python:

print("Hello World")

You can see that the Python code is very short compared to the C++ one.

Now, we’ve reached the end of this article. But, you’ve to know that It’s always preferable to have a long-term plan so that you can practice the different concepts. But if you don’t have this option, try to pick one of the two other plans and work hard to achieve what you want.

One last note, these are some useful resources I personally tried. They can help you to learn the programming language you want:

And always remember that “practice makes perfect”.

Liskov Substitution Principle

Amr Saeed — Sat, 14 Nov 2020 16:00:19 +0000

You know, when I heard the name of the Liskov Substitution Principle for the first time, I thought it would be the most difficult one in SOLID principles. The principle’s name sounded very strange to me. I judged the book by its cover, and I convinced myself that I wouldn’t grasp it. Eventually, it turned out that it was one of the easiest and straight forward principles in SOLID principles.

So, let’s start our journey by putting a simple definition for the Liskov Substitution Principle:

It’s the ability to replace any object of a parent class with any object of one of its child classes without affecting the correctness of the program.

I know it sounds strange to you but let’s break it into pieces. Suppose we have a program that has a parent class. The parent class has some child classes who inherit from. If we decided to create some objects from the parent class in our program, we’ve to be able to replace any one of them with any object of any child class, and the program should work as expected without any errors.

In other words, we have to be able to substitute objects of a parent class with objects of child classes without causing the program to break. That’s why the principle has the keyword ‘substitution’ in its name. As for Liskov, it’s the name of the scientist Barbara Liskov who developed a scientific definition for that principle. You can read this article Liskov substitution principle on Wikipedia for more information about that definition.

Now, let’s try to link the definition we’ve just discussed to a famous example to understand the principle.

Bird is a class which has the two methods eat() and fly(). It represents a base class that any type of bird can extend.

public class Bird {

    public void eat() {
        System.out.println("I can eat.");
    }

    public void fly() {
        System.out.println("I can fly.");
    }
}

Swan is a type of bird that can eat and fly. Hence, it has to extend the Bird class.

public class Swan extends Bird {

    @Override
    public void eat() {
        System.out.println("OMG! I can eat pizza!");
    }

    @Override
    public void fly() {
        System.out.println("I believe I can fly!");
    }
}

Main is the main class of our program which contains its logic. It has two methods, letBirdsFly(List<Bird> birds) and main(String[] args). The first method takes a list of birds as a parameter and invokes their fly methods. The second one creates the list and passes it to the first.

public class Main {

    public static void letBirdsFly(List<Bird> birds) {
        for(Bird bird: birds) {
            bird.fly();
        }
    }

    public static void main(String[] args) {
        List<Bird> birds = new ArrayList<Bird>();
        birds.add(new Bird());
        letBirdsFly(birds);
    }
}

The program simply creates a list of birds and lets them fly. If you try to run this program, it will output the following statement:

I can fly.

Now, let’s try to apply the definition of this principle to our main method and see what happens. We are going to replace the Bird object with the Swan object.

public static void main(String[] args) {
    List<Bird> birds = new ArrayList<Bird>();       
    birds.add(new Swan());
    letBirdsFly(birds);
}

If we try to run the program after applying the changes, it will output the following statement:

I believe I can fly!

We can see that the principle applies to our code perfectly. The program works as expected without any errors or problems. But, what if we tried to extend the Bird class by a new type of bird that cannot fly?

public class Penguin extends Bird {

    @Override
    public void eat() {
        System.out.println("Can I eat taco?");
    }

    @Override
    public void fly() {
        throw new UnsupportedOperationException("Help! I cannot fly!");
    }
}

We can check whether the principle still applied to our code or not by adding a Penguin object to the list of birds and run the code.

public static void main(String[] args) {
    List<Bird> birds = new ArrayList<Bird>();       
    birds.add(new Swan());
    birds.add(new Penguin());
    letBirdsFly(birds);
}

I believe I can fly!
Exception in thread "main" 
java.lang.UnsupportedOperationException: Help! I cannot fly!

Ops! it didn’t work as expected!

We can see that with the Swan object, the code worked perfectly. But with the Penguin object, the code threw UnsupportedOperationException. This violates the Liskov Substitution Principle as the Bird class has a child that didn’t use inheritance correctly, hence caused a problem. The Penguin tries to extend the flying logic, but it can’t fly!

We can fix this problem using the following if check:

public static void letBirdsFly(List<Bird> birds) {
    for(Bird bird: birds) {
        if(!(bird instanceof Penguin)) {
            bird.fly();
        }
    }
}

But this solution is considered a bad practice, and it violates the Open-Closed Principle. Imagine if we add another three types of birds that cannot fly. The code is going to become a mess. Notice also that one of the definitions for the Liskov Substitution Principle, which is developed by Robert C. Martin is:

Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it.

This is not the case with our solution, as we’re trying to know the type of the Bird object to avoid the misbehavior of the non-flying birds.

One of the clean solutions to solve this issue and refollow the principle is to separate the flying logic in another class.

public class Bird {

    public void eat() {
        System.out.println("I can eat.");
    }
}

public class FlyingBird extends Bird {

    public void fly() {
        System.out.println("I can fly.");
    }
}

public class Swan extends FlyingBird {

    @Override
    public void eat() {
        System.out.println("OMG! I can eat pizza!");
    }

    @Override
    public void fly() {
        System.out.println("I believe I can fly!");
    }
}

public class Penguin extends Bird {

    @Override
    void eat() {
        System.out.println("Can I eat taco?");
    }
}

Now we can edit the letBirdsFly method to support flying birds only.

public class Main {

    public static void letBirdsFly(List<FlyingBird> flyingBirds) {
        for(FlyingBird flyingBird: flyingBirds) {
            flyingBird.fly();
        }
    }

    public static void main(String[] args) {
        List<FlyingBird> flyingBirds = new ArrayList<FlyingBird>();     
        flyingBirds.add(new Swan());
        letBirdsFly(flyingBirds);
    }
}

The reason we forced the letBirdsFly method to accept flying birds only is to guarantee that any substitution for the FlyingBird will be able to fly. Now the program works as expected and outputs the following statements:

I believe I can fly!

You can see that the Liskov Substitution Principle is about using the inheritance relationship in the correct manner. You’ve to create subtypes of some parent if and only if they’re going to implement its logic properly without causing any problems.

We’ve reached the end of this journey, but we still have another two principles to cover. So take your time reading about this principle and make sure that you understand it before moving on. Stay tuned!

Open Closed Principle

Amr Saeed — Sat, 14 Nov 2020 10:18:20 +0000

Now it’s the time to start another journey with the second SOLID principle, the Open-Closed.

Open-Closed principle states:

“Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification”

What does that even mean? How could a software entity be opened and closed at the same time!

Let’s start explaining by using a real-world scenario to illustrate the problem, then moving into the solution and the technical details.

Photo viewers are used everywhere, literally. You can find them on social media platforms such as facebook or twitter. Also, you can find them on your smartphone as gallery applications. They’re considered a key feature in many apps.

If you decided to develop a photo viewer with your own, users would expect it to open photos of any type. It could be a JPEG photo. It might be a PNG. Sometimes it’s not the case that a specific type is supported by your photo viewer. Hence, you need to change the source code of your photo viewer to support that type.

How to guarantee that a new type added to your photo viewer won’t affect an already existing one? You may edit your application to support a GIF type, but it crashes the application when you open a PNG photo. How to prevent that from happening? And how to guarantee enough flexibility to add and remove other types in the future without affecting each other.

The solution is the Open-Closed principle, as you certainly would guess.

Recalling the PhotoViewer class from the Single Responsibility article with a slight change.

class PhotoViewer{
    void openPhoto(){
        System.out.println("Open JPEG photo!");  
    }
}

Now you wrote your photo viewer class, and you’re quite sure that it has to open JPEG photos only. Later you realized that your users are continuously trying to view PNG photos. And because your app doesn’t support it, it raises an error. So, you decided to edit the source code so that it supports PNG.

class PhotoViewer{  
    void openPhoto(String type){
        if(type == "JPEG"){      
            System.out.println("Open JPEG photo!");
        }    
        else if(type == "PNG"){
            System.out.println("Open PNG photo!");    
        }
        else{
            System.out.println("Photo type is not supported!");
        }
    }
}

Now, what are the problems of your code after making the changes?

What if you decided to add another type? Which is 100% going to happen now or then?

At that moment, you would add another else if statement. Adding a new type after another makes open photo function too large as a function. And because all types exist at the same place, removing some lines of code from one type may crash the others.

So the code is open for extension, which means you can extend it by other features. But not closed for modification, because every time you add a type you modify the open photo function lines of code. Many changes at the same block of code for different reasons is an indication of bad design.

Okay, I know you might have thought about separating JPEG and PNG into different functions at the photo viewer class. I’m with you, let’s try it!

class PhotoViewer{  
    void openJpegPhoto(){    
        System.out.println("Open JPEG photo!");
    }
    void openPngPhoto(){
        System.out.println("Open PNG photo!");
    }
}

Now your code is open for extension. You can add new types easily by adding new functions. But the same problem still exists. The solution is not 100% closed for modification, as the class lines of code are going to be affected by the changes. Also notice that adding another type to the photo viewer class is going to make it larger with more responsibilities. This violates the Single Responsibility Principle.

I know you’re tired, but believe me, it worth it.

The solution is about using Object-Oriented Programming features by using a generic interface to represent a generic photo type that any new type can implement.

interface Photo{
    void open();
}

class PhotoJpeg implements Photo{  
    void open(){    
        System.out.println("Open JPEG photo!");  
    }
}

class PhotoPng implements Photo{
    void open(){    
        System.out.println("Open PNG photo!");  
    }
}

class PhotoViewer(){  
    void openPhoto(Photo photo){    
        photo.open();  
    }
}

You can see that adding a new type won’t change a single line of code from the source code. You only need to implement the photo interface with the new type and send the photo to the photo viewer to be opened.

class PhotoGif implements Photo{  
    void open(){    
        System.out.println("Open GIF photo!");  
    }
}

The solution is 100% open for extension and closed for modification. Notice that the single responsibility principle is also applied.

Now you know that Open-Closed means that your code is open to be extended by new functionalities and closed in terms of changing the source code, but appending to it.

Wait for a new journey with the third SOLID principle, Liskov Substitution!

Single Responsibility Principle

Amr Saeed — Fri, 13 Nov 2020 17:14:41 +0000

If you are a passionate developer who’s interested in learning how to write high-quality software solutions, then you came into the right place, my friend.

One of the most common and effective software engineering principles is SOLID principles introduced by Robert C. Martin who is known as Uncle Bob. They are intended to make software designs more understandable, flexible, and maintainable.

SOLID is an acronym for 5 design principles:

Single responsibility.
Open-closed.
Liskov substitution.
Interface segregation.
Dependency inversion.

In this article, we’re going to talk about the first and easiest one which is the Single Responsibility principle.

Single responsibility principle says:

“A class should have only one reason to change”

But what does the phrase “only one reason” mean!

You know, I believe examples are the best teacher. Let’s read the following code snippet in order to understand.

class MusicPlayer{
   void playMusic(){
      System.out.println("Let the fun begins!");
   }
   void openPhoto(){
      System.out.println("Really! should I open the photo now?");
   }
}

As you can see we have a music player class that can play music and open photos.

Try to imagine that this class exists in some project at XYZ company who you work for. Khaled is a photographer at XYZ and uses the open photo function to open photos. Ali is another employee who is addicted to music and uses the play music function.

If Khaled decides to change the way photos are opened you are going to open MusicPlayer class and change the openPhoto function. Similarly, if Ali, a totally different employee, and maybe from a different department decided so. You will do the same but with the playMusic function.

We gave the class two different reasons to change and they are not related to each other. One for music and the other for photos. Besides, what is the relationship between MusicPlayer class and openPhoto function! I know you’ve thought openPhoto shouldn’t be there.

The class looks like a student who works at two totally different jobs. In software engineering, this is a bad practice. The more a class can do things the more it is susceptible to change, hence more bugs and problems.

Not only that, try to imagine if we decided to remove some lines of code from playMusic to find that openPhoto crashes. Different things in one place may affect each other. Bugs everywhere my friend, bugs everywhere!

So let’s separate the responsibilities and give a class one reason to change.

class MusicPlayer{
   void playMusic(){
      System.out.println("Let the fun begins!");
   }
}

class PhotoViewer{
   void openPhoto(){
      System.out.println("What about now should I open it?");
   }
}

Now if we decided to change the photo functionality at any time we won’t touch the music functionality and vice versa. Besides the functions are know logically related to the names of their classes.

In practice, it’s very hard to give the class only one reason to change with many functions exist, but what you can do is to keep its functions related as much as you can. This is generally known as cohesion in software engineering. Classes with high cohesion are an indication of good design.

You can apply a single responsibility principle also on functions. A function has to do one specific task no more no less.

Always ask yourself when you write a function what does it do? if you say it does something “and” something. And here means you’re doing it wrong.

This is the end of our journey for now.

Soon we’ll start another journey with the open-closed principle. Just wait for it!