Forem: Sadisha Nimsara

SOLID Principles

Sadisha Nimsara — Sun, 20 Oct 2024 16:02:43 +0000

SOLID is a collection of fundamental principles designed to enhance the manageability and scalability of code in Object-Oriented Programming (OOP). It consists of five key principles:

S ingle Responsibility Principle — SRP
O pen-Closed Principle — OCP
L iskov’s Substitution Principle — LSP
I nterface Segregation Principle — ISP
D ependency Inversion Principle — DIP

These principles were introduced by Robert C. Martin (also known as Uncle Bob) in the early 2000s and have since become widely adopted in the software development community. By following SOLID principles, developers can create code that is easier to understand, modify, and extend, leading to more robust and maintainable software systems.

Single Responsibility Principle (SRP)

Single Responsibility Principle is the first and most fundamental principle in OOP and SOLID. As the name sounds, this principle means “One class should have only one specific responsibility to take care of”.

Suppose we have a class called Invoice , which contains 2 methods generateInvoice() and saveToFiles() .

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }

  public void saveToFiles() {
    // code to save invoice as a file.
  }
}

This is not a good practice because the Invoice class has two responsibilities. A better approach would be to separate these functionalities into dedicated classes.

public class Invoice {
  private Long InvoiceNo;

  public void generateInvoice() {
    // code to generate Invoice.
  }
}

public class FileManager {
  public void saveToFiles(Invoice invoice) {
    // code to save invoice as a file.
  }
}

Here, we can see we have 2 classes for the use case:

Generating the invoice
Save it to files

Benefits of following SRP

Improved Code Organization : By separating concerns into different classes, the codebase becomes more organized and easier to navigate.
Better Maintainability : When a class has a single responsibility, it is easier to understand its purpose and make changes without unintended side effects.
Increased Reusability : Classes with a single responsibility are more likely to be reusable in different parts of the application or even in other projects.
Easier Testing : Classes with a single responsibility are typically smaller and more focused, making them easier to test in isolation.

Open-Closed Principle (OCP)

Open-Closed principle is another core principle in SOLID. This principle was introduced by Bertrand Meyer in 1997. The idea behind this principle is “Software artifacts (classes, modules, and functions) should open for extensions, but closed for modifications.”

For example;

Let’s say, we have a class called Shape , we can use this class to calculate the area of the shape.

public class Shape {
    private String shapeType;
    private double radius;
    private double length;
    private double width;

    public Shape(String shapeType, double radius, double length, double width) {
        this.shapeType = shapeType;
        this.radius = radius;
        this.length = length;
        this.width = width;
    }

    public double area() {
        if (shapeType.equals("circle")) {
            return Math.PI * (radius * radius);
        } else if (shapeType.equals("rectangle")) {
            return length * width;
        } else {
            throw new IllegalArgumentException("Unknown shape type");
        }
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Shape circle = new Shape("circle", 5, 0, 0);
        Shape rectangle = new Shape("rectangle", 0, 4, 6);

        System.out.println(circle.area());
        System.out.println(rectangle.area());
    }
}

In the code above, adding a new shape requires modifying the existing Shape class, which is not considered a good practice.

Below is a code example that demonstrates how to apply the Open-Closed Principle to this scenario.

public interface Shape {
  public double area();
}

class Circle implements Shape {
    private double radius;

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

    @Override
    public double area() {
        return Math.PI * (radius * radius);
    }
}

class Rectangle implements Shape {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public double area() {
        return length * width;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);

        System.out.println(circle.area());
        System.out.println(rectangle.area());
    }
}

With the application of OCP, we can add many shapes as we want without modifying the current implementation.

NOTE: Using interfaces is not the only way to achieve OCP.

Benefits of following OCP

Reduced Risk of Bugs : By not modifying existing code, the risk of introducing new bugs or breaking existing functionality is minimized.
Improved Maintainability : Code that follows the OCP is easier to maintain and extend, as new features can be added without altering the existing codebase.
Enhanced Flexibility : The use of abstractions and polymorphism allows for more flexible and adaptable designs, making it easier to accommodate changing requirements.

Liskov’s Substitution Principle (LSP)

Liskov’s Substitution Principle is another important principle in OOP. It was introduced by Barbara Liskov in 1987 during a conference talk on data abstraction.

The principle states, “Objects of a superclass should be replaceable with objects of its subclasses without altering the correctness of the program”.

For example, if Circle and Rectangle are sub types of Shape, then we should be able to replace Shape object with a Circle or Rectangle object without any issues.

public interface Shape {
  public double area();
}

class Circle implements Shape {
    private double radius;

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

    @Override
    public double area() {
        return Math.PI * (radius * radius);
    }
}

class Rectangle implements Shape {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public double area() {
        return length * width;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5); // Replace Shape object with Circle
        Shape rectangle = new Rectangle(4, 6); // Replace Shape object with Rectangle

        System.out.println(circle.area());
        System.out.println(rectangle.area());
    }
}

As demonstrated in this example, adhering to the Liskov Substitution Principle means we should be able to substitute a superclass instance with a subclass instance seamlessly.

Benefits of following LSP

Improved Code Reusability : By ensuring that subtypes can be substituted for their base types, code that uses the base type can also work with any of its subtypes, promoting code reuse.
Enhanced Maintainability : Code that follows LSP is easier to maintain because it reduces the risk of introducing bugs when modifying or extending the codebase.
Better Testability : LSP makes it easier to write unit tests for classes and their subtypes, as the tests can be written against the base type and should work for all subtypes.

Interface Segregation Principle (ISP)

The Interface Segregation Principle is one of the five SOLID principles introduced by Robert C. Martin. It states: “Clients should not be forced to depend on interfaces they do not use”.

In other words, Using many task specific interfaces is better than using one general purpose interface.

Below example shows the usage of general purpose interface.

public interface MultifunctionPrinter {
    void printDocument(Document document);
    void scanDocument(Document document);
    void faxDocument(Document document);
}

public class BasicPrinter implements MultifunctionPrinter {
    @Override
    public void printDocument(Document document) {
        System.out.println("Printing: " + document.name());
    }

    @Override
    public void scanDocument(Document document) {
        throw new UnsupportedOperationException("Scanning not supported.");
    }

    @Override
    public void faxDocument(Document document) {
        throw new UnsupportedOperationException("Faxing not supported.");
    }
}

Using a general-purpose interface like MultifunctionPrinter forces us to implement unnecessary methods, which is considered bad practice. Let’s explore how we can apply the Interface Segregation Principle to this scenario.

Interfaces

public interface Printer {
    void printDocument(Document document);
}

public interface Scanner {
    void scanDocument(Document document);
}

public interface Fax {
    void faxDocument(Document document);
}

Implementations

public class BasicPrinter implements Printer {
    @Override
    public void printDocument(Document document) {
        System.out.println("Printing: " + document.name());
    }
}

public class AdvancedPrinter implements Printer, Scanner {
    @Override
    public void printDocument(Document document) {
        System.out.println("Printing: " + document.name());
    }

    @Override
    public void scanDocument(Document document) {
        System.out.println("Scanning: " + document.name());
    }
}

public class FaxMachine implements Fax {
    @Override
    public void faxDocument(Document document) {
        System.out.println("Faxing: " + document.name());
    }
}

By applying the ISP , we split it into smaller, role-specific interfaces — like Printer, Scanner, and Fax. This allows each class (e.g. BasicPrinter, AdvancedPrinter, or FaxMachine) to implement only the relevant functionality, promoting modularity and reducing unnecessary dependencies.

Benefits of following ISP

Modular and Reusable Code : By breaking down large interfaces into smaller, more specific ones, the code becomes more modular and reusable. Classes or modules can implement only the interfaces they need, reducing unnecessary dependencies and making it easier to reuse code across different parts of the system.
Reduced Code Complexity : When classes or modules depend only on the interfaces they need, the code becomes less complex and easier to understand. This is because developers do not have to deal with unnecessary methods or dependencies. These are not relevant to their specific use case.
Improved Maintainability : With smaller and more focused interfaces, it becomes easier to maintain the code. Changes to one interface are less likely to affect other parts of the system, reducing the risk of introducing bugs or breaking existing functionality.
Better Testability : Smaller and more focused interfaces make it easier to write unit tests for individual components. This is because the tests can focus on specific behaviors without being affected by irrelevant methods or dependencies.
Increased Flexibility : By adhering to the ISP, the system becomes more flexible and easier to extend or modify. New features or requirements can be added by creating new interfaces or modifying existing ones without affecting the entire system.

Dependency Inversion Principle (DIP)

Dependency Inversion Principle is the final principle of SOLID. Which was also introduced by Robert C. Martin. This promotes loosely-coupled code.

DIP states few points:

High-level modules should not depend on low-level modules.
Both should depend on abstraction.
Abstraction should not depend on details.
Details should depend on abstraction.

In simple terms, instead of a class directly depending on other specific classes (concrete implementations), it should depend on interfaces or abstract classes. This makes the code more flexible and easier to maintain, as you can swap out implementations without changing the dependent class.

Tightly coupled code (without DIP)

public class Keyboard {
    public void type() {
        System.out.println("Typing...");
    }
}

public class Computer {
    private Keyboard keyboard;

    public Computer() {
        this.keyboard = new Keyboard(); // Direct dependency
    }

    public void use() {
        keyboard.type();
    }
}

As shown in the example above, the Computer class directly depends on the Keyboard class.

Loosely coupled code (with DIP)

public interface InputDevice {
    void type();
}

pubic class Keyboard implements InputDevice {
    @Override
    public void type() {
        System.out.println("Typing...");
    }
}

public class Computer {
    private InputDevice inputDevice;

    public Computer(InputDevice inputDevice) {
        this.inputDevice = inputDevice; // Depends on abstraction
    }

    public void use() {
        inputDevice.type();
    }
}

Now, Computer depends on the InputDevice interface, not a specific Keyboard. This makes it easy to switch to another input device, like a WirelessKeyboard, without modifying the Computer class.

Benefits of following DIP

Loose Coupling : By depending on abstractions rather than concrete implementations, the code becomes less tightly coupled, making it easier to change one part of the system without affecting others.
Improved Maintainability : Changes in low-level modules do not impact high-level modules, making the system easier to maintain and extend.
Enhanced Testability : High-level modules can be tested using mock implementations of the low-level modules, making testing faster and more reliable.
Increased Reusability : High-level modules can be reused in different contexts without needing to change the low-level modules they depend on.

Conclusion

In conclusion, the SOLID principles: Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion provide essential guidelines for writing clean, maintainable, and scalable code in object-oriented programming.

By adhering to these principles, developers can create systems that are easier to understand, modify, and extend, ultimately leading to higher quality software and more efficient development processes.

Summary

Thank you for reading this article! I hope you now have a solid understanding of the SOLID principles and how you can apply them to enhance your projects.

Follow me on:

LinkedIn — @nsadisha
GitHub — @nsadisha
Medium — @nsadisha
Dev.to — @nsadisha

— Sadisha Nimsara

OOP Simplified!

Sadisha Nimsara — Thu, 04 Apr 2024 05:12:17 +0000

Introduction

In this article, you will learn and understand Object-Oriented Programming (OOP) principles, which are essential for every software engineer and developer. I emphasize “understand” here because, many individuals, especially beginners, acquire knowledge of OOP principles from various sources without grasping how to apply them in programming. Therefore, I hope that this article will assist them in understanding OOP principles thoroughly.

Pre-requisites

This article explains OOP concepts using Java. To fully benefit from this content, I recommend that you possess a foundational understanding of programming fundamentals, including syntax, data types, variables, functions, and packages.

Enjoy your learning journey!

Why OOP?

OOP simplifies programs by translating real-world concepts into programming. It involves mapping real-world objects to objects within the program, making programs more manageable and comprehensible.

Classes & Objects

Understanding this concept is crucial. If you’ve seen Java code previously, you’ve likely noticed the keyword class. We can view a class as a blueprint for a real-world object. A class contains properties and behaviours. In OOP, we call them instance variables and methods.

For instance, just like a building plan (blueprint) contains the entire structure of a building, in OOP terms, we can consider the blueprint as the class and the building as an object. It’s important to note that multiple buildings can be constructed using the same plan (blueprint).

To create an object from a class, we call the constructor. A class can have multiple constructors. In cases where the developer doesn’t specify one, a default constructor will be used. To create an object, we invoke the constructor using the new keyword, followed by the class name and parentheses.

// defauled constructor
User user = new User();

// user defined constructor
// accepts name as a parameter
User user2 = new User("Sadisha Nimsara");

Interface

Interfaces in programming define the structure of a class , much like how a class serves as a blueprint for an object. Interfaces contain public static final variables and abstract methods. (An abstract method is a method that does not have a body.)

public interface User {
  // all variables must be declared as public, static, and final
  public static final String type;

  // this is also public, static, and final by default.
  // only in newer java version
  String _type;

  // interface method (does not have a body)
  public void setType();
}

OOP Concepts

There are four OOP principles. These principles form the foundation of object-oriented design and programming principles.

Inheritance
Abstraction
Encapsulation
Polymorphism

Let’s discuss them one by one.

Inheritance

Inheritance refers to establishing connections between classes.

Extend or Implement?

In Java, we utilize the keywords extends and implements to accomplish inheritance. Inheritance can take various forms, including:

Inherit class from another class — use extends
Inherit class from an interface — use implements
Inherit interface from another interface — use extends

This process of inheritance establishes a relationship between a Parent class (superclass) and a Child class (subclass). Put simply, the parent class provides inheritance, while the child class receives it.

The way we can achieve properties and methods from parent class is using the super keyword. If you want to call the constructor of the super class, you may call super(); .

class User {
  public String name;

  public float calculateSalary() {
    // calculate the salary
    return 0;
  }
}

class Employee extends User {
  public int id;

  public Enployee(int id) {
    // calls the constructor of the super class
    super();
  }

  public String getName() {
    // get a property value from super class
    return super.name;
  }

  public float getSalary() {
    // calling a method from super class
    return super.calculateSalary();
  }
}

As you can see in this example, User class has one property called name and one method called calculateSalary(). Employee class is extended from the User class. So it gets inheritance from User class. Thats why we can access nameand calculateSalary() methods within the Employee class by calling super.name and super.calculateSalary() .

If you’re curious about how data is accessible to child classes, we can manage the access of inherited properties and methods using Access Modifiers. This concept is known as Encapsulation , and we’ll delve into it later in this article.

Inheritance Types

There are multiple inheritance types as you can see in this picture. But, Java does not support Multiple inheritance for classes by default. However, we can use interfaces to achieve multiple inheritance in java.

interface A { 
  /* some methods */
}

interface B {
  /* some methods */
}

public class C implements A, B{
  /* overriden methods from A and B */
}

As you can see in the above example, Class C inherits all the properties and behaviours in Interface A and Interface B .

Abstraction

Abstraction stands as a fundamental principle in Object-Oriented Programming. It defines a model to create an application component. The implementation of abstraction depends on the language-specific features and processes.

In a nutshell, This means hiding the implementation and providing the functionality.

For instance, when you start your car, you simply insert the key and turn it or press the start button. The complex internal workings involved in starting the car are abstracted from you, where the implementation remains hidden, and only the functionality is visible.

There are two ways to achieve abstraction in java:

Abstract classes(0 to 100% abstraction)
Interfaces (100% abstraction)

Abstract classes

An abstract class is defined with the abstract keyword and can include data properties like a regular class. Additionally, it can contain both abstract and non-abstract methods. We cannot instantiate an object directly from an abstract class; instead, it must be extended by a child class.

abstract class User {
  protected String name;
  protected float age;
  protected float salaryRate;

  // regular method
  public String getName() {
    return this.name;
  }

  // abstract method
  // does not have a method body
  // must be overridn by a child class
  public abstract void calculateSalary();
}

public class Employee extends User {

  @Override
  public void calculateSalary() {
    // calculate the salary
  }

}

public class Main {
  public static void main(String[] args) {

    User user = new User(); // not allowed (error)

    Employee employee1 = new Employee(); // allowed

    User employee2 = new Employee(); // allowed

  }
}

Interfaces

An interface is an example of an abstract class that achieves 100% abstraction. But, if we use interfaces, data properties are common for all the clid classes. Because, interfaces have public static and final variables.

interface Vehicle {
  public void start();
  public void accelerate();
  public void stop();
}

public class Car extends Vehicle {

  @Override
  public void start() {
    // start a car
  }

  @Override
  public void accelerate() {
    // accelerate a car
  }

  @Override
  public void stop() {
    // stop a car
  }

}

public class Main {
  public static void main(String[] args) {

    Vehicle vehicle = new Vehicle(); // not allowed (error)

    Car car1 = new Car(); // allowed

    Vehicle car2 = new Car(); // allowed

  }
}

When to use Abstract classes and when to user Interfaces

Suppose A is an interface, and B and C are A’s subclasses.

If B and C share the same properties with identical values, it’s preferable to use interfaces.

However, if B and C have the same properties but different values for them, abstract classes would be a better choice.

Encapsulation

Encapsulation involves restricting access to data and methods within classes. Classes consist of variables and methods. We can manage how other classes access these variables and methods. This concept is known as encapsulation.

There are four access modifiers used to restrict access within a class:

Default (No keyword): Limits access to classes within the same package.
Private: Limits access to the class itself.
Protected: Limits access to the same class and its subclasses.
Public: Removes all access restrictions.

There is a misconception about this: “Encapsulation increases security.” However, that is not the case. Encapsulation is not directly related to security.

Default (No keyword)

public class User {
  int id;
  string name;
  Date birthday;
  float age;

  void calculateAge() { /*calculates the age from birthday*/ }
}

All the variables and methods can be accessed within the package.

Private

public class User {
  private int id;
  private string name;
  private Date birthday;
  private float age;

  void calculateAge() { /*calculates the age from birthday*/ }
}

In this example, all variables can be accessed within the class. However, the calculateAge() method can only be accessed within the package.

Protected

public class User {
  protected int id;
  protected string name;
  protected Date birthday;
  protected float age;

  void calculateAge() { /*calculates the age from birthday*/ }
}

public class Employee extends User {

  String getName() {
    return super.name;
  }
}

The property name can be accessed within the User class since it is a protected field. Consequently, child classes will also have access to protected properties.

Public

public class User {
  private String name;

  public String getName() {
    return this.name;
  }
}

In this example, the name field is private to the User class, meaning it cannot be accessed from outside the class. However, the getName() method is public, allowing it to be used from anywhere.

Abstraction vs Encapsulation

Polymorphism

Polymorphism stands out as a cornerstone concept in Object-Oriented Programming (OOP), highlighting the capacity of an entity to manifest or exist in multiple forms. These diverse manifestations emerge as entities that can assume varied meanings and serve different purposes across various contexts.

The word polymorphism was also constructed using 2 words.

Poly — Means multiple
Morphism — Behaviours

For example, Cat, Dog, Cow are Animals. Here, we can take the Animal as the parent class and Cat, Dog, Cow as the child classes of Animal. All animals make sounds. But, differently. That is the concept of polymorphism.

In programming, mainly there are 2 types of polymorphism.

Runtime polymorphism
Compile-time polymorphism

Runtime polymorphism

Method overriding enables the attainment of runtime polymorphism. In Java, the Java Virtual Machine (JVM) identifies the correct method to invoke during runtime, not during compilation. This mechanism is also referred to as dynamic or late binding.

A behaviour of parent is replaced by the same behaviour of child.

interface Animal {
  // abstract method without a body
  public void speak();
}

class Cat implements Animal {
  @Override
  public void speak() {
    // how cat speaks
    System.out.println("Meow");
  }
}

class Dog implements Animal {
  @Override
  public void speak() {
    // how dog speaks
    System.out.println("Woof");
  }
}

In runtime polymorphism, only the method body will change. It does not change the method signature.

Compile-time polymorphism

Compile-time polymorphism is achieved by Method overloading. When an object is associated with its functionality during compilation, it is termed compile-time polymorphism. During compilation, Java determines which method to invoke based on method signatures, leading to compile-time polymorphism, also known as static or early binding.

public class Calculator {

  public int add(int a, int b) {
    return a + b;
  }

  public double add(double a, double b) {
    return a + b;
  }

}

In this example, you can observe that the Calculator class contains two distinct add() methods. It’s important to note that we cannot have the same method repeated within the same class. However, these methods are differentiated by their method signatures, making them distinct despite sharing the same name.

public int add( int a, int b)
public double add( double a, double b)

The first method accepts two integers as parameters and returns an integer , while the second method accepts two doubles as parameters and returns a double. During compile time, we can call either of these methods. The compiler determines which method to invoke based on the arguments provided when invoking these methods.

Compile Time vs Runtime polymorphism

Source: GeeksForGeeks

I hope this article has provided you with a simplified and comprehensive understanding of Object-Oriented Programming (OOP) concepts. Thank you for taking the time to read this article. May your journey in software development be filled with creativity and success!

Happy coding!

Android MVVM data binding with ViewModel

Sadisha Nimsara — Fri, 04 Nov 2022 06:45:48 +0000

Hello everyone, this article is about how you can implement android MVVM architecture to your android application. I thought to right this article because I was having many troubles when I first using the android MVVM pattern. So, I wanted other people not to face same problems again.

Introduction

MVVM is an architectural design pattern, which helps us to accomplish separation of concerns. Also it is used to build reusable and testable native android applications.

What is MVVM?

MVVM stands for:

Model — This holds the data of the application. It cannot directly talk to the View. Generally, it’s recommended to expose the data to the ViewModel through Observables.
View — Simply this is the user interface of the application. Does not contain any application logic.
View Model — It acts as a link between the Model and the View. It’s responsible for transforming the data from the Model. It provides data streams to the View. It also uses hooks or callbacks to update the View. It’ll ask for the data from the Model.

MVVM

There are 3 possible ways to bind data with a view model in android. Those are:

Two way data binding
Binding using LiveData
Binding using RxJava

In this article, we are going to learn binding using LiveData. We will be using Kotlin as the PL. Let’s begin.

Project structure

Project structure

Add libraries and dependencies

Enable data binding and view binding libraries

In order to do this, you need to open the build.gradle file and enable those as this:

android {
    buildFeatures {
        viewBinding true
        dataBinding true
    }
}

Add dependencies

Add these dependencies in the build.gradle file under dependencies section.

implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.5.1'
implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.5.1'

Here you have successfully completed the first step. Let’s create our model.

Create data model

To store the data within the application run time, we are using a model. So let’s create a model called Counter as below.

Create View Model

Create a view model as below.

important

Remember that we cannot directly use _data.value.increment() method, because it does not update the value in MutableLiveData object. So we assign _data.value with _data.value.apply {this?.increament()} to awoid live data updating issues.

Creating the view

Let’s create a simple view with a TextView and a Button.

Important

You need to remember that you need to have tag inside the tag. Otherwise it does not work.
To bind a value, we use “@{viewModel.data}” format.
We use android:onClick=”@{() -> viewModel.increase()}” format to bind events.
Remember to use the same name in the tag.
Use android:text=”@{viewModel.data.toString()}” format. not android:text=”@={viewModel.data.toString()}”.

Associated kotlin file:

Important

Here, we are getting the view model from the ViewModelProvider, because there will be having a single instance of the view model until we destroy the view.
In line number 26, we initialise the binding variable from the DataBindingUtil class.
We have to set the binding.viewModel to our view model (Line: 29). So that we can use the view model in xml file.
One important thing most of the people forget to do is setting the lifecycleOwner (Line: 32). Without this, your data will update in the view model. But, your UI will not be updated.

Thank you for reading this article. If you find something valuable in this article please give it a clap and leave your thoughts. Don’t forget to share.

To be continued!

Start building your carrier as a web developer

Sadisha Nimsara — Tue, 18 Oct 2022 19:13:58 +0000

Hello guys, I am Sadisha Nimsara(nsadisha). This article is for beginners who interested in web development. Most of the people, even students in universities are familiar with web development. But most of them have no idea how they can start it as their carrier. So, in this article we are going to learn “What are the things you need to learn to become a expert in web development.”

Path ways

In this path, you can be either “Front-end”, “Back-end”, or a “Full-stack” Developer.

Front-end developer

Front-end developer is a person who develop websites and web applications. Simply, the development of the client-side(how a web page will look like) is developed by a front-end developer.

Three basic technologies

Most basic elements in a web page.

Popular CSS and JavaScript frameworks

These things will make the development process easier for you.

Handling APIs

REST — Representative State Transfer
GraphQL

API data formats

JSON — JavaScript Object Notation
XML — eXtensible Markup Language

Version controlling

You can start by learning the above mentioned technologies. And also do some projects your own. It will help you a lot to understand how these things work together, what error can be occurred, and many more.

Back-end developer

Back-end developer is responsible for how the website/applications will work. All business logics and database related things are handled by him.

Languages

Frameworks

Database management

MongoDB
SQL/relational databases (MySQL, Oracle, PostgreSQL)
Firebase — Complete platform for backend

Web servers

Other tools

Postman — used for testing API endpoints

Full-stack developer

Full-stack developer is a combination of both front-end and back-end developers. He is responsible for developing user interfaces, business logic, database integration.

** Mastering JavaScript will be a bigger advantage for a web developer regardless of his roll. **

If you wish to learn more about back-end development, follow the following topics:

Caching

CDN (Cloud Delivery Network)
Server-side caching
Client-side cashing

Web Security

Hashing Algorithms
MD5
SHA Family
Scrypt
Bcrypt
HTTPS
CORS
SSL/TLS

Testing

Unit testing
Integrated testing
E2E testing

Containerisation/Virtualisation

Docker
Kubernetes
RKT

Architectural patterns

Monolithic
Microservices
Serverless
Scaling (Horizontal & Vertical)
Load Balancers

Cloud platforms

AWS (Amazon Web Services)
GCP (Google Cloud Platform)
Microsoft Azure
Oracle Cloud
SISCO

Thank you for reading this article. If you find something valuable in this article please give it a clap and leave your thoughts. Don’t forget to share.

To be continued!

Build your own Operating System #2_implementing_C

Sadisha Nimsara — Wed, 21 Jul 2021 18:04:38 +0000

In the previous article, we guided you to setup the booting part of our operating system. In this article, we are going to implement C language to our project instead of Assembly language. Assembly is a very good programming for interacting with CPU and other hardware resources. But, C is much more human-friendly language when compared with Assembly language. So, we decided to use C as much as possible to make the development process easier and assembly language will be used only where it make sense.

So, let’s get started!

Setting up a stack

Since all non-trivial(not lightweight) C programs use a stack, and setting up a stack is not harder than to make the esp register point to the end of an area of free memory. So far, in this development process, the only things in memory are GRUB, BIOS, the OS kernel, and some memory mapped I/Os. This is not a good thing to do; because, we don’t know how much memory is available or if the esp pointed memory area is used by something else.

Reserving a piece of uninitialized memory in the bss section in the ELF file of the kernel will be a solution. And also, this will reduce the OS executable size.

KERNEL_STACK_SIZE equ 4096 ; size of stack in bytes

    section .bss
    align 4 ; align at 4 bytes
    kernel_stack: ; label points to beginning of memory
        resb KERNEL_STACK_SIZE ; reserve stack for the kernel

Add this section to loader.s file.

And then, we need to setup the stack pointer by pointing esp to the end of the kernel\_stack memory. In order to do that, you need to add the following statement inside the loader: block you your loader.s file.

mov esp, kernel_stack + KERNEL_STACK_SIZE ; point esp to the start of the
                                                ; stack (end of memory area)

After all, loader.s file will look like this:

Calling C code from the Assembly

Since we are using C language, we need to call the C code from the Assembly code. There are many different ways to do that. But in here, we will use cdecl calling convention. According to this convention, the arguments of the function should be pushed on the stack in a right-to-left order, that is, you push the rightmost argument first. And, the return value of the function is placed in the eax register.

For example, to call the following function in Assembly:

/* The C function */
    int sum_of_three(int arg1, int arg2, int arg3)
    {
        return arg1 + arg2 + arg3;
    }

You have to call it like this.

; The assembly code
external sum_of_three ; the function sum_of_three is defined elsewhere

    push dword 3 ; arg3
    push dword 2 ; arg2
    push dword 1 ; arg1
    call sum_of_three ; call the function, result will be in eax

In your project directory, create an empty file called kmain.c. You can do it with touch kmain.c command. You can keep this file empty for now.

Compiling the C code

The next step will be this. For normal compilations, we can use gcc fileName.c -o objectName. But, in this case, we are compiling them for an operating system. So, we have to use a lot of flags as below.

-m32 -nostdlib -nostdinc -fno-builtin -fno-stack-protector -nostartfiles -nodefaultlibs

And, we recommend you to turn on all warnings and treat warnings as errors by adding these flaags:

-Wall -Wextra -Werror

Build tools

This is the last step for this article. In this step, we are going to build the OS. Previously, we used a lot of commands to compile each and every file separately, build the ISO image, and run the OS in bochs emulator. But, we can do it in an easier way. In order to do that, you have to create a separate file to execute those commands. Execute touch Makefile to create the file.

Save this file in Makefile. Note that you have to do all the indentations with tabs, not with spaces.

After all of these steps, your file structure should look like this.

    .
    |-- bochsrc.txt
    |-- iso
    | |-- boot
    | |-- grub
    | |-- menu.lst
    | |-- stage2_eltorito
    |-- kmain.c
    |-- loader.s
    |-- Makefile

Now, you should be able to run the OS in the bochs emulator by executing the simple command make run. This will compile the kernel and boot it up. Then check the bochslog.txt to find RAX=00000000CAFEBABE or EAX=CAFEBABE to make sure that your OS has successfully booted.

You can download a completed code that I have created for booting my OS from: here

Hope you have successfully implemented C to OS and hope to catch you in the next article.

Thank you!

Build your own Operating System #1_setup_booting

Sadisha Nimsara — Mon, 12 Jul 2021 13:05:34 +0000

This is the first article of “Build your own OS” article series. In this article series, we hope to guide you how you can build your own operating system with linux kernel. Developing a custom operating system is not an easy task. But, you will be able to develop your own simple operating system at the end of this article series.

I will be using Ubuntu as the operating system for the development. Since we have to directly access the memory while developing, its better to try all these things in a virtual box environment for safety purposes. I will be using C and assembly languages in this article series.

So, let’s get started!

Setting up development environment

Once you have done installing Ubuntu in a virtual box, the next step is installing some necessary packages ( build-essential , nasm , genisoimage , bochs and bochs-sdl ). You can simply install them by executing this command in your terminal.

sudo apt-get install build-essential nasm genisoimage bochs bochs-sdl

build-essential

This package contains GNU debugger, g++/GNU compiler collection, and some tools and libraries which are required to compile a C program.

nasm

Since we are using assembly, we have to use nasm(Netwide Assembler) to compile assembly programs.

genisoimage

We need this package to generate an ISO image file for the file system.

bochs

This will be the emulator that we will be using to debug our operating system.

Booting

Booting is the process of starting a computer. After you press the power button, computer will run several programs before handover the control of the computer to the operating system.

Booting process diagram

BIOS

BIOS program(stands for Basic Input Output System) is usually stored on a read only memory chip on the motherboard of the PC. The original role of the BIOS program was to export some library functions for printing to the screen, reading keyboard input etc. After all, it will transfer the control of the computer to the bootloader.

Bootloader

This program’s task is to handover the control of the computer to the operating system. But, due to some restrictions, the bootloader is often split into two parts. The first part of the bootloader will transfer control to the second part, which finally transfers the control to the operating system.

We will be using an existing bootloader called “GNU GRand Unified Bootloader (GRUB)”. Because we don’t need to write a lot of low-level codes. GRUB will load our operating system to the correct memory location.

Download GRUB: https://github.com/littleosbook/littleosbook/raw/master/files/stage2_eltorito

Compiling the operating system

In here we use little bit of assembly code. This program will write a very specific number 0xCAFEBABE to the eax register. Save the following code in a file called loader.s

The file loader.s can be compiled into a 32 bits ELF [18] object file with the following command:

nasm -f elf32 loader.s

Linking the Kernel

Next, GRUB needs to load the Kernel into the memory. It should be loaded into a memory address larger than or equal to 0x00100000 (1 megabyte (MB)), because addresses lower than 1 MB are used by GRUB itself, BIOS and memory-mapped I/O. In order to do that, we will be using the following code.

Save the linker script into a file called link.ld. And then, the executable can now be linked with the following command:

ld -T link.ld -melf_i386 loader.o -o kernel.elf

The final executable file will be generated, called kernel.elf.

Then, copy the downloaded file (stage2_eltorito) in to the same project location as loader.s and link.ld.

Building an ISO image file

ISO image is the type that can be loaded by a virtual or physical machine. So, we will create the kernel ISO image with the genisoimage package. Before generating an ISO, we need to create a specific folder structure and copy the bootloader and the kernel into different locations. Which can be done by executing following commands.

mkdir -p iso/boot/grub # create the folder structure
cp stage2_eltorito iso/boot/grub/ # copy the bootloader
cp kernel.elf iso/boot/ # copy the kernel

Finally, a configuration file menu.lst for GRUB must be created. This file tells GRUB where the kernel is located and configures some options:

Place the file menu.lst in the folder iso/boot/grub/. Then, the contents of the iso folder should now look like the following figure:

iso
 |-- boot
       |-- grub
       |     |-- menu.lst
       |     |-- stage2_eltorito
       |-- kernel.elf

If your folder structure is correct, you can generate your ISO image with the following command.

genisoimage -R \
            -b boot/grub/stage2_eltorito \
            -no-emul-boot \
            -boot-load-size 4 \
            -A os \
            -input-charset utf8 \
            -quiet \
            -boot-info-table \
            -o os.iso \
            iso

Now you have successfully created the os.iso file.

Running your OS in Bochs

Now we can run the OS in the Bochs emulator using the os.iso ISO image. One last thing before that, Bochs needs a configuration file to start and an example of a simple configuration file is given below:

Save this file as bochsrc.txt in the root directory of your project(same location as loader.s). And run the following command to boot your os in Bochs emulator.

bochs -f bochsrc.txt -q

Extra: If you see any error in your terminal try changing display_library: sdl to display_library: sdl2 . And try!

If you see some text on the bochs emulator, containing “Booting os”, quit the emulator. If emulator has no text on the screen, type continue in the terminal and hit enter. It will boot the OS.

After quitting the Bochs, you can check the log generated by the Bochs. You can open it in a text editor or else execute the following command:

cat bochslog.txt

You should now see the contents of the registers of the CPU simulated by Bochs somewhere in the output. If you find RAX=00000000CAFEBABE or EAX=CAFEBABE (depending on if you are running Bochs with or without 64 bit support) in the output;

Congratulations!!! Your OS has successfully booted!

You can download a completed code that I have created for booting my OS from: https://github.com/nsadisha/lemonOS/tree/setup_booting_os

Hope you have successfully booted your OS and hope to catch you in the next article.

Thank you!

Get pinned GitHub repositories as JSON

Sadisha Nimsara — Tue, 22 Dec 2020 18:33:28 +0000

I saw a lot of people asking about how they can get pinned GitHub repositories as a JSON response. This can be done with GraphQL, but some of them are asking for a rest API solution. Fortunately, I found a solution for them.

Visit this site:

https://gh-pinned-repos-5l2i19um3.vercel.app/
Type your GitHub username
Click the ‘go’ button

There you have your JSON response. Or else, you can just replace your Username in the following URL.

https://gh-pinned-repos-5l2i19um3.vercel.app/?username=Username

This program was originally developed by @egoist.

For contributors: Source code

How to create a bootable flash drive with command prompt(cmd)

Sadisha Nimsara — Fri, 04 Dec 2020 05:12:46 +0000

In order to install windows to a computer that no DVD ROM, you need to prepare a bootable flash drive for that.

Formatting the flash drive

First of all, plug-in a flash drive with a minimum of 4GB of capacity. Now, go to windows explorer, right-click on your flash drive and format it in a regular way.

Create a partition in the command prompt

Next, you have to set up your flash drive to make it a bootable drive. To do that, you have to open your command prompt with Run as administrator. And then, type the following command in your cmd.

diskpart

This opens the diskpart.exe program. Now type,

list disk

And hit enter. This command shows information about all the drives that are connected at the time. Now you have to identify your flash drive with its capacity and remember its disk number. (eg: Disk 1)

Then, type the following command and hit enter.

select disk 1

This will show a message that “Disk 1 is now the selected disk.” Now you have to remove the default setting in your flash drive. Type,

clean

and hit enter. This will show the message “DiskPart succeeded in cleaning the disk.”

To create a bootable disk, you need to have a separate partition for that. For that, type

create partition primary

and hit enter. This will show “succeeded in creating the specified partition.” Now you need to select the partition. For that, type,

select partition 1

and hit the enter key. This shows “Partition 1 is now selected partition.” message. Now you have to make that partition active. Type,

active

This will show you “DiskPart marked the current partition as active.”

Formatting the partition

Now, you need to format the partition as suitable. In order to do that, Type,

format fs=fat32 quick

and enter. Now, flash drive will be formatted, then shows “100 percent completed” and “DiskPart success fully formatted the volume.”

Now you have to assign a dive letter to the flash drive. Type,

assign

and enter. This will show the message “DiskPart successfully assigned the drive letter or mount point.”

Now you are done with the command prompt and you can close it by typing exit and hit enter.
Now, you are almost done! :)

Copy the setup files

This is the last step of the process. You need to copy all the windows installation files to your flash drive.

Now you can install windows to a computer using this flash drive.

Github git cheat sheet

Sadisha Nimsara — Fri, 04 Dec 2020 04:39:07 +0000

GitHub Git Cheat Sheet

Git is an open source distributed version control system that facilitates GitHub activities on your laptop or
desktop. This cheat sheet will help you with commonly used Git command line instructions for quick reference.

Catalog

Install Git
How to use Git
Configure tooling
Create repositories
Make changes
Group changes
Refactor filenames
Suppress tracking
Save fragments
Review history
Redo commits
Synchronize changes

INSTALL GIT

For Windows users

Download Git for Windows Setup
Install Git through the setup. Usually all configurations can be left in default settings.

For macOS users

Download Git for Mac

For Linux users

Debian/Ubuntu

For the latest stable version for your release of Debian/Ubuntu

$ sudo apt-get update
$ sudo apt-get get install git

For Ubuntu, this PPA provides the latest stable upstream Git version

$ sudo add-apt-repository ppa:git-core/ppa
$ sudo apt update
$ sudo apt install git

Fedora

For releases up to Fedora 21

$ yum install git

For Fedora 22 and later

$ dnf install git

Arch Linux

$ pacman -S git

HOW TO USE GIT

Windows

Right click on any location and click git bash.

Linux and Mac

Open Terminal to use git.

CONFIGURE TOOLING

Configure user information for all local repositories

Set the name you want attached to your commit transactions

$ git config --global user.name "[name]"

Set the email address you want attached to your commit transactions

$ git config --global user.email "[email address]"

CREATE REPOSITORIES

Start a new repository or obtain one from an existing URL

Create a new local repository with the specified name

$ git init [project-name]

Download a project and its entire version history

$ git clone [url]

MAKE CHANGES

Review edits and craft a commit transaction

List all new or modified files to be commited

$ git status

Show file differences not yet staged

$ git diff

Snapshot a file in preparation for versioning

$ git add [file]

Snapshot all files of the current directory in preparation for versioning

$ git add .

Unstage the file (reset), but preserve its contents

$ git reset [file]

Record file snapshots permanently in version history

$ git commit -m "[descriptive message]"

GROUP CHANGES

Name a series of commits and combine completed efforts

List all local branches in the current repository

$ git branch

Create a new branch

$ git branch [branch-name]

Switch to the specified branch and updates the working directory

$ git checkout [branch-name]

Combine the specified branch's history into the current branch

$ git merge [branch-name]

Delete the specified branch

$ git branch -d [branch-name]

REFACTOR FILENAMES

Relocate and remove versioned files

Delete the file from the working directory and stages the deletion

$ git rm [file]

Remove the file from version control but preserves the file locally

$ git rm --cached [file]

Change the file name and prepares it for commit

$ git mv [file-original] [file-renamed]

SUPPRESS TRACKING

Exclude temporary files and paths

List all ignored files in this project

$ git ls-files --other --ignored --exclude-standard

A text file named .gitignore suppresses accidental versioning of files and paths matching the specified paterns

*.log
build/
temp-*

SAVE FRAGMENTS

Shelve and restore incomplete changes

Temporarily store all modified tracked files

$ git stash

List all stashed changesets

$ git stash list

Restore the most recently stashed files

$ git stash pop

Discard the most recently stashed changeset

$ git stash drop

REVIEW HISTORY

Browse and inspect the evolution of project files

List version history for the current branch

$ git log

List version history for a file, including renames

$ git log --follow [file]

Show content differences between two branches

$ git diff [first-branch]...[second-branch]

Output metadata and content changes of the specified commit

$ git show [commit]

REDO COMMITS

Erase mistakes and craf replacement history

Undo all commits afer [commit], preserving changes locally

$ git reset [commit]

Discard all history and changes back to the specified commit

$ git reset --hard [commit]

SYNCHRONIZE CHANGES

Register a repository bookmark and exchange version history

Download all history from the repository bookmark

$ git fetch [bookmark]

Combine bookmark’s branch into current local branch

$ git merge [bookmark]/[branch]

Upload all local branch commits to GitHub

$ git push [alias] [branch]

Download bookmark history and incorporates changes

$ git pull

Dealing with databases

Sadisha Nimsara — Fri, 25 Sep 2020 18:49:01 +0000

What is a database?

A graphical image for a database

Simply, A database is an organized collection of structured information, or data, typically stored electronically in a computer system.

Designing a database

There are many ways you can design your database depending on what kind of database you are going to design. In general, Let’s see how to design a SQL database. There are 3 main to design a SQL database.

Those are:

Decide what are the objects you want to include in your database.
Determine which of these objects should be tables and which should be columns within those tables.
Define tables based on how you need to organize the objects.

Step 1: Define objects

As the first step in designing a database, you have to select important aspects of the system to include in the model. Treat each aspect as an object. List all the objects as you can think of.

When you are done, decide how these objects related to each other. Each object considered as an entity. And each entity has its own attributes. Some of the objects are major entities and other objects are subsidiary to those major entities.

Step 2: Identify tables and columns

Major entities become database tables. Its attributes become table columns. Many business databases, for example, consider a CUSTOMER table that keeps track of customers’ names, addresses, and other permanent information. Each attribute of a customer — such as name, street, city, state, etc —becomes a column in the CUSTOMER table.

It is better to find a set of rules to identify which objects should be tables and which attributes belong to which table.

Step 3: Define tables

Now you have to define tables for each entity and columns for each attribute. You can use either a rapid application development (RAD) tool or SQL’s Data Definition Language (DDL) to create tables.

SQL

All the data, that are organized and stored in databases, should be able to access. That is where SQL comes.

Introduction

SQL which stands for (Structured Query Language), is used to access and modify data stored in databases. It was developed by Donald D. Chamberlin and Raymond F. Boyce at IBM in the early 1970s. It was originally called SEQUEL (Structured English Query Language), but later it became SQL.

What does SQL do?

Creating the database with SQL’s Data Definition Language (DDL).
The main thing SQL does is accessing the data stored in databases.
In a sense, SQL is the thing that stays in the middle and connects front-end with the back-end databases.

Commands

SQL contains many important commands to deal with data.

SELECT — extracts data from a table
DELETE — deletes data stored on a table
CREATE DATABASE — creates a new database
INSERT INTO — puts your data into a table
ALTER DATABASE — makes changes to a database
CREATE TABLE — creates a new table within a database
CREATE INDEX — creates a new search key
DROP — delete an existing table or a database

With these commands, you can easily modify and manipulate data as you want.

Examples:

CREATE DATABASE Students;

CREATE TABLE Student_Info(
stdID int,
name varchar(50),
address varchar(50),
city varchar(20),
phoneNumber int
);

INSERT INTO Student_Info VALUES(
001,
'student name1',
'address1',
'city1',
99345638906
);

INSERT INTO Student_Info VALUES(
002,
'student name2',
'address2',
'city2',
99343213459
);

SELECT name FROM Student_Info WHERE stdID=001;

SELECT * FROM Student_Info

Advantages

High speed
Portable
No coding skills needed
Easy to learn and understand
Multiple data views

Disadvantages

Difficult interface
Some versions are costly
Complete control is not given to the database

Why SQL is Very Popular

Businesses love SQL because it is a quick and efficient way of retrieving, viewing, and editing large volumes of data. StackOverflow report that SQL is the second most used programming language (JavaScript is first) and regularly used by 58% of full-stack developers, 53% of back-end developers, and 25% of front-end developers.

Physical databases

Physical databases are both the actual device housing the information files and the search paths used to access information between sources. They are technically smaller units of storage. A field is the smallest unit of storage housing only a single file.

As a summary, a physical database can be called as a refinement of the logical database design.

According to Microsoft, the term “database” refers only to the logical database controlling information files for the entire system.