DEV Community: Olawale Afuye

Advice to Junior–Mid Level Engineers: Reality of the Job Market Today

Olawale Afuye — Tue, 06 Jan 2026 20:07:45 +0000

1. The Market Has Changed — Adjust Your Expectations

The job market you are entering is not the same one that existed 5–7 years ago.

Building a basic application is no longer impressive.
“I built X” matters less than:
- How it works
- Why it works
- How it fails
Companies are hiring fewer people and expecting broader impact from each hire.

This is not unfair. It is a rational response to:

Cost pressure
More mature tooling
Faster delivery expectations

2. The Definition of “Junior” Has Shifted

What used to be considered mid-level is now expected from many junior engineers.

Common expectations include:

Comfort working across frontend and backend
Ability to read and understand unfamiliar codebases
Debugging production issues, not just local bugs
Basic understanding of deployment and environments
Shipping features end-to-end with minimal supervision

If your experience is limited to tutorials or copying patterns without understanding them, you will struggle.

3. AI Tools Did Not Remove Jobs — They Removed Shallow Roles

The job market did not disappear.

Low-leverage roles did.

Employers now avoid hiring engineers who:

Can only write code when guided step-by-step
Cannot explain design decisions or tradeoffs
Cannot debug issues introduced by generated code
Break down when requirements are unclear or incomplete

Engineers who understand systems, failures, and constraints remain in demand.

4. Projects Still Matter — But Only If They Show Depth

Having many projects is not the goal.

Having one or two serious projects is.

A strong project demonstrates:

Clear design decisions and tradeoffs
Proper handling of edge cases
Thoughtful error handling and observability
Performance and scalability considerations
What broke and how you fixed it

If your project never failed, it is probably not deep enough.

5. Full-Stack Expectations Are Now the Norm

Many companies cannot afford large, specialized teams.

As a result, they prefer engineers who can:

Work across frontend, backend, and basic infrastructure
Understand APIs, data models, and UI constraints
Communicate effectively with product and non-technical stakeholders

You do not need to be an expert in everything.

You do need to avoid being blocked by any single layer.

6. Speed Alone Is Not the Advantage

Fast output is easy today.

Correct output is not.

What employers value:

Finishing work without creating long-term problems
Identifying risks early
Knowing when not to ship
Writing code others can understand and maintain

Speed without judgment is a liability.

7. Employability Now Depends on Ownership

To remain employable, you must:

Take responsibility beyond assigned tickets
Understand the business impact of your work
Support what you build after release
Learn continuously without waiting for permission

The most secure engineers are not the smartest.

They are the most reliable.

Final Reality Check

This market rewards:

Engineers who think in systems
Engineers who adapt quickly
Engineers who finish work properly

It penalizes:

Surface-level knowledge
Overreliance on tools
Inability to operate without hand-holding

This is not a bad time to be an engineer.

It is a bad time to be an unprepared one.

Thriving in the Age of AI: A Senior Software Engineer's Guide to Future-Proofing Your Career

Olawale Afuye — Fri, 13 Sep 2024 12:20:37 +0000

As AI and automation grow senior software engineers face changing job responsibilities. Here are some tactics to help you advance in your career and ensure success over time:

1. Welcome AI and Machine Learning (ML) Tools

Study AI Frameworks and Tools: Get to know common AI/ML frameworks such as TensorFlow, PyTorch, or scikit-learn. Knowing how these tools work and how to integrate them into current systems can boost your value.

Apply AI to Improve Development: Use AI tools to complete code, find bugs, and run tests. Tools like GitHub Copilot, V0 by vercel, chatgpt, claude ai or DeepCode can help you write cleaner more effective code in less time.

2. Emphasize System Design and Architecture

Enhance Your System Design Skills: AI tools can't yet create complex systems from the ground up. Boost your know-how in crafting scalable, tough, and productive software structures.

Get Good at Cloud and Distributed Systems: As more setups shift to the cloud, being an expert in cloud setup, microservices, and spread-out systems will keep being sought after.

3. Grow Cross-Functional Abilities

Turn into a Full-Stack Developer: If you haven't yet, broaden your skills to cover both frontend and backend development. This makes you more flexible and able to handle different project needs.

Get to know DevOps and CI/CD: Learn about DevOps practices, including Continuous Integration/Continuous Deployment (CI/CD) pipelines, containerization (Docker, Kubernetes), and Infrastructure as Code (IaC).

4. Focus on Areas Where AI Lacks

Put Human-Centered Skills First: Skills such as empathy, creativity, and leadership are hard to copy for AI. Look into jobs that involve managing stakeholders leading teams, and talking with clients.

Build Up People Skills: Good communication, bargaining, and big-picture thinking are key areas where we'll always need human know-how.

5. Become an Expert in Special Tech Fields

Get Really Good at New Tech: Zero in on special areas like quantum computing, blockchain, edge computing, or cybersecurity where AI is still growing and we need human experts.

Know Your Field Inside Out: Become a pro in one industry (like healthcare or finance) where your tech skills plus industry knowledge can offer something unique.

6. Contribute to Open Source and Communities

Get Involved with Developer Groups: Take part in open-source projects, help out in communities, and be active on developer forums. This helps you build connections and boost your standing in the tech world.

Keep Up with Tech Changes: Often check tech news, go to conferences, watch webinars, and join workshops to learn about the newest industry shifts and technologies.

7. Pursue Leadership Roles

Transition to Tech Leadership: Think about roles such as Engineering Manager, Tech Lead, or CTO. These positions need you to make strategic decisions and manage people.

Mentor and Coach: Pass on your knowledge and experience. You can do this by guiding juniors or running workshops inside your company. This will cement your place as a must-have team member.

8. Use AI to Automate Everyday Tasks

Automate Repeated Work: Put AI tools to work on regular tasks like keeping an eye on systems, running tests, and looking at data. This gives you time to tackle work that matters.

Create Tools and In-house Utilities: Make tools that automate tasks and utilities to boost how much your team or company gets done. This shows how valuable you are.

9. Keep an Open Mind and Roll with the Changes

Never Stop Learning and Adjusting: Make learning a lifelong habit and be ready to switch to new tech or jobs as the field keeps changing.

Try Out AI Projects: Begin with small AI tasks to get a better grasp of what it can and can't do, and to discover how AI might boost your current abilities.

10. Become the AI Champion in Your Workplace

Lead AI Integration Efforts: Become the go-to person in your company who gets both software engineering and AI connecting data science and software development teams.

Identify AI Opportunities: spot areas in your organization where AI can boost value, through making processes better, predicting trends, or providing automated help.

Final Thoughts

The main idea is to see AI as a tool that boosts your skills rather than a danger. By mixing deep technical know-how with big-picture thinking, industry knowledge, and people skills, you can make yourself a must-have asset to your company.

Key Concepts Every Backend Engineer Should Master.

Olawale Afuye — Mon, 31 Jul 2023 12:42:26 +0000

I compliled a long list of essential and practical considerations when developing the backend of an application. Let's summarize and expand on each point.

Paginate long list of data: When dealing with large datasets, it's essential to implement pagination to split the data into smaller chunks. This allows for more efficient data retrieval and reduces the load on the server and client.

Validate data coming in: Data validation is crucial to ensure that the incoming data is in the correct format and meets the necessary constraints. This helps prevent errors and security vulnerabilities caused by malformed or malicious data.

Use ORM over raw query where possible: Object-Relational Mapping (ORM) tools provide a more abstract and intuitive way to interact with the database, making it easier to write and maintain database queries. ORM helps avoid potential SQL injection vulnerabilities and enhances code readability.

Always return a clear message and status code to the frontend: When responding to client requests, the backend should provide clear and informative messages along with appropriate HTTP status codes. This helps frontend developers and users understand the outcome of their requests.

Remove unnecessary data from response payload: Minimizing the amount of data sent in the response can improve the application's performance and reduce network overhead. Only include the essential data needed by the frontend.

Keep things simple at first, don't over-engineer things: Start with a simple and straightforward design for the backend. Avoid adding unnecessary complexity that might hinder development and maintenance.

Don't optimize too early: While performance is essential, premature optimization can lead to overcomplicated code. Focus on building a functional and secure system first, and then optimize performance based on real-world usage and profiling data.

Think security first: Security should be a top priority in any application. Implement best practices like hashing passwords, input validation, and avoiding SQL or NoSQL injections to protect the system from potential attacks.

Avoid storing secrets in JWT: JSON Web Tokens (JWT) are commonly used for authentication, but sensitive data like passwords or cryptographic keys should not be stored in them. Instead, use JWT to hold lightweight and non-sensitive information.

Cache frequently accessed data: Caching can significantly improve the application's performance by storing frequently accessed data in memory. This reduces the need to fetch the same data repeatedly from the database.

Understand the problem and the domain: To build an effective backend, it's essential to have a good understanding of the problem domain. Properly model the data and design the system to meet the specific requirements of the application.

Authentication and authorization: The backend should handle user authentication to verify the identity of clients and then authorize access to specific resources based on user roles and permissions.

Database communication: The backend is responsible for interacting with the database, including reading, writing, updating, and deleting data. It should execute queries efficiently and handle database errors.

Error handling: The backend should handle errors gracefully and provide meaningful error messages to clients to aid in debugging and troubleshooting.

Logging and monitoring: The backend should log important events and errors to facilitate debugging and provide insights into the system's health and performance.

Request/response compression: Implementing compression techniques like Gzip or Brotli can reduce the size of data transferred between the backend and the client, resulting in faster communication.

Cross-Origin Resource Sharing (CORS): If the backend provides APIs that are consumed by different domains, it should properly handle CORS to control access from different origins and prevent unauthorized cross-origin requests.

Integration with external services: Many applications rely on external services like payment gateways, email services, or third-party APIs. The backend should be able to integrate with these services securely.

Unit testing and validation: To ensure the reliability and correctness of the backend code, it should be thoroughly tested with unit tests and validated against various use cases.

Share your thought in case I miss any. I am willing to learn.

Inversion of Control Made Simple: Elevate Your Understanding

Olawale Afuye — Sat, 29 Jul 2023 22:40:52 +0000

Inversion of control is a big and complicated concept that even some Senior developers struggle to fully understand. But I'll do my best to explain it in the best possible way for you to understand, teach and see its application.

When all have a home of our own. We need water and power. We have two options we create power ourselves and make a borehole or we outsource to another body only responsibility is that and does it well.

In the case of power we rely on Power Holding company of Nigeria and for water we rely on Nigeria water cooperation to provide that for us.

In the example, the control of providing power and water is moved to third-party organizations, which are responsible for generating power and providing water. This allows the homeowners to focus on their own needs without worrying about the technical details of how power or water is generated or distributed

That's kind of inversion of control. You're the one who wants something, but you're not the one doing all the work to get it. You're relying on someone or an organization else to help you out.

In software development, inversion of control (IoC) is a design pattern that allows different parts of a program to work together in a more flexible and maintainable way. It's a way of designing software so that instead of one part of the program being responsible for everything, different parts can work together in a more decentralized way.

IoC works by inverting the usual control flow between different parts of a program. In a traditional program, each part of the program is responsible for calling other parts of the program when it needs them. This can lead to tight coupling between different parts of the program, which can make it hard to change or replace parts of the program without affecting other parts.

With IoC, the control flow is inverted so that the parts of the program that are responsible for providing services or resources (known as "providers") are called by the parts of the program that need those services or resources (known as "consumers"). This means that the providers don't need to know about the consumers, which makes the program more modular and easier to change or replace.

In computer programming, inversion of control is a way of designing programs so that different parts of the program can work together without any one part having to do everything by itself. Instead of one part of the program doing everything, it asks other parts of the program to help out.

So just like how you rely on mommy or daddy to help you get what you want sometimes, different parts of a program rely on each other to get things done. And that's inversion of control!

There are many different ways to implement IoC in software development, such as using dependency injection, service locators, or the observer pattern. The specific implementation depends on the programming language and framework being used.

Overall, inversion of control is a powerful design pattern that can help make software development more flexible, maintainable, and modular. By inverting the control flow between different parts of a program, IoC can help reduce tight coupling and make it easier to change or replace different parts of the program as needed.

Observer pattern in the context of a Game App

Olawale Afuye — Tue, 13 Jun 2023 21:55:04 +0000

The Observer pattern is a design pattern that allows objects to be notified of changes to the state of another object, called the "subject." In the context of a game app, this could be used to notify different game components (such as scoreboards, health bars, etc.) when the game's state changes (such as when the player collects a power-up or takes damage).

Here's an example TypeScript code snippet that illustrates the Observer pattern in a game app:

interface Subject {
  registerObserver(o: Observer): void;
  removeObserver(o: Observer): void;
  notifyObservers(): void;
}

interface Observer {
  update(score: number, health: number): void;
}

class Game implements Subject {
  private score: number = 0;
  private health: number = 100;
  private observers: Observer[] = [];

  public registerObserver(o: Observer): void {
    this.observers.push(o);
  }

  public removeObserver(o: Observer): void {
    const index = this.observers.indexOf(o);
    if (index !== -1) {
      this.observers.splice(index, 1);
    }
  }

  public notifyObservers(): void {
    for (const observer of this.observers) {
      observer.update(this.score, this.health);
    }
  }

  public collectPowerUp(): void {
    this.score += 10;
    this.notifyObservers();
  }

  public takeDamage(): void {
    this.health -= 10;
    this.notifyObservers();
  }
}

class Scoreboard implements Observer {
  private score: number = 0;

  public update(score: number, health: number): void {
    this.score = score;
    this.render();
  }

  public render(): void {
    console.log(`Score: ${this.score}`);
  }
}

class HealthBar implements Observer {
  private health: number = 100;

  public update(score: number, health: number): void {
    this.health = health;
    this.render();
  }

  public render(): void {
    console.log(`Health: ${this.health}`);
  }
}

// Usage
const game = new Game();
const scoreboard = new Scoreboard();
const healthBar = new HealthBar();

game.registerObserver(scoreboard);
game.registerObserver(healthBar);

game.collectPowerUp(); // Logs "Score: 10"
game.takeDamage(); // Logs "Health: 90"

game.removeObserver(healthBar);
game.collectPowerUp(); // Logs "Score: 20" (only the Scoreboard is notified)

In this example, the Game class is the subject, which maintains the state of the game (score and health) and notifies its observers when the state changes. The Scoreboard and HealthBar classes are observers that listen for changes to the game state and update their respective displays accordingly.

When the collectPowerUp method is called on the Game instance, it increases the score and notifies all observers by calling notifyObservers. Similarly, when the takeDamage method is called, it decreases the health and notifies all observers.

The Scoreboard and HealthBar instances both implement the Observer interface, which requires them to have an update method that takes in the current score and health values. When they receive an update from the Game instance, they update their own internal state and call render to update their display.

Finally, we can see that we can remove an observer by calling removeObserver on the Game instance, and the removed observer will no longer be notified of updates.

Dependency Injection Pattern ( For beginners)

Olawale Afuye — Sun, 28 May 2023 00:17:51 +0000

Dependency injection is a design pattern used in software development to manage dependencies between components of an application. In a nutshell, it's a way to organize code so that the dependencies between different parts of the system are clearly defined and managed. The basic idea behind dependency injection is to pass dependencies into a component, rather than having the component create them itself.

There are several libraries and frameworks in JavaScript that use dependency injection (DI) to manage object creation and dependencies. Here are a few examples:

Angular: Angular is a popular framework for building web applications in TypeScript. It uses a hierarchical injector system to manage object creation and dependency injection. Angular provides a built-in @Injectable decorator that can be used to annotate classes as injectable services.
Awilix: Awilix is a lightweight dependency injection container for Node.js applications. It provides a fluent API for declaring dependencies and supports both constructor injection and property injection. Awilix also supports middleware-style dependency injection, which can be useful for managing complex application workflows.
NestJS: NestJS is a progressive Node.js framework for building scalable and maintainable web applications. It uses a modular architecture based on Angular's DI system to manage object creation and dependency injection. NestJS provides a built-in @Injectable decorator for declaring injectable services and supports a variety of injection patterns.

Using Dependency Injection in an authentication system

Let's take an authentication system as an example. In a typical authentication system, you might have a number of different components that need to interact with each other, such as a user model, a password hasher, and a session manager. Rather than having each component create its own dependencies, we can use dependency injection to pass them in from outside.

Here's an example implementation of an authentication system in JavaScript using dependency injection:

class User {
  constructor(id, name, passwordHash) {
    this.id = id;
    this.name = name;
    this.passwordHash = passwordHash;
  }
}

class PasswordHasher {
  hash(password) {
    // Hash the password using some algorithm
    return password + "hashed";
  }
}

class SessionManager {
  startSession(user) {
    // Create a new session for the user
    return "session_token";
  }

  endSession(sessionToken) {
    // End the user's session
  }
}

class Authenticator {
  constructor(userModel, passwordHasher, sessionManager) {
    this.userModel = userModel;
    this.passwordHasher = passwordHasher;
    this.sessionManager = sessionManager;
  }

  authenticate(username, password) {
    const user = this.userModel.getUserByName(username);
    if (!user) {
      throw new Error("User not found");
    }

    const hashedPassword = this.passwordHasher.hash(password);
    if (user.passwordHash !== hashedPassword) {
      throw new Error("Invalid password");
    }

    const sessionToken = this.sessionManager.startSession(user);
    return sessionToken;
  }

  endSession(sessionToken) {
    this.sessionManager.endSession(sessionToken);
  }
}

const userModel = {
  getUserByName(username) {
    // Look up the user in the database
    return new User(1, "Alice", "password_hash");
  }
};

const passwordHasher = new PasswordHasher();
const sessionManager = new SessionManager();
const authenticator = new Authenticator(userModel, passwordHasher, sessionManager);

const sessionToken = authenticator.authenticate("Alice", "password");
console.log(sessionToken);
authenticator.endSession(sessionToken);

In the above code snippet, we have a number of different components: User, PasswordHasher, SessionManager, and Authenticator. Rather than having each component create its own dependencies, we pass them in when the component is created. For example, when we create the Authenticator, we pass in the userModel, passwordHasher, and sessionManager as arguments to the constructor.

Dependency Injection is a powerful design pattern that can bring a number of benefits to your codebase. Here are some of the main advantages and disadvantages of using dependency injection:

Merits:

Loose Coupling: Dependency injection helps to reduce the coupling between components by allowing them to depend on abstractions rather than concrete implementations. This means that changes to one component won't necessarily require changes to others, which can help to make your code more flexible and easier to maintain.

Easier Testing: By using dependency injection, you can more easily write unit tests for your code. Since dependencies are passed in as arguments, it's easy to create mock objects for testing purposes, which can help to isolate your code and make it more testable.

Flexibility: Dependency injection allows you to easily swap out one implementation for another. This means that you can change the behavior of your code without having to modify the code itself. This can be especially useful if you need to support multiple environments or configurations.

Reusability: By separating concerns and dependencies, it's easier to reuse code in other parts of your application or even in other projects.

Demerits:

Complexity: Implementing dependency injection can add complexity to your code. There are a number of different ways to implement the pattern, and choosing the right one for your situation can be difficult. Additionally, it can be difficult to manage the lifecycle of dependencies, especially when dealing with complex object graphs.

Performance: Depending on how you implement dependency injection, it can have a negative impact on performance. In particular, using a lot of small dependencies can increase the overhead of object creation and initialization, which can slow down your application.

Overuse: It's possible to overuse dependency injection, which can lead to code that's difficult to understand and maintain. In particular, injecting too many dependencies into a component can make it hard to reason about its behavior and make it difficult to test. It's important to strike a balance between flexibility and simplicit

Here are some resources to learn more about Dependency Injection:

Dependency Injection Principles, Practices, and Patterns by Mark Seemann - This book provides a comprehensive introduction to Dependency Injection, including best practices and design patterns. It covers a variety of popular DI frameworks and libraries, including Unity, Autofac, and Castle Windsor.

The Clean Code Talks Dependency Injection by Misko Hevery - This video provides an in-depth look at Dependency Injection, including why it's important and how to use it effectively. It's a great resource for those who want to dive deeper into the theory behind DI.

Inversion of Control Containers and the Dependency Injection pattern by Martin Fowler - This article by one of the pioneers of Dependency Injection provides a detailed look at the benefits of using an Inversion of Control (IoC) container and how to use them effectively.

These resources should provide a good starting point for learning more about Dependency Injection and how to use it effectively in your code.

SOLID PRINCIPLE in a software devepment

Olawale Afuye — Wed, 03 May 2023 00:06:51 +0000

SOLID principles are a set of five design principles that help developers write software that is easy to maintain, extend, and modify. These principles, when applied to a software development project, can help produce code that is less prone to bugs, easier to test, and easier to understand.
The principles were introduced by Robert C. Martin, also known as Uncle Bob, and they provide a framework for creating software that is flexible, modular, and easy to maintain.

SOLID Principles

The SOLID principles are an acronym for five different principles:

Single Responsibility Principle (SRP)
Open/Closed Principle (OCP)
Liskov Substitution Principle (LSP)
Interface Segregation Principle (ISP)
Dependency Inversion Principle (DIP)

In this article, we will look at the SOLID principles in the context of a learning management system (LMS) and provide code samples in JavaScript to illustrate each principle.

Single Responsibility Principle (SRP)

This principle states that a class should have only one reason to change. In other words, a class should have only one responsibility or job. If a class has multiple responsibilities, any changes to one responsibility may affect other responsibilities.
In the context of an LMS, let's consider a class called "Course." This class should be responsible only for handling information about a course, such as its name, description, and course material. It should not be responsible for handling user authentication or managing the database.


class Course {
  constructor(name, description, courseMaterial) {
    this.name = name;
    this.description = description;
    this.courseMaterial = courseMaterial;
  }

  getName() {
    return this.name;
  }

  getDescription() {
    return this.description;
  }

  getCourseMaterial() {
    return this.courseMaterial;
  }
}

Open-Closed Principle (OCP)

This principle states that a class should be open for extension but closed for modification. In other words, you should be able to add new functionality to a class without changing its existing code.
In the context of an LMS, let's consider a class called "CourseRepository." This class should be responsible for storing and retrieving course data from the database. However, we may want to use a different type of database or storage system in the future. To ensure that we can add new functionality without modifying the existing code, we can create an interface for the repository.

class CourseRepository {
  constructor() {
    this.courses = [];
  }

  addCourse(course) {
    this.courses.push(course);
  }

  getCourses() {
    return this.courses;
  }
}

class ICourseRepository {
  addCourse(course) {}
  getCourses() {}
}

Liskov Substitution Principle (LSP)

This principle states that subclasses should be substitutable for their base classes. In other words, a subclass should be able to replace its parent class without changing the behavior of the program.
In the context of an LMS, let's consider a class called "VideoCourse" that extends the "Course" class. The "VideoCourse" class should be able to be used in place of the "Course" class without affecting the functionality of the LMS.

class VideoCourse extends Course {
  constructor(name, description, courseMaterial, videoUrl) {
    super(name, description, courseMaterial);
    this.videoUrl = videoUrl;
  }

  getVideoUrl() {
    return this.videoUrl;
  }
}

Interface Segregation Principle (ISP)

The Interface Segregation Principle states that no client should be forced to depend on methods it does not use. This means that we should create interfaces that are specific to the needs of each client, rather than creating a general-purpose interface that contains all possible methods. For example, if we have a class that is responsible for managing user profiles, we should create interfaces that are specific to the needs of each client.

In a learning management system, we can apply the ISP to our user profile management class. We can create interfaces that are specific to the needs of teachers and students, rather than creating a general-purpose interface that contains all possible methods. This will make our code more modular and easier to maintain.


class UserProfile {
  // common methods for all clients
  updateProfile(user, data) {
    // code to update user profile
  }

  deleteProfile(user) {
    // code to delete user profile
  }
}

// interface for teachers
class TeacherProfile {
  addCourse(course) {
    // code to add a course to teacher's profile
  }

  removeCourse(course) {
    // code to remove a course from teacher's profile
  }
}

// interface for students
class StudentProfile {
  enrollCourse(course) {
    // code to enroll a course for student
  }

  dropCourse(course) {
    // code to drop a course for student
  }
}

Dependency Inversion Principle (DIP):

The Dependency Inversion Principle states that high-level modules should not depend on low-level modules. Both should depend on abstractions. Abstractions should not depend on details. Details should depend on abstractions. This means that we should use interfaces to define the dependencies between classes, rather than concrete implementations. For example, if we have a class that is responsible for sending notifications, it should depend on an interface for sending notifications, rather than a concrete implementation.

In a learning management system, we can apply the DIP to our notification sending class. We can define an interface for sending notifications, and our notification sending class can depend on this interface. This will make our code more flexible and easier to maintain.

// interface for sending notifications
class NotificationSender {
  sendNotification(user, message) {
    // code to send notification
  }
}

// class that depends on the interface
class EmailNotificationSender {
  constructor(notificationSender) {
    this.notificationSender = notificationSender;
  }

  sendEmailNotification(user, message) {
    // code to send email notification
    this.notificationSender.sendNotification(user, message);
  }
}

// class that depends on the interface
class SMSNotificationSender {
  constructor(notificationSender) {
    this.notificationSender = notificationSender;
  }

  sendSMSNotification(user, message) {
    // code to send SMS notification
    this.notificationSender.sendNotification(user, message);
  }
}

Pros and Shortcomings:

The SOLID principles provide a set of guidelines for creating software that is easy to maintain, scalable, and extendable. By following these principles, we can create code that is more modular and easier to maintain, which can save us time and effort in the long run.

However, applying the SOLID principles can sometimes lead to more complex code, which can be harder to understand and debug. Additionally, applying the principles requires a certain level of skill and experience, which not all developers may possess.

In conclusion, the SOLID principles are a powerful set of guidelines that can help developers create high-quality software that is easy to maintain, scalable, and extendable. While there may be some upfront cost in terms of complexity and development time, the benefits of applying these principles are often worth it in the long run.

If you're new to the SOLID principles, it may take some time and practice to get used to applying them in your code. However, there are many resources available online that can help you get started, such as online courses, tutorials, and books.

Some recommended resources for further study include:

"Clean Code: A Handbook of Agile Software Craftsmanship" by Robert C. Martin
"Refactoring: Improving the Design of Existing Code" by Martin Fowler
"SOLID Principles of Object-Oriented Design and Architecture" course on Pluralsight
"The SOLID Principles of Object-Oriented Design" course on Udemy
By applying the SOLID principles in your code, you can improve the quality of your software and become a more skilled and effective developer.

Registry Pattern - Revolutionize Your Object Creation and Management in your applications

Olawale Afuye — Fri, 07 Apr 2023 11:14:42 +0000

The Registry pattern is a design pattern that provides a centralized location for managing and creating instances of objects. It is useful when you have multiple instances of related objects that need to be created and managed, and can simplify object creation and management by providing a single point of access for creating and retrieving instances of those objects.

In other way, a registry object maintains a collection of named objects and provides methods for registering and retrieving those objects. This can improve performance by allowing the system to reuse existing objects rather than creating new ones each time they are needed. It also makes it easy to add new types of objects to the system without modifying existing code.

Learning Management System (LMS)

Let's consider a Learning Management System (LMS) that needs to manage different types of courses, such as online courses, in-person courses, and hybrid courses. Each course type has its own set of properties and behavior, and we want to be able to create multiple instances of each course type.

Here's an example of how we can use the Registry pattern to manage the different course types:

Define a base Course class that defines the common properties and behavior of all course types:

class Course {
  name: string;
  description: string;

  constructor(name: string, description: string) {
    this.name = name;
    this.description = description;
  }

  enroll(student: Student) {
    // enroll the student in the course
  }

  cancelEnrollment(student: Student) {
    // cancel the student's enrollment in the course
  }
}

Define a subclass for each course type, and add any additional properties or behavior specific to that course type:

class OnlineCourse extends Course {
  url: string;

  constructor(name: string, description: string, url: string) {
    super(name, description);
    this.url = url;
  }

  start(): void {
    // start the online course
  }
}

class InPersonCourse extends Course {
  location: string;

  constructor(name: string, description: string, location: string) {
    super(name, description);
    this.location = location;
  }

  schedule(): void {
    // schedule the in-person course
  }
}

class HybridCourse extends Course {
  url: string;
  location: string;

  constructor(name: string, description: string, url: string, location: string) {
    super(name, description);
    this.url = url;
    this.location = location;
  }

  start(): void {
    // start the online portion of the hybrid course
  }

  schedule(): void {
    // schedule the in-person portion of the hybrid course
  }
}

Create a CourseRegistry object that will store instances of each course type:

interface CourseConstructor {
  new (...args: any[]): any;
}

class CourseRegistry {
  private courses: {[key: string]: CourseConstructor} = {};

  registerCourse(courseType: string, constructor: CourseConstructor): void {
    this.courses[courseType] = constructor;
  }

  createCourse(courseType: string, ...args: any[]): any {
    const CourseConstructor = this.courses[courseType];
    if (!CourseConstructor) {
      throw new Error(`Course type '${courseType}' not registered`);
    }
    return new CourseConstructor(...args);
  }
}


const courseRegistry = new CourseRegistry();
courseRegistry.registerCourse('online', OnlineCourse);
courseRegistry.registerCourse('in-person', InPersonCourse);
courseRegistry.registerCourse('hybrid', HybridCourse);

Create instances of each course type using the CourseRegistry:

const onlineCourse = courseRegistry.createCourse('online', 'Introduction to JavaScript', 'Learn JavaScript online', 'https://example.com/js');
const inPersonCourse = courseRegistry.createCourse('in-person', 'Advanced React', 'Learn advanced React techniques in person', 'New York');
const hybridCourse = courseRegistry.createCourse('hybrid', 'Full-stack Web Development', 'Learn full-stack web development', 'https://example.com/webdev', 'San Francisco');

Benefits of using the Registry pattern

Centralized management of object creation: The Registry pattern provides a centralized location for managing and creating instances of objects, which can simplify object creation and management.

Flexibility and extensibility: By using the Registry pattern, you can add new types of objects to the system without modifying existing code, making the system more flexible and extensible.

Improved performance: The Registry pattern can improve performance by allowing the system to reuse existing objects rather than creating new ones each time they are needed.

Easy access to objects: The Registry pattern provides a simple way to access objects throughout the system, making it easy to share objects between different parts of the system.

Demerits of using the Registry pattern

Increased complexity: The Registry pattern can introduce additional complexity to a system, particularly if it is not implemented properly or is used excessively.

Dependencies: The Registry pattern can introduce dependencies between objects and the Registry, which can make it more difficult to test and maintain the system.

Potential for naming collisions: The Registry pattern relies on unique names for objects, so there is a risk of naming collisions if multiple objects have the same name.

Potential for misuse: The Registry pattern can be misused if it is not implemented properly, leading to issues such as memory leaks, poor performance, and difficult-to-maintain code.

Overall, the Registry pattern can be a useful tool in certain situations, particularly when managing multiple instances of related objects. However, like any design pattern, it should be used judiciously and with careful consideration of its potential benefits and drawbacks.

Smart Steps for Remote Work Newbies: Protecting Yourself in the Digital Landscape

Olawale Afuye — Fri, 07 Apr 2023 05:22:44 +0000

Remote work has become an increasingly popular option for job seekers, particularly in the wake of the COVID-19 pandemic. However, for those who are new to this way of working, it can be difficult to know how to navigate the landscape and protect themselves from potential pitfalls. In this article, we will provide some tips and advice on how to ensure you are making a smart and informed decision when considering a remote work opportunity.

First and foremost, it is essential to thoroughly read and understand any offers or agreements you receive. Look out for red flags, such as payment milestones that are difficult to gauge or unclear. It is also important to determine or negotiate your salary, and to check the legitimacy of the email addresses from which the offers are sent.

Visiting the physical address or office of the organization can provide further reassurance and help to confirm its legitimacy. Additionally, researching the company's reputation online through platforms such as Glassdoor, Twitter, and Nairaland, as well as speaking with former employees, can provide valuable insights.

Meeting other employees of the company, either online or in person, can also be beneficial. It is not always a red flag if there is only one interview, but be cautious if there are no interviews at all.

For gig work, it is advisable to collect a mobilization fee to cover any potential losses in the event of client default or fraud. If proper verification is not possible, ensure that you have substantial control over your work in case of any issues.

Having personal and verifiable contacts in case of payment default can also be helpful, as can checking the profile and online engagements of the CEO.

If the first salary payment to you is delayed by two to three months, this can be a significant red flag. It is important not to fall for empty promises or excuses, as it is ultimately the employer's responsibility to pay you when you deliver.

One useful strategy is to examine the commits from past contributors and reach out to them personally to ask about their experience with the company. Auditors frequently do this for professional engagements, and it can provide valuable insights.

It is crucial not to act out of desperation when seeking remote work, don’t let hope get the better of reason. Take the time to do your research and background checks, and be cautious if you are given a full project as a test without any algorithms or pet projects to test your knowledge.

Look for clear and detailed job descriptions: Be wary of vague or overly generic job descriptions. If the job requirements and responsibilities are not clearly defined, it could be a red flag that the employer is not serious about the position.

Don't accept a job offer without speaking to a human first, even for online jobs. Phone or video interviews are necessary. Beware of work from home scams over the phone and turn down offers without usual interview procedures.

Use reputable job search platforms: Stick to using reputable job search platforms and websites to avoid falling for scams. Be cautious of unsolicited job offers that come through social media or email.

Check if the company is registered and in good standing with the relevant government agencies in their country of operation. Verify the company's legal status, ownership, and financial statements.

A company that has been successfully operating remotely for several years is more likely to be a legitimate employer. Look for reviews and feedback from other employees who have worked with the company in the past.

Be cautious of requests for payment of upfront fees or wire money, personal informatio. Be cautious of requests for sensitive personal information such as bank account details,asking payment for gadgets or documentations, and passwords. Legitimate employers will not ask for this information during the initial stages of the hiring process.

Get everything in writing. Ensure that all job offers, agreements, and communications with your employer are documented in writing. This can help protect you in case of any misunderstandings or disputes.

If you are working with a company located in a different country, be aware of potential cultural and language barriers. This can sometimes result in misunderstandings and miscommunications.

Be cautious of job offers that come to you unexpectedly. Watch for red flags to avoid scams and protect your privacy.

In conclusion, remote work can be a fantastic opportunity, but it is essential to approach it with caution and diligence. By following the tips outlined in this article, you can help ensure that you make informed decisions and protect yourself from potential issues.

Adapter Pattern using a payment gateway as a case study.

Olawale Afuye — Wed, 05 Apr 2023 06:50:19 +0000

Introduction
In the world of software development, there are times when you need to integrate different components that don't quite fit together. One such case is integrating a payment gateway into your application. You may have your own application architecture, but the payment gateway may have its own structure and set of APIs. This is where the adapter pattern comes into play. In this article, we will discuss the adapter pattern and how it can be used to integrate a payment gateway into your application.

The Adapter Pattern

The adapter pattern is a design pattern that allows you to convert the interface of one class into another interface that your application can use. This pattern is used when the interface of an existing class does not match the interface that your application expects. The adapter pattern consists of two parts: the adapter class and the adaptee class. The adapter class is the class that you create to convert the interface of the adaptee class into the interface that your application expects. The adaptee class is the class that you want to integrate into your application.

Case Study: Integrating a Payment Gateway

Let's consider a case where you need to integrate a payment gateway into your application. The payment gateway has its own set of APIs and interfaces, but your application has its own structure and set of APIs. To integrate the payment gateway into your application, you can use the adapter pattern.

First, you need to create an adapter class that will convert the interface of the payment gateway into the interface that your application expects. Here is a code sample in JavaScript:


interface PaymentGateway {
  charge(paymentDetails: PaymentDetails): string;
}

interface PaymentDetails {
  amount: number;
  currency: string;
}
class PaymentGatewayAdapter implements PaymentGateway {
  constructor(paymentGateway) {
    this.paymentGateway = paymentGateway;
  }

  processPayment(amount) {
    const paymentDetails = {
      amount: 10000,
      currency: 'USD'
    };
    return this.paymentGateway.charge(paymentDetails);
  }
}

In the above code, we have created an adapter class called PaymentGatewayAdapter that takes an instance of the payment gateway as its constructor argument. The adapter class has a method called processPayment that takes the payment amount as an argument and converts it into the payment details that the payment gateway expects. The adapter class then calls the payment gateway's charge method with the payment details and returns the result.

Next, you need to create an instance of the payment gateway and pass it to the adapter class. Here is a code sample in JavaScript:

class PaymentGateway {
  charge(paymentDetails: PaymentDetails): string {
    // Process payment using the payment gateway's APIs
    return 'Payment successful';
  }
}

const paymentGateway = new PaymentGateway();
const paymentGatewayAdapter = new PaymentGatewayAdapter(paymentGateway);
const paymentResult = paymentGatewayAdapter.processPayment(100);
console.log(paymentResult); // Output: Payment successful

In the above code, we have created an instance of the payment gateway and passed it to the adapter class. We have also created an instance of the adapter class and called its processPayment method with the payment amount. The adapter class converts the payment amount into the payment details that the payment gateway expects and calls the payment gateway's charge method. The result of the payment gateway's charge method is then returned by the adapter class.

Pros and Cons of the Adapter Pattern:

Pros:

It allows you to integrate components with different interfaces.
It keeps the integration code separate from your application code.
It allows you to reuse existing code without modifying it.
It there is a chnage it has to be done on the adapter.

Cons:

It adds an extra layer of abstraction to your application.
It can add complexity to your application if not implemented properly.
It can lead to performance issues if the adapter class is not optimized.

Final Notes:

In this article, we have discussed the adapter pattern and how it can be used to integrate a payment gateway into your application. We have also provided code samples.

If you are interested in learning more about the adapter pattern and how it can be used in software development, here are some references for further reading:

"Design Patterns: Elements of Reusable Object-Oriented Software" by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides.
"Head First Design Patterns" by Elisabeth Freeman and Eric Freeman.
"Adapter Design Pattern" on GeeksforGeeks: https://www.geeksforgeeks.org/adapter-pattern/
"Adapter Pattern" on Refactoring.Guru: https://refactoring.guru/design-patterns/adapter
"JavaScript Design Patterns: The Adapter Pattern" on SitePoint: https://www.sitepoint.com/javascript-design-patterns-adapter-pattern/
"Adapter Pattern in JavaScript" on Medium: https://medium.com/@olinations/adapter-pattern-in-javascript-f9f830d23d7d
These resources provide a more in-depth understanding of the adapter pattern and how it can be used in different scenarios.

Types of Design patterns.

Olawale Afuye — Fri, 24 Mar 2023 16:21:38 +0000

Software development can be a complex and challenging process, especially when it comes to designing software that is both efficient and maintainable. This is where design patterns come into play. Design patterns are reusable solutions to common software design problems that have been tried and tested over time. These patterns offer developers a set of guidelines that help them to create software that is more flexible, reusable, and maintainable. By using design patterns, developers can write code that is more easily understood and adapted to changing requirements, and can avoid common pitfalls that can lead to errors and bugs. In this article, we will explore the types of design patterns in more detail and examine how they can be used to improve the quality of software design.

In subsequent articles, I will discuss one pattern after the other.

There are several types of design patterns, including:

Creational patterns: These patterns are used to create objects and provide ways to create objects in a manner suitable for the situation at hand. Examples include
Some of the creational design patterns are as follow:

Singleton Design Pattern
Factory Design Pattern
Abstract Factory Design Pattern
Builder Design Pattern
Prototype Design Pattern
Object Pool Design Pattern

Structural patterns: These patterns focus on the composition of classes and objects to form larger structures. Examples include:

Adapter pattern
Bridge pattern,
Composite pattern,
Decorator pattern,
Facade pattern,
Flyweight pattern,
and Proxy pattern

Behavioral patterns: These patterns are concerned with the interaction and communication between objects and how they operate together to perform tasks. Examples include:

Observer pattern,
Chain of Responsibility pattern,
Command pattern,
Interpreter pattern,
Iterator pattern,
Mediator pattern,
Memento pattern,
State pattern,
Strategy pattern,
Template Method pattern,
Visitor pattern.

Concurrency patterns: These patterns are designed to help manage and coordinate concurrent programming tasks and multi-threaded programming paradigm. Examples include:

Monitor Object pattern
Active Object pattern,
Half-Sync/Half-Async pattern
Producer Consumer Design Pattern
Leaders/followers pattern
Read write lock pattern
Balking pattern
Scheduler pattern
Thread pool pattern
Barrier pattern
Double-checked locking
Guarded suspension pattern
Reactor pattern

Architectural patterns: These patterns are used to design and organize the structure of large-scale software applications. Examples include:

Model-View-Controller (MVC) pattern,
Model-View-Presenter (MVP) pattern,
Model-View-ViewModel (MVVM) pattern,
Layered architecture pattern,
Microservices architecture pattern.

These are some of the main categories of design patterns, but there are many more specific patterns within each category. Understanding and applying design patterns can help to improve the quality, maintainability, and flexibility of software systems.

The concept of design patterns has been criticized in several ways. As the right usage of, right design pattern at right place, in right context give the advantages if the above conditioned not satified and worng pattern is been used then it creates mess for the design. So it is atmost important task to choose the right design pattern for specific situations.

In my upcoming tutorials, I will be taking each patterns one by one using a popular app as a case study.

Command Pattern in Programming using a uber as a case study

Olawale Afuye — Wed, 22 Mar 2023 20:23:09 +0000

the command pattern is a behavioral design pattern in which an object is used to encapsulate all information needed to perform an action or trigger an event at a later time. This information includes the method name, the object that owns the method and values for the method parameters. It is also a design pattern in software development that allows us to encapsulate requests or commands as objects, allowing us to parameterize clients with different requests, queue or log requests, and support undoable operations.

To explain this pattern using an Uber app as an example, let's consider the following scenario:

Suppose you're building an Uber app, and you want to implement a feature that allows users to request a ride. When a user requests a ride, you'll need to perform several tasks, such as:

Finding a nearby driver
Calculating the fare
Notifying the driver about the ride request
Updating the user's ride history

Instead of implementing all these tasks directly in the ride request function, we can use the Command Pattern to encapsulate each task as a separate object, and then chain them together to perform the entire ride request process.

Here's how it would work:

We create a base Command interface or abstract class that defines an execute method.

We create concrete command classes that implement the Command interface or extend the abstract class. For example, we might create a FindDriverCommand, CalculateFareCommand, NotifyDriverCommand, and UpdateRideHistoryCommand.

We pass the concrete command objects to the ride request function, which stores them in a queue or list.

The ride request function then iterates over the list of commands and calls the execute method on each command object.

The execute method of each command object performs the specific task it's responsible for, such as finding a nearby driver or calculating the fare.

Once all the commands have been executed, the ride request function completes the ride request process.

// Define the Command interface
class Command {
  execute() {}
}

// Define concrete command classes
class FindDriverCommand extends Command {
  execute() {
    // Find a nearby driver
    console.log("Finding a nearby driver...");
  }
}

class CalculateFareCommand extends Command {
  execute() {
    // Calculate the fare
    console.log("Calculating the fare...");
  }
}

class NotifyDriverCommand extends Command {
  execute() {
    // Notify the driver about the ride request
    console.log("Notifying the driver...");
  }
}

class UpdateRideHistoryCommand extends Command {
  execute() {
    // Update the user's ride history
    console.log("Updating ride history...");
  }
}

// The ride request function that uses the Command Pattern
function requestRide() {
  const commands = [
    new FindDriverCommand(),
    new CalculateFareCommand(),
    new NotifyDriverCommand(),
    new UpdateRideHistoryCommand()
  ];

  // Execute the commands in sequence
  for (let i = 0; i < commands.length; i++) {
    commands[i].execute();
  }
}

// Request a ride
requestRide();
**Logs**
Finding a nearby driver...
Calculating the fare...
Notifying the driver...
Updating ride history...

In this example, we define the Command interface and several concrete command classes that implement the interface. We then create a requestRide function that uses the Command Pattern to execute a sequence of commands, such as finding a nearby driver, calculating the fare, notifying the driver, and updating the user's ride history. Finally, we call the requestRide function to request a ride, which executes the commands in sequence.

Using the Command Pattern in this way provides several benefits, including:

Decoupling the client (the ride request function) from the implementation details of each task. This makes it easier to add new tasks or modify existing ones without affecting the client code.
Making it possible to queue or log commands for later processing, which can be useful for handling high traffic or distributed systems.
Allowing for undoable operations, which can be useful in scenarios where a user might accidentally request a ride or change their mind after the ride has been requested.

While the Command Pattern has several advantages, it also has some potential pitfalls:

Complexity: The Command Pattern can add extra complexity to the code by requiring the creation of additional classes and objects. This can make the code harder to read and understand, especially for junior developers.

Overhead: Using the Command Pattern can add overhead to the system, as each command needs to be created as an object and stored in memory. This can be a concern in resource-constrained environments.

Maintenance: As the number of commands and the complexity of the system grow, maintaining the Command Pattern can become challenging. Refactoring and debugging can be more difficult due to the increased number of classes and objects.

Unnecessary for simple tasks: The Command Pattern is designed to handle complex tasks that require a sequence of steps or undoable operations. For simple tasks, it can be overkill and add unnecessary complexity to the code.

Potential for misuse: The Command Pattern can be misused if developers create too many unnecessary commands or use it in situations where it is not needed, leading to code bloat and decreased performance.

It's important to carefully consider whether the Command Pattern is the right solution for a particular problem, and to use it judiciously when it is appropriate.