DEV Community: Ridwan Abiola

Software Design Principle: Inversion of Control(IOC) and Dependency Injection

Ridwan Abiola — Fri, 26 Apr 2024 09:51:29 +0000

Software engineering is an established discipline within the broader field of Computer Science. It is a discipline that has made great strides and impressive breakthroughs. Strides relating to powering spacecraft, advances in computer hardware, creating billion-dollar products and platforms, and more recently breakthroughs in AI.

It has also granted individuals skilled in the software-making craft a means to taste freedom from remote work, make a global impact, experience great career opportunities, and more.

Coming into software, some things we hear a lot are the sayings: "Do not reinvent the wheel" and "Standing on the shoulders of giants". These sayings aren't mere statements, they are enduring principles that have stood the test of time.

Software engineering has numerous principles that help make your code maintainable and easy to test. Some popular ones include Separation of Concerns, KISS, SOLID, and Design Patterns. There are also less popular ones and controversial ones as well. Some are now being regarded as bad practices. Though there are a lot, the rest of this article will zoom in on the Inversion of Control, one of the popular ones.

Inversion of Control

Inversion of Control is a software engineering principle that discourages a Developer from creating the object and dependencies his program needs to run directly. Rather he outsources it to a framework or an external entity. Inversion of control (IoC) is where control is inverted, rather than the programmer controls the flow of the program, the framework takes control instead.

In procedural programming, a program's custom code calls reusable libraries to take care of generic tasks, but with inversion of control, it is a framework that calls the custom code. The principle is popular with Java's Spring framework and Javascript's Angular.

Dependency Injection

Dependency Injection is related to the Inversion of Control in the sense that it is the pattern through which Inversion of Control is achieved. In DI, instead of a Class creating its dependencies, the dependencies are provided to the class from the outside. This helps to decouple classes and make them more testable, maintainable, and flexible.

There are three common types of dependency injection:

1.Constructor Injection: Dependencies are provided to a class through its constructor. It is the most common form of DI and ensures a Class has all its dependencies when created.

public class MyClass {
    private final MyDependency dependency;

    public MyClass(MyDependency dependency) {
        this.dependency = dependency;
    }

    // Class methods using the dependency
}

2.Setter Injection: Dependencies are provided to a class through setter methods. This allows for more flexibility, as dependencies can be changed after the class is created.

public class MyClass {
    private MyDependency dependency;

    public void setDependency(MyDependency dependency) {
        this.dependency = dependency;
    }

    // Class methods using the dependency
}

3.Method Injection: Dependencies are provided to individual methods when called. This is less common than constructor or setter injection and is often used in specific cases.

public class MyClass {
    public void doSomething(MyDependency dependency) {
        // Method logic using the dependency
    }
}

This is also the case in Javascript's Angular, DI is a core concept used to provide services, components, and other objects to classes that need them. Angular's DI system is built into the framework and is used extensively throughout Angular applications. Below is a simple example to demonstrate how dependency injection works in Angular:

First, we create a service that we'd like to inject into a component:

// my.service.ts
import { Injectable } from '@angular/core';

@Injectable({
  providedIn: 'root',
})
export class MyService {
  getMessage(): string {
    return 'Hello from MyService!';
  }
}

Next, we create a component that will consume the service:

// my.component.ts
import { Component } from '@angular/core';
import { MyService } from './my.service';

@Component({
  selector: 'app-my',
  template: `
    <h1>{{ message }}</h1>
  `,
})
export class MyComponent {
  message: string;

  constructor(private myService: MyService) {
    this.message = this.myService.getMessage();
  }
}

In the above code, the MyComponent class has a constructor parameter of type MyService. Angular's DI system will automatically inject an instance of MyService into the MyComponent class when created.

Finally, we add MyService and MyComponent to the list of providers in the Angular module:

// app.module.ts
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { MyComponent } from './my.component';
import { MyService } from './my.service';

@NgModule({
  declarations: [MyComponent],
  imports: [BrowserModule],
  providers: [MyService],
  bootstrap: [MyComponent],
})
export class AppModule {}

In this example, MyService is provided at the root level, meaning a single instance of MyService is shared across the entire application. This allows flexibility in making future changes as the components are loosely coupled.

Some Advantages

There is loose coupling between components
You can easily change dependencies without compromising on quality.
You can leverage code usability and achieve System stability.
Minimal code to maintain.
You can easily replace components without affecting others.

Conclusion

In conclusion, we discussed SE principles and why they are necessary. We focused on IoC and DI, a design pattern through which IoC is achieved. We also mentioned the different types of DI using code samples where appropriate. We mentioned some advantages of IoC and DI. Finally, DI is a powerful design pattern that makes managing complex dependencies in large applications easier.

Thanks for reading, you can follow me on LinkedIn

Java's own EJB and Spring Framework

Ridwan Abiola — Sat, 13 Apr 2024 22:38:29 +0000

In the world of Java, there are a lot of possibilities. Those possibilities range from game development to cloud-based applications, server-side apps, Internet of Things, Machine learning, and more.

Especially in the world of server-side enterprise application development, Java provides a lot of options. Enterprise Java Beans was an early technology designed to make server-side development easier in Java. It could handle transaction processing, persistence, security, and more. However, EJBs were somehow cumbersome due to the amount of configuration required.

Around 2002 Spring was created as an alternative to EJBs and its heavy-weight containers, it also supports auto-configuration. It is a highly flexible framework used mainly for building Java web applications. In addition, Spring makes programming Java quicker, easier, and safer for everybody. Its focus on speed, simplicity, and productivity has made it the world's most popular Java framework.

The issues on ground

EJB had several issues that made it challenging to work with. Some of the key issues include:

Complexity: EJBs were often criticized for their complexity, especially in earlier versions. Developing and deploying EJBs required dealing with a lot of configuration and boilerplate code.
Performance: EJBs were known to have performance issues, especially due to their remote method invocation (RMI) mechanism. This was due to the overhead of serialization/deserialization and network communication.
Transaction Management: EJB's container-managed transactions (CMT) could be restrictive and cumbersome to configure, leading to performance and maintenance issues.
Scalability: EJBs were seen as not very scalable, especially concerning their heavy use of server-side resources.
Complex Deployment: Deploying EJBs required deploying them to an application server, which could be complex and time-consuming compared to simpler deployment mechanisms.

Spring resolves these issues by making things simpler, quicker, and better. Spring is also open source with a large community backing making it easier to ask for help.

How popular is the Spring framework

In 2024, it is to be noted that Spring is a top choice still among software developers. And one thing that has kept its appeal is the addition of the latest useful feature that improves the developer experience. According to Jet Brains' 2033 Developer Ecosystem survey, Spring Boot leads followed by Spring MVC. This is also the case with Continuum's Java Ecosystem 2023 Survey Results

Conclusion

Finally, Spring's simplicity, flexibility, testing support, lack of vendor lock-in, integration capabilities, and community support make it a preferred choice for many developers over EJB.

Using LESS in your Angular 9 Project

Ridwan Abiola — Wed, 17 Jun 2020 22:37:32 +0000



ng new my-app

Running the above angular cli command will give you a shiny brand new workspace and app. Chances are you may mistakenly or hastily select the defaults when prompted for information about features to include in the initial app.

It is all cool if you are a master CSS bender and manipulator but let's face it, down the road when your projects get larger you tend to get exhausted writing vanilla CSS (if that's a thing).

Re-introducing: CSS Preprocessors

CSS preprocessor takes the work out of writing your styles (well almost). It gives you features like variables, nesting, escaping, imports, mixins and so much more. Less is an example of this. It gives you a cleaner and efficient way of styling components.

Now: Putting LESS in Angular



ng config schematics.@schematics/angular:component.styleext less

Running the above instructs Angular to use less as the default stylesheet format.



"schematics": {
    "@schematics/angular:component": {
      "style": "less"
    }
  }

You should see the above changes to angular.json file.

Next: Changing all occurrences

VSCode has a neat feature to change all occurrences at once.

Here we go again



ERROR in ./src/app/app.component.ts
Module not found: Error: Can't resolve './app.component.less' in '/Users/tbo/my-app/src/app'
ERROR in ./src/app/dashboard/dashboard.component.ts
Module not found: Error: Can't resolve './dashboard.component.less' in '/Users/tbo/my-app/src/app/dashboard'
ERROR in ./src/app/home/home.component.ts
Module not found: Error: Can't resolve './home.component.less' in '/Users/tbo/my-app/src/app/home'
ERROR in ./src/app/landing/landing.component.ts
Module not found: Error: Can't resolve './landing.component.less' in '/Users/tbo/my-app/src/app/landing'
ERROR in ./src/app/profile/profile.component.ts
Module not found: Error: Can't resolve './profile.component.less' in '/Users/tbo/my-app/src/app/profile'

Angular complains of not finding the module which makes sense since we changed all references but the file name remain unchanged.

This stack overflow answer shows you how to rename bunch of files extensions. Just so we are clear make sure you in the src folder when running the command. You can thank me later.

Finally

Since all that is out of the way. Now you can do:

This:



@width: 10px;
@height: @width + 10px;

#header {
  width: @width;
  height: @height;
}

This:



.bordered {
  border-top: dotted 1px black;
  border-bottom: solid 2px black;
}



#menu a {
  color: #111;
  .bordered();
}

.post a {
  color: red;
  .bordered();
}

And that:



#header {
  color: black;
  .navigation {
    font-size: 12px;
  }
  .logo {
    width: 300px;
  }
}

Ha! Exciting times to be a developer.

Keeping up with Ruby

Ridwan Abiola — Sun, 10 Nov 2019 00:33:16 +0000

Ha Ruby! some real gem there, believe me. My first impressions checking through the docs, when first starting out was: "This looks like C (now I know better, it doesn't)". Little do I know am going to be writing a post about it some few odd months after.

So what made me hooked enough to want to explore the language more? Well am not yet sure but i will tell you something along the lines of:

It's syntax
Visual Appearance (makes a case for clear code out of the box)
Flexibility
Modules
Exception Handling

Best parts for me so far

Hashes

This will be equivalent of "Objects Literals" in JavaScript. Key/value pairs, two way binding, linked(you get the picture), they differ from Arrays in the sense that whereas Arrays are like lists, they are like dictionaries.

Create 'em:

  example_hash = {
    "one": "okan",
    "two": "eeji",
    "three": "eeta"
  }

Use 'em

example_hash["one"] # => okan

Love 'em

Modules

Modules is a way of classifying methods and constants, watch the word "classify", even though similar (well kind of) to classes yet modules cannot be instantiated (objects cannot be created out of it) and the keyword "new" does not work on it.

Create 'em

module Alifabeti
  CONST = "A"
end

Use 'em

module Alifabeti
  def oro?
    true
  end
end

class Ede
  include Alifabeti
end

ede_yooba = Ede.new
puts ede_yooba.oro? # => true

Love 'em

Symbols

Symbols represents code in your code (am confused as well) rather than string. It is a unique identifier for piece of data you need in your code. Even though it is like a string, it is not a string (i think an example will do a better job than am trying to do right now).

Create 'em

apamo = :faweli

Use 'em

  apamo.object_id # => 1928988
  apamo.object_id # => 1928988
  apamo.object_id # => 1928988

Did you notice it returned the same "object_id" for the that same symbol, Ruby only uses one object to represent all those symbols. And perhaps that's one of the obvious difference between symbols and string, for each time you use the same string in your code, it will create a new object each time.