DEV Community: Walid Bouladam

Unit Tests: Why is it important?

Walid Bouladam — Thu, 19 Jan 2023 08:18:20 +0000

Unit testing is a software development practice in which individual units or components of a software application are tested in isolation from the rest of the application. The goal of unit testing is to validate that each unit of the software application is working as intended. In this article, we will discuss why unit testing is important and how it can benefit your software development process.

One of the main benefits of unit testing is that it helps to catch bugs early in the development process. When a unit test fails, it is an indication that there is a problem with the unit of code being tested. By catching bugs early, unit testing can save time and resources that would have been spent on debugging and fixing problems later in the development process. Additionally, unit testing can help to prevent the introduction of new bugs by providing a safety net for code changes.

Another benefit of unit testing is that it helps to ensure code quality. Unit tests serve as a form of documentation for the code, as they specify how the code should behave. Additionally, by writing unit tests, developers are forced to think about the design of their code and how it can be tested. This can lead to better code design and maintainability.

Unit testing also helps to increase code reuse. When a unit of code is thoroughly tested, it is more likely to be reused in other parts of the application. Additionally, unit tests can serve as a form of regression testing, ensuring that code changes do not break existing functionality.

Unit testing also enables developers to work on a codebase with more confidence. With a comprehensive suite of unit tests, developers can make changes to the codebase without worrying about introducing bugs. This can lead to faster development and more efficient use of resources.

In addition, unit tests can also help to improve code collaboration. When multiple developers are working on a codebase, unit tests can serve as a form of communication, making it clear how the code should behave and how it can be tested. This can help to reduce misunderstandings and prevent bugs from being introduced.

Finally, unit testing is a key part of continuous integration and delivery (CI/CD) pipeline. Unit tests are run automatically as part of the build process, ensuring that the code is working as intended before it is deployed to production. This can help to reduce the risk of introducing bugs into production and improve the overall quality of the software.

In conclusion, unit testing is a crucial practice in software development. It helps to catch bugs early, ensures code quality, increases code reuse, enables developers to work with more confidence, improves code collaboration and it is a key part of CI/CD pipeline. By incorporating unit testing into your software development process, you can improve the quality of your software and save time and resources in the long run.

SOLID Principles for Programming and Software Design

Walid Bouladam — Thu, 15 Dec 2022 07:23:28 +0000

Hey y'all!

This article will go over the following:

What are the SOLID principles?
Why are they used in Object-Oriented programming?

I will also provide examples of how we can implement the SOLID principles when programming, using PHP, which is the language I am currently using as I learn about Object-Oriented programming.

What are the SOLID principles?

The SOLID principles are a set of five principles of object-oriented software design intended to make software designs more understandable, flexible, and maintainable. The principles are:

Single Responsibility Principle: A class should have one and only one reason to change, meaning it should only have one job or responsibility.
Open/Closed Principle: A class should be open for extension, but closed for modification. This means that new functionality should be added by extending the class, rather than modifying its existing code.
Liskov Substitution Principle: Derived classes should be substitutable for their base classes. This means that any instance of a base class should be able to be replaced with an instance of a derived class without breaking the application.
Interface Segregation Principle: Clients should not be forced to implement interfaces they don't use. This means that you should split large interfaces into smaller, more specific ones so that clients only have to implement the methods that they need.
Dependency Inversion Principle: High-level modules should not depend on low-level modules. Both should depend on abstractions. This means that you should use abstractions, such as interfaces, to decouple your code and make it more flexible.

Why are they used in Object-Oriented programming?

The SOLID principles are important in Object-Oriented programming because they help to create software designs that are more understandable, flexible, and maintainable.

The Single Responsibility Principle, for example, helps to ensure that a class has a well-defined purpose and is not trying to do too many things at once. This makes the code easier to understand and reduces the likelihood of introducing bugs when making changes.

The Open/Closed Principle, on the other hand, promotes code reuse and extensibility by allowing new functionality to be added through inheritance rather than modifying existing code. This makes the code more flexible and easier to maintain.

Overall, following the SOLID principles can help to create more robust and scalable software designs.

Examples

Single Responsibility Principle

Here is an example of the Single Responsibility Principle being implemented in PHP:

// A class that handles user authentication
class UserAuth
{
    public function login($username, $password)
    {
        // Check the user's credentials and log them in
    }

    public function logout()
    {
        // Log the user out of the system
    }
}

In this example, the UserAuth class has a single responsibility, which is to handle user authentication. It has two methods, login() and logout(), which allow users to log in and out of the system. This class does not try to do anything else, such as managing user profiles or sending emails, and is therefore following the Single Responsibility Principle. This makes the code easier to understand and maintain.

Open/Closed Principle

Here is an example of the Open/Closed Principle being implemented in PHP:

// A base class for a bank account
abstract class BankAccount
{
    protected $balance;

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

    public function getBalance()
    {
        return $this->balance;
    }

    abstract public function deposit($amount);
    abstract public function withdraw($amount);
}

// A class that extends the BankAccount class to add support for interest
class SavingsAccount extends BankAccount
{
    private $interestRate;

    public function __construct($balance, $interestRate)
    {
        parent::__construct($balance);
        $this->interestRate = $interestRate;
    }

    public function deposit($amount)
    {
        // Calculate the interest earned and add it to the balance
    }

    public function withdraw($amount)
    {
        // Withdraw the given amount from the balance
    }
}

In this example, the BankAccount class is defined as an abstract base class, which means that it cannot be instantiated on its own. It defines two abstract methods, deposit() and withdraw(), which must be implemented by any derived classes. This allows the BankAccount class to be extended to support different types of accounts, such as savings accounts, without modifying its existing code. For example, the SavingsAccount class extends BankAccount and adds support for interest. This follows the Open/Closed Principle by allowing new functionality to be added through inheritance, rather than modifying the base class. This makes the code more flexible and easier to maintain.

Liskov Substitution Principle

Here is an example of the Liskov Substitution Principle being implemented in PHP:

// A base class for a rectangle
class Rectangle
{
    protected $width;
    protected $height;

    public function __construct($width, $height)
    {
        $this->width = $width;
        $this->height = $height;
    }

    public function getArea()
    {
        return $this->width * $this->height;
    }
}

// A class that extends the Rectangle class to represent a square
class Square extends Rectangle
{
    public function __construct($side)
    {
        parent::__construct($side, $side);
    }
}

In this example, the Rectangle class defines a base class for a rectangle with a width and a height. It also has a getArea() method that calculates the area of the rectangle. The Square class extends Rectangle and represents a square, which is a special type of rectangle with equal sides. However, instead of defining its own width and height properties, it sets the width and height of the Rectangle class to the same value, which is the side length of the square. This allows any instance of the Square class to be used in place of an instance of the Rectangle class without breaking the application. This follows the Liskov Substitution Principle by ensuring that derived classes are substitutable for their base classes. This makes the code more flexible and easier to maintain.

Interface Segregation Principle

Here is an example of the Interface Segregation Principle being implemented in PHP:

// An interface that defines methods for a database connection
interface DatabaseConnection
{
    public function connect();
    public function query($sql);
    public function disconnect();
}

// An interface that defines methods for a MySQL database connection
interface MySQLConnection extends DatabaseConnection
{
    public function getMySQLVersion();
}

// A class that implements the MySQLConnection interface
class MySQL implements MySQLConnection
{
    public function connect()
    {
        // Connect to a MySQL database
    }

    public function query($sql)
    {
        // Execute a query on the MySQL database
    }

    public function disconnect()
    {
        // Disconnect from the MySQL database
    }

    public function getMySQLVersion()
    {
        // Return the version of the MySQL server
    }
}

In this example, the DatabaseConnection interface defines three methods that must be implemented by any class that implements the interface: connect(), query(), and disconnect(). These methods are common to any type of database connection. However, the MySQLConnection interface extends DatabaseConnection and adds a fourth method, getMySQLVersion(), which is specific to MySQL connections. This allows the MySQLConnection interface to be implemented by classes that need to connect to MySQL databases, without forcing them to implement the methods from the `DatabaseConnection interface that they don't need. This follows the Interface Segregation Principle by splitting a large interface into smaller, more specific ones. This makes the code more flexible and easier to maintain.

Dependency Inversion Principle

Here is an example of the Dependency Inversion Principle being implemented in PHP:

// An interface that defines methods for a logger
interface Logger
{
public function log($message);
}

// A class that implements the Logger interface
class FileLogger implements Logger
{
public function log($message)
{
// Log the given message to a file
}
}

// A class that uses the FileLogger class to log messages
class User
{
private $logger;

public function __construct(Logger $logger)
{
    $this->logger = $logger;
}

public function login()
{
    // Log a message when the user logs in
    $this->logger->log('User logged in.');
}

public function logout()
{
    // Log a message when the user logs out
    $this->logger->log('User logged out.');
}

}

In this example, the User class depends on the Logger interface to log messages. It does not depend on a specific implementation of the Logger interface, such as the FileLogger class. This means that the User class is not tied to a specific logging mechanism and can be used with any class that implements the Logger interface. For example, you could create a DatabaseLogger class that implements the Logger interface and logs messages to a database, and use it with the User class without modifying its code. This follows the Dependency Inversion Principle by depending on abstractions, rather than concretions. This makes the code more flexible and easier to maintain.

Summary

The SOLID principles are a set of principles of object-oriented software design that are intended to make software designs more understandable, flexible, and maintainable. The principles focus on the separation of concerns, the use of abstraction, and the dependency of high-level modules on abstractions rather than concretions. By following these principles, developers can create software designs that are more robust, scalable, and easier to maintain.

Database Normalisation

Walid Bouladam — Thu, 08 Dec 2022 07:21:08 +0000

Hey y'all!

In this blog, I will explain the following:

What database normalisation is?
Why database normalisation is important?
How can we normalise a data model?

What database normalisation is?

Database normalisation is the process of organizing a database in a way that reduces redundancy and dependency. It is a fundamental concept in database design, as it helps to ensure data integrity and improve the performance of the database.

Why database normalisation is important?

Database normalisation is important because it helps to eliminate data redundancy, which can lead to a number of problems. For example, redundant data can cause data inconsistencies, in which different parts of the database contain conflicting information. This can make it difficult to trust the accuracy of the data, and can lead to errors in applications that rely on the database.

Redundant data can also take up a lot of unnecessary space, which can slow down the performance of the database. By eliminating redundancy, database normalisation can help to improve the performance of the database, and make it more efficient.

How can we normalise a data model?

To normalize a data model, we start by identifying the entities in the model, and the relationships between them. Then, we apply a series of normal forms, which are a set of rules for organizing the data in the database. The most common normal forms are:

First Normal Form (1NF):
The first normal form requires that all data in the database be stored in a simple, flat table, with no repeating groups of data. Each column in the table must have a unique name, and each row must be uniquely identified by a primary key.
Second Normal Form (2NF):
The second normal form builds on the first normal form by requiring that all non-key columns in the table be dependent on the primary key. This means that the data in these columns must be related to the primary key, and cannot be dependent on any other non-key columns in the table.
Third Normal Form (3NF):
The third normal form builds on the second normal form by requiring that all non-key columns in the table be independent of each other. This means that the data in these columns must not be dependent on any other non-key columns in the table, and can only be dependent on the primary key.

Example

Suppose we have a table that stores data about books, with the following columns:

BookId: a unique identifier of each book
Title: the title of the book
Author: the author of the book
Publisher: the publisher of the book
Genre: the genre of the book

Here's what the table might look like in first normal form (1NF):

BookId	Title	Author	Publisher	Genre
1	The Cat in the Hat	Dr. Seuss	Random House	Children's
2	1984	Geroge Orwell	Penguin	Dystopian
3	The Great Gatsby	F. Scott Fitzgerald	Scribner	Literary

In this table, the BookId column serves as the primary key, and each book has a unique identifier. This table is in first normal form because it satisfies the basic requirements for 1NF, which are:

The data is stored in a table
The table has a unique primary key
Each row in the table is unique and identifiable

Now, let's move on to second normal form (2NF). In order to be in 2NF, a table must satisfy the requirements for 1NF, plus the following additional requirement:

All data in the table must be fully dependent on the primary key

In order to make our table meet this requirement, we need to remove any data that is not directly related to the primary key. For example, the Publisher and Genre columns are not directly related to the BookId column, so we should move that data to a seperate table. Here's what the table might look like in 2NF:

BookId	Title	Author
1	The Cat in the Hat	Dr. Seuss
2	1984	Geroge Orwell
3	The Great Gatsby	F. Scott Fitzgerald

Now, let's move on to third normal form (3NF). In order to be in 3NF, a table must satisfy the requirements for 2nF, plus the following additional requirement:

No data in the table should be dependent on any other data in the tale, except through the primary key

In our example, the Publisher and Genre data is dependent on the BookId, but not on any other data in the table. So, we can move that data to a seperate table, like this:

BookId	Title	Author
1	The Cat in the Hat	Dr. Seuss
2	1984	Geroge Orwell
3	The Great Gatsby	F. Scott Fitzgerald

BookId	Publisher	Genre
1	Random House	Children's
2	Penguin	Dystopian
3	Scribner	Literary

Now, our table is in third normal form because it satisfies the requirements for 1NF, 2NF and 3NF. This means that our data is organized in a logical and efficient way, and we can easily access and manipulate it as needed.

In summary, database normalisation is a crucial concept in database design, as it helps to ensure data integrity and improve the performance of the database. By applying the normal forms, we can organize the data in a way that eliminates redundancy, and makes the database more efficient and reliable.

Simple guide to start you off on your programming journey

Walid Bouladam — Sat, 27 Aug 2022 06:50:04 +0000

Are you interested in learning how to code but not sure where to begin? Coding can be intimidating for beginners. It often feels like a skill that is reserved for tech-savvy people who understand complex logic and can read monstrous manuals like they’re second nature. Luckily, that’s not the case! Anyone can learn how to code, even if you have no previous experience with programming. Once you learn the basics of coding, it opens up a world of possibilities for your future career or personal endeavours. Let’s take a look at why you should learn how to code and some great resources if you’re ready to get started!

Why should you learn how to code?

You can create new websites and apps without hiring developers. You can automate repetitive tasks at work. You can understand how the internet works. These are just a few of the many reasons why you should learn how to code. As more and more of our lives are lived online, it is more important than ever to understand how everything works.

What does coding feel like?

When you are first learning how to code, it can feel a bit like learning a new language. You will likely feel overwhelmed by all of the new terminology, techniques, and concepts. As you begin to understand the basics, though, you’ll notice that you are actually capable of doing a lot more than you ever thought possible! Programming is a creative process. Even experienced coders often find that they need to experiment before they can find a suitable solution. Once you start to get the hang of it, you will find that you can create almost anything you set your mind to. You don’t need to understand how everything works right away. Learning how to code can be overwhelming. That’s why it is important to focus on the basics and build your knowledge from there.

Free resources for beginner programmers

Codecademy
Codecademy is easily the best free resource for beginners. The website features interactive lessons that walk you through everything you need to know to get started with web development.

Free Code Camp
Free Code Camp features a very helpful beginner curriculum. Once you finish a section, you can unlock a “badge” that verifies your knowledge. Free Code Camp also has a “real-world” section, which challenges you to create real-life projects. These projects can often be turned into your first freelance projects, which can be a great way to start making money as a coder.

Hacker Rank
Hacker Rank is a platform where you can practice programming challenges. You can also find challenges that employers are looking for on this platform.

Bottom line

Learning how to code is a great skill to have, especially in an age when so much of our lives are lived online. It can open up a lot of opportunities for your future and can even be a source of income if you decide to become a freelance coder. Beginners should focus on the basics but can learn a lot from those free resources. Once you get the hang of it, coding can be a very rewarding skill.