DEV Community: Akpevwe11

The Impact of AI in Software Development: A Double-Edged Sword

Akpevwe11 — Wed, 28 May 2025 08:30:50 +0000

Artificial Intelligence is reshaping software development in unprecedented ways. From code generation to bug detection and architectural design, AI tools like GitHub Copilot, ChatGPT, and Claude are accelerating developer workflows and increasing productivity.

Positive Impacts:

Enhanced Productivity: AI-assisted coding reduces the time spent writing boilerplate code, enabling developers to focus more on problem-solving and creativity.

Bug Detection and Testing: AI tools can scan through large codebases to identify vulnerabilities and generate test cases, making software more secure and reliable.

Learning and Mentorship: AI is an on-demand tutor, helping new developers understand complex concepts quickly and improving the overall learning curve.

Rapid Prototyping: AI can help developers iterate faster on new ideas, validate concepts, and build MVPs without getting bogged down in repetitive tasks.

Negative Impacts:

Over-reliance on AI: Developers may become overly dependent on AI tools and lose touch with core programming principles and logic.

Code Quality Concerns: AI-generated code can be syntactically correct but semantically wrong or insecure, especially if developers fail to review and test it properly.

Job Displacement Anxiety: As AI takes over repetitive tasks, there's fear that some developer roles may become redundant, particularly those focused on simple or routine coding tasks.

Bias and Ethical Risks: AI tools are trained on vast datasets that may contain biased or unethical code patterns, which can be unknowingly propagated.

AI is not here to replace developers but to empower them. When used responsibly, it can be a superpower. But like all tools, its impact depends on how wisely we wield it.

Demystify google search

Akpevwe11 — Sun, 14 Apr 2024 18:38:03 +0000

As we surf the internet with our various devices, we some time pause to ponder the the complex infrastructure that takes our request to their destination.

In this article, I'll take you through a journey and the various layers of the web to demystify what happens behind the scene when we type in an address like https://www.google.com and press Enter.

DNS Request

We begging surfing the internet by typing in a URL in our browser. our browser takes in whatever domain name we typed in and then send it to a DNS server. this step is carried out for DNS resolution purposes. ( is a process of converting the human friendly domain name typed into the browser to its equivalent IP address).

This process is facilitated by the Domain Name System (DNS). This DNS service is typically provided by our internet service provider (ISP) or a third-party DNS service like Google DNS. The resolver simply retrieves the corresponding IP address associated with www.google.com from a DNS server.

TCP/IP

The next stage of the process is our browser establishing a TCP (Transmission Control Protocol) Connection with the resolved IP address. The essence of the TCP connection is to ensure reliable delivery of data by breaking the data into packets, and then reassembling them at the destination.

FireWall

Before a request arrives at its final destination, it may encounter a firewall. a fire wall is a security measure designed to filter incoming and outgoing traffic from a server based on predetermined rules.

The essence of firewall is to ensure that only legitimate traffic can pass through it. protecting the network from unauthorized access or malicious activity.

HTTPS/SSL

as the browser establishes a connection with the server, it has do so securely using HTTPS (Hypertext Transfer Protocol Secure). HTTPS, is a secure communication protocol that encrypts data exchange between the client and server. This encryption is made possible through the use of SSL (Secure Sockets Layer) or its successor, TLS(Transport Layer Security), in order to ensure confidentiality and integrity of communication with the server.

Load Balancer

Upon reaching the server's network, our request may encounter a load balancer-- a load balancer is a device that distributes incoming traffic across multiple servers in order to optimize resource usage and maximize throughput, and ensure high availability.

Load balancers enhances the scalability and reliability of web applications by evenly distributing the workload among servers.

Web Server

Once our request successfully traverses the load balancer, it arrives at a web server—a specialized software application responsible for serving web content in response to client requests. The web server processes our request, retrieves the requested resources (such as HTML, CSS, and JavaScript files), and sends them back to our browser for rendering.

Application Server

In scenarios where dynamic content is involved, our request may be forwarded to an application server—a server-side software framework or environment capable of executing application logic, querying databases, and generating dynamic content on-the-fly. The application server interacts with databases, external services, and other resources to fulfill our request and generate a personalized response.

Database

Behind the scenes, our application server may interact with a database—a structured collection of data organized for efficient retrieval and storage. Whether it's storing user information, product catalogs, or session data, databases play a crucial role in powering dynamic web applications by providing persistent storage and enabling data-driven functionalities.

By understanding the intricacies of this journey, we gain insight into the fundamental workings of the web.

Deeper Dive Into Generics In Type Script

Akpevwe11 — Fri, 23 Jun 2023 15:34:18 +0000

In my previous article, I we look at an introduction to generics in typescript and we looked at a few examples of how to create a generic function, class, and interface. In this article, we're going to take a deeper dive into the world of generics.

We're going to look at more advance topics such as:

Multiple generic types
Constraining and using the type T
Generic constraints and interfaces
Creating new objects within generics

Let's get started with generics.

TypeScript employs an angled bracket notation along with a type symbol to indicate the use of generic syntax.

let say you use the type T as the generic type. to specify that is being used as a generic type, it has to be wrapped within angle brackets <T>. to indicate that this code is substituting a normal type name with the symbol T.

let use some code samples to make this more clearer:

function identity<T>(arg: T) {
  console.log(`typeof T is : ${typeof arg}`);
  console.log(`value is : ${arg}`)
}

// Usage
identity(1);
identity("string");
identity(true);
identity(() => { });
identity({ id: 1 });

Here, we are calling the identity function with a wide range of values (number, string, boolean).

if you print the output to the console, it will be as follows:

value is : 1
typeof T is : string
value is : string
typeof T is : boolean
value is : true
typeof T is : function
value is : () => {}
typeof T is : object
value is : [object Object]

As we can see from this output, theidentity function is indeed working with pretty much every type that we can throw at it.

we can also call this function as follows:

identity<string>("string");

Here, we are using what is known as type casting that is, the angled brackets is used to explicitly specify what type we are calling this function with.

if you look at the previous way in which we called the indentity function, we did not, explicitly set the type using this long form notation, but simply called the
function with an argument, that is, identity(1). In this instance, TypeScript is inferring the type T to be a number.

Note, too, that if we explicitly set the type to be used using this long form notation, type rules will apply for any usage of the type T. Consider the following example:

identity<string>(1);

Here, we are explicitly specifying that the function will be called with a type , but our single argument is actually of type number. This code will generate the following error:

error TS2345: Argument of type '1' is not assignable to parameter of type 'string'

This error is telling us that we are attempting to call a generic function with the wrong type as an argument, as the type of T was explicitly set.

If we do not explicitly specify what type the generic function
should use, by omitting the specifier, the typescript compiler will infer the type to be used from the type of each argument.

Multiple Generic Type

Type Script also allows you to define multiple type parameters for classes, interfaces, and functions. Here's an example of using multiple generic type parameters in Type Script:


 function printPair<T1, T2>(pair: [T1, T2]): void {
  const [first, second] = pair;
  console.log(`First: ${first}, Second: ${second}`);
}

printPair<string, number>(["Hello", 42]); // Output: First: Hello, Second: 42
printPair<number, boolean>([3.14, true]); // Output: First: 3.14, Second: true

here, we have a function printPair with two generic type parameters, T1 and T2. The function takes an array pair of two elements and logs their values to the console.

When calling the printPair function, we specify the types for the generic type parameters within angle brackets (<>). In the first invocation, we pass an array of type [string, number] to the function, indicating that the first element is a string and the second element is a number. In the second invocation, we pass an array of type [number, boolean], specifying that the first element is a number and the second element is a boolean.

let see another example where we use multiple generic type parameters in TypeScript:

class Pair<T1, T2> {
  private first: T1;
  private second: T2;

  constructor(first: T1, second: T2) {
    this.first = first;
    this.second = second;
  }

  getFirst(): T1 {
    return this.first;
  }

  getSecond(): T2 {
    return this.second;
  }

  setFirst(first: T1): void {
    this.first = first;
  }

  setSecond(second: T2): void {
    this.second = second;
  }
}

const pair1: Pair<string, number> = new Pair("Hello", 42);
const pair2: Pair<number, string> = new Pair(3.14, "World");

we define a Pair class with two type parameters, T1 and T2. The class has properties first and second of types T1 and T2, respectively. The constructor and methods of the class are also using the generic type parameters.

We can create instances of the Pair class by specifying the types for the type parameters. In the example, pair1 has a type Pair<string, number> representing a pair of a string and a number, while pair2 has a type Pair<number, string> representing a pair of a number and a string.

Constraining the type of T

constraining is the act of limiting the type of T in order to only allow a specific set of types to be used within our generic code. This helps enforce type safety and provides more control over the types that can be used with a generic type or function. Here are a few ways to apply constraints in TypeScript:

Type constraints with extends:

You can use the extends keyword to enforce that the generic type T must extend a certain type or satisfy specific conditions. For example:

  interface Printable {
  print(): void;
}

function printItem<T extends Printable>(item: T): void {
  item.print();
}

class Book implements Printable {
  print(): void {
    console.log("Printing book...");
  }
}

printItem(new Book()); // Output: Printing book...

In the example above, the printItem function accepts a generic parameter T constrained by the Printable interface. This means that T must be a type that implements the Printable interface. Therefore, we can pass an instance of the Book class (which implements Printable) to the printItem function.

Using T as a return type: You can use T as the return type of a function, allowing the caller to determine the specific type returned based on the input. For example:

function identity<T>(value: T): T {
  return value;
}

const result = identity("Hello");
console.log(result.toUpperCase()); // Output: HELLO

In the above example, the identity function takes a generic parameter T and returns the same value of type T. When calling the function with the string "Hello", the inferred type of result is string, and we can use string-specific methods like toUpperCase() on it.

Using intersection (&) to impose multiple constraints:

You can apply multiple constraints by using the intersection type operator (&). This ensures that the generic type parameter satisfies all the specified conditions. Here's an example:

 interface Printable {
  print(): void;
}

function printItem<T extends Printable & { name: string }>(item: T): void {
  console.log(item.name);
  item.print();
}

class Book implements Printable {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
  print(): void {
    console.log("Printing book:", this.name);
  }
}

const book = new Book("The TypeScript Guide");
printItem(book); // Output: The TypeScript Guide \n Printing book: The TypeScript Guide

In this case, the printItem function expects a generic type T that satisfies two conditions: it extends the Printable interface and has a name property of type string. The Book class meets these requirements, so calling printItem(book) successfully prints the name of the book and invokes the print method.

Using type predicates: Type predicates allow you to specify custom constraints using type assertions and logical checks. This technique is particularly useful when dealing with union types or runtime validations. Here's an example:

function isNumber(value: unknown): value is number {
  return typeof value === "number";
}

function multiplyByTwo<T>(value: T): T | undefined {
  if (isNumber(value)) {
    return value * 2;
  }
  return undefined;
}

console.log(multiplyByTwo(5)); // Output: 10
console.log(multiplyByTwo("Hello")); // Output: undefined

In the above example, the isNumber function is a type predicate that checks whether the value is a number. The multiplyByTwo function uses this type predicate to conditionally multiply the value by two if it's a number. Otherwise, it returns undefined. This allows for type-specific operations while maintaining type safety.

Using T to define properties or methods: You can use T to define properties or methods within a class or interface. This allows the class or interface to work with different types based on the actual usage. Here's an example:

class Container<T> {
  private value: T;

  constructor(value: T) {
    this.value = value;
  }

  getValue(): T {
    return this.value;
  }
}

const container = new Container<string>("Hello");
console.log(container.getValue()); // Output: Hello

In this example, the Container class has a generic type parameter T, and the value property is of type T. We can create an instance of Container with a specific type, in this case, string, and retrieve the stored value using thegetValue method.

By applying constraints in TypeScript, you can ensure that generic types adhere to specific requirements, leading to more robust and predictable code.

Generics in typescript made easy

Akpevwe11 — Wed, 21 Jun 2023 15:23:12 +0000

lets say in your house, you have different containers where you sort different things, like toys, books, and candies. Then you have a container that can hold any thing (whether it be books, candies, toys) without things getting messy.

Generics in Typescript is like that special box that can hold any thing. They are like magic placeholders that allow you to create a special box that can hold different types of things. Instead of specifying a specific type of thing, you can use a generic placeholder.

In a much more technical term, generics is just a "Yet to be defined" type, that obtains its' definition at the moment of use.

They allow you to create reusable components and functions that can work with a variety of data types while maintaining type safety. They provide a way to define placeholders for types that will be specified when the component or function is used.

To define a generic type in TypeScript, you use angle brackets (<>) and specify the generic parameter(s) inside them. Here's a basic example of a generic function:

function identity<T>(arg: T): T {
  return arg;
}

In this example, T is the generic parameter representing the type of the argument and the return value. The function identity takes an argument of type T and returns a value of the same type T. When the function is called, the type inference system will automatically determine the specific type based on the argument passed.

lets look at another example that relates to our box analogy.

Imagine you have a function called getContents that takes a box and tells you what's inside it. With generics, you can write the function like this:

 function getContents<T>(box: T): T {
  return box;
}

The <T> part is like a blank space where you can fill in any type you want when you use the function. For example, you can call the function like this:

 const toyBox: string = getContents("Teddy Bear");
const bookBox: number = getContents(5);
const candyBox: boolean = getContents(true);

In this example, the T in getContents<T> becomes a specific type depending on what you pass to the function. The function returns the same type that you put in. So if you put a string, it will return a string. If you put a number, it will return a number.

Using generics with classes and interfaces.

Just as we can create generic functions that can work with a wide variety of types, we can as well create generic interfaces and classes.

A generic interface allows you to define an interface that can work with different types. It enables you to create reusable and flexible interfaces that can be used with various data types without explicitly specifying the type.

Here's an example of a generic interface in TypeScript:

interface Container<T> {
  data: T;
  add(item: T): void;
  remove(item: T): void;
  getSize(): number;
}

In the above code, Container is a generic interface that takes a type parameter T. The interface has three methods:add, remove, andgetSize, which operate on the type T. The data property is also of type T.

You can then use this generic interface with different types when implementing a class, like this:

class NumberContainer implements Container<number> {
  data: number[] = [];

  add(item: number): void {
    this.data.push(item);
  }

  remove(item: number): void {
    const index = this.data.indexOf(item);
    if (index !== -1) {
      this.data.splice(index, 1);
    }
  }

  getSize(): number {
    return this.data.length;
  }
}

const container = new NumberContainer();
container.add(1);
container.add(2);
container.add(3);
console.log(container.getSize()); // Output: 3
container.remove(2);
console.log(container.getSize()); // Output: 2

In the above example, the NumberContainer class implements the Container interface with the type parameter number. This allows the data property and methods to work specifically with numbers.

You can create additional implementations of the Container interface with different types, providing flexibility and reusability.

Why Do We Need Generics in Type Script?

Generics are important in TypeScript, for several reasons:

Reusability: Generics allow you to create components, functions, and data structures that can work with different types of data. This promotes code reuse and reduces the need to write duplicate code for each specific type. By using generics, you can create versatile and flexible code that can be used with various data types.
Type Safety: TypeScript is a statically typed language, and generics help enforce type safety. By using generics, you can specify the expected type of data that a component or function should work with. This helps catch type-related errors at compile-time, reducing the chances of runtime errors and improving the overall reliability of your code.
Abstraction: Generics allow you to create abstract and generic algorithms or data structures. You can design components and functions that are independent of the specific data types they operate on, making your code more modular and easier to maintain. This level of abstraction enables you to write flexible and reusable code that can adapt to different scenarios.
Code Readability: Generics can make your code more expressive and readable. When you use generics, you provide clear intentions and expectations about the types of data being used. This helps other developers understand the purpose and requirements of your code, making it easier to collaborate and maintain the codebase in the long run.
Performance: Generics can help improve performance by avoiding unnecessary type conversions or type checking operations. By working directly with the specified types, you can optimize your code and reduce overhead, leading to more efficient execution.

Overall, generics provide a powerful tool for writing reusable, type-safe, and expressive code. They promote code modularity, improve maintainability, and enhance the overall quality and performance of your software projects.

What are Prototypes in JavaScript

Akpevwe11 — Fri, 28 Apr 2023 12:02:19 +0000

Prototype is one of the most confusing concepts in JavaScript to wrap your head around. even seasoned JavaScript developers still have a hard time understanding prototyping and how to apply it in their code base.

JavaScript uses Prototypes and constructors to mimic class.
But in JavaScript, we don’t have classes, what we have is object. so how can we implement inheritance using objects?

Let say we have a Car object, we can define another object called Vehicle and we add all the common behavior or common method to the Vehicle object, like:

drive(startLocation, endLocation) and some how, we can link the Car object and the Vehicle object. and now we refer to Vehicle object as the prototype of the Car.

So prototype is just the parent of another object. most materials out there makes prototypes sounds complicated. so whenever you hear the word prototyping just know it is just parent.

Every object in JavaScript has a prototype or parent except for one object. objects inherits all the members define in his prototype. let see that in action.

open google chrome and go to the developer tool on the console tab, define an empty object as shown below:

you will notice a property called [[Prototype]] . you will also notice other properties like constructor, hasOwnProperty,and so on.

Every object has a constructor property which reference the function that was used to construct that object.

let see a diagrammatic representation of the x object.

so we have this x object in memory, and the x object is linked another object (lets call it the base object ). the x object inherits the properties and methods of the base object.

So every object we create in JavaScript, directly or indirectly inherits from the base object.

so the base object is the root of all object in JavaScript and so doing, it doesn’t have a prototype or parent.

let say we create another object in memory called myobject.

you will observe that both x object and myobject have the same properties and methods, because they inherit from the same baseobject. and based on the fact that they are empty objects. that is, they do not have properties and methods of their own except for the the once they inherit from the baseobject.

Back in you browser developer tool, if you type in Object.getPrototypeOf(x).

what you see above is the object base with its members.
an expression like as shown below will result to true. try it out on your browser developer tool.

Object.getPrototypeOf(x) === Object.getPrototype(myobject); 
// true

The reason is because both x and myobject has exact same prototype.

when you access the property or method of an object, JavaScript engine first look for that property on the object if it cant find it, it looks at the [[prototype]] for that object which we called base object. in JavaScript, this is what is referred to as prototypical inheritance.

Conclusion

Overall, prototypes are a powerful feature of JavaScript that allows objects to inherit properties and methods from other objects. They are very vital when one wants to create multiple objects with the same properties and methods, which makes your code DRY.

Encapsulation Explained using JavaScript

Akpevwe11 — Sat, 15 Apr 2023 01:15:21 +0000

Encapsulation is one of the fundamental principles of object-oriented programming (OOP) that refers to the concept of binding the data (member variable) and the methods that operate on the data (member functions) within a single unit called a class.

Encapsulation enables programmers to hide the implementation details of one object from other objects and restrict direct access to the internal state of an object.

Encapsulation provides several benefits, such as:

improving the maintainability of the code -- making it easier to modify and extend the class's functionality.
Enhancing the security of the data by preventing unauthorized access.
It also allows the programmer to use the class's interface without knowing the implementation details, which makes it easier to use and understand.

let look at an example of encapsulation in JavaScript:

function createCounter() {
  let count = 0;

  function increment() {
    count++;
    console.log(count);
  }

  return increment;
}

const counter = createCounter();

counter(); // Output: 1
counter(); // Output: 2
counter(); // Output: 3

In this example, we have a createCounter function that returns an increment function. The increment function has access to the count variable through a closure, but the count variable is not accessible from outside the function. The only way to modify the count variable is by calling the increment function, which increments the count and logs it to the console.
This is an example of encapsulation because the count variable is hidden from the outside world and can only be accessed through the increment function, which provides a well-defined interface for accessing and modifying the count.

In addition to using closures, another way to achieve encapsulation in JavaScript is by using setters and getters. Setters and getters are methods that allow us to control how properties are set and retrieved from an object.

Here's an example of encapsulation using setters and getters:

class Person {
  constructor(name, age) {
    this._name = name;
    this._age = age;
  }

  get name() {
    return this._name;
  }

  set name(newName) {
    if (typeof newName === "string") {
      this._name = newName;
    } else {
      throw new Error("Name must be a string");
    }
  }

  get age() {
    return this._age;
  }

  set age(newAge) {
    if (typeof newAge === "number" && newAge > 0) {
      this._age = newAge;
    } else {
      throw new Error("Age must be a positive number");
    }
  }
}

const person = new Person("John Doe", 30);
console.log(person.name); // Output: John Doe
console.log(person.age); // Output: 30

person.name = "Jane Doe";
person.age = 25;

console.log(person.name); // Output: Jane Doe
console.log(person.age); // Output: 25

person.name = 123; // Throws an error: Name must be a string
person.age = -1; // Throws an error: Age must be a positive number

In this example, we have a Person class with name and age properties that are encapsulated using setters andgetters. The getters allow us to retrieve the values of these properties, while the setters allow us to control how they are set.

For instance, the name setter checks whether the new value is a string before setting the _name property, while the age setter checks whether the new value is a positive number. This allows us to enforce certain constraints on the values of these properties and ensure that they are always valid.

By encapsulating thename and age properties using setters and getters, we can hide their internal implementation and control how they are accessed and modified from outside the class. This helps to maintain the integrity of the object and prevent any unexpected side-effects that could result from direct manipulation of its properties.

In Summary, In encapsulation can be achieved through the use of closures and modules, as well as using setters and getters to control how properties are set and retrieved from an object. it also helps to improve the quality and maintainability of software systems.

An Introduction to Object Oriented Programming in JavaScript

Akpevwe11 — Sat, 25 Mar 2023 14:51:12 +0000

so what is object-oriented programming? it is a style of programming that is centered around objects .that is a kind of binding or tie that exists between data which are referred to as properties of the object and functions that operates on that data which are called methods in OOP. The combination of member variables (properties of the object) and member functions (methods that operate on the variables) is referred to as an object. OOP breaks down a problem into several entities called objects and these objects can then communicate with each other.

Object Oriented Programming is not a tool or a framework but a programming paradigm. several programming languages support oop such as c#, Java, Ruby, PHP and more. many of the frameworks out there such as laravel, spring boot, and .NET framework were designed using object-oriented principles. if you want to go far in your career as a software developer, you need to understand object-oriented programming principles.

In this article, I'm going to explain object-oriented principles and how to implement them in JavaScript.

Basic Concepts of Object-oriented Programming

Objects

An Object is a unique entity that contains properties and methods. if you take a look around you right now, you'll find many examples of real-world objects: your mobile phone, your dog (if you have one)

Real-world objects share two characteristics: They all have states and behavior. Dogs have state (name, color, breed) and behavior (barking, fetching, wagging tail). Software objects are kind of similar to real-world objects: they too consist of state and related behavior. An object stores its state in fields (which can also be referred to as variables) and behaviors are expressed through methods (which can also be referred to as functions in some programming languages). Methods operate on an object's internal state. they serve as the channel for object-to-object communication. Hiding the internal state and requiring all interaction to be performed through an object's methods is known as data encapsulation.

The object can be created in two ways using JavaScript

Object Literal

Example:

Using Object literal:

const Student = {

   // properties

name: "James",

age: 21,

gender: "Male",

Department: "Computer Science",

// method

getDetails: function() {

return `Student Name ${this.name} Student age: ${this.age}

gender: ${this.gender} Department: ${this.Department}`;

     }

}

Constructor Function

Examples:

using object constructor:


function Student(name, age, gender, Department) {

this.name = name;

this.age = age;

this.gender = gender;

this.Department = Department;

this.getDetails = function() { return Student Name ${this.name}, Student age: ${this.age}, gender: ${this.gender}, Department: ${this.Department};
   }

}

Classes

In the real world, you'll often find many individual objects all of the same kind. let's say for example your mobile phone. there may be thousands of other phones in existence, all of the same make and model. Each phone was built from the same set of blueprints and therefore contains the same components. In object-oriented terms, we say that your phone is an instance of the class of objects known as a Phone. A class is a blueprint from which individual objects are created. another scenario is that a real estate developer can use a single architectural blueprint to make multiple replicas of the same type of building.

There is something I want you to take note of, unlike other Object Oriented languages there are no classes in JavaScript we have only Object. JavaScript is a prototype-based language, meaning that it doesn't have classes, rather it defines behaviors using a constructor function and then reuses it using the prototype.

JavaScript classes, introduced in ECMAScript 2015, are primarily syntactical sugar over JavaScript’s existing prototype-based inheritance. The class syntax is not introducing a new object-oriented inheritance model to JavaScript. JavaScript classes provide a much simpler and clearer syntax to create objects and deal with inheritance.
-Mozilla Developer Network
let's look at the two ways in which one can obtain a class-like behavior in JavaScript.

Example 1: Using ES6 Class Syntax

// Defining class using ES6

class Vehicle {

constructor(name, model, maker)

{

this.name = name;

this.model = model;

this.maker = maker;

}
 getDetails() {

return The name of the Vehicle is ${this. name}.

}

} // Making object with the help of the constructor let vehicle1 = new Vehicle('corolla', 2010, 'Toyota'); console.log(vehicle1.name); console.log(vehicle1.maker); console.log(vehicle1.model); console.log(vehicle1.getDetails());

Example 2

: Simulating Classes Using Constructor functions

// Defining class using Object Constructor function Vehicle(name, model, maker) {

this.name = name;

this.model = model;

this.maker = maker;

this.getDetails = function() {

console.log('The name of the bike is ' + this.name);

}

}; let vehicle1 = new Vehicle('corolla', 2018, 'Toyota');

vehicle1.getDetails();

Pillars of Object-oriented Programming

There are four main pillars of Object-oriented programming, they are:

Abstraction
Polymorphism
Encapsulation
Inheritance

Abstraction

Think of your mobile device or your computer as an object, your mobile device or computer has a complex circuit board inside of it and buttons or touch screens on the outside that you interact with (interface). as a computer user, you don't need to know the working principles behind its operation to use it for your purpose or use case. all the complexities of the circuit board are hidden from you. This is what is referred to as abstraction. displaying only essential information and hiding the details.

We can do the same thing for our object in a computer program by hiding some properties and methods from outside usage and exposing only the essentials.

The way to hide the details of a class is by creating private properties and methods.

Example:

let's understand abstraction using an example.

function Box(length, breadth, height) {

this.length = length;

this.breadth = breadth;

this.height = height;

this.defaultPosition = { x: 0, y: 0};

this.computeOptimumPosition = function() {

console.log('compute the best positon');

} this.draw = function() {

this.computeOptimumPosition();

console.log('draw');

}

} const box1 = new Box(55, 22, 35);

console.log(box1.defaultPosition)

box1.computeOptimumPosition()

let's say for example we don't want consumers of this object to have access to computeOptimumPosition() function and the defaultPosition property, we can do that by abstracting it way (that is by declaring them as private properties so that consumers of the class can't have direct access to it). the process of making these properties private is known as abstraction.

Example:

let's make these properties private

the way to makecomputeOptimumPosition()function and the defaultPosition variable private is by declaring them as local variables inside of the constructor function making them go out of scope outside of the function. with this technique, we can hide certain members of the class from the outside.

function Box(length, breadth, height) {

this.length = length;

this.breadth = breadth;

this.height = height;

let defaultPosition = { x: 0, y: 0};

let computeOptimumPosition = function() {

console.log('compute the best positon');

} this.draw = function() {

// ensure you remove this keyword here too

computeOptimumPosition();

console.log('draw');

}

} const box1 = new Box(55, 22, 35);

console.log(box1.defaultPosition) // trying this out will result in an error

box1.computeOptimumPosition() // trying to do this will result in an error

so by removing thethis keyword and declaring them as local variables using the let the keyword, we've been able to make them private.

Benefits of abstractions

Simpler Interface: simple interface by exposing only the essentials

helps to reduce the impact of change: that is changing a private property or method won't have any external effect.

Encapsulation

Encapsulation is the wrapping up/binding of data and function into a single unit called a class. encapsulation helps keep an object's internal state (member variables or data) private so that it can only be accessed by the object's methods (member functions), and not from other objects. These functions (member methods) facilitate object-to-object communication within your program.

Inheritance

Inheritance is a way of reducing redundant code and ensuring reusability within your program. It is a phenomenon in which some properties and methods of an Object are being used by another Object. In other object-oriented programming languages, classes inherit from other classes, but in JavaScript, it is quite different (Objects inherit from other Objects ( certain features; properties and methods of one object can be reused by other Objects).

Example: let's understand inheritance with an example

// Inheritance example -- the function of the constructor method is to initialize the member variables of the class (name and gender)

class Person {

constructor(name, gender) {

this.name = name;

this.gender = gender;

// method to return the string

toString() {

return `Name of Person: ${this.name} and he is a ${this.gender}`

}

}

class Student extends Person {

constructor(name,gender, id) {

// super keyword for calling the above class constructor

super(name,gender);

this.id = id;

}

toString() {

return ${super.toString()}, Student Gender: ${this.gender}, Student Id: ${this.id}; }

}

let student1 = new Student('James', 'Male', 552);

console.log(student1.toString());

In the above example, we define a Person Object with properties; name, gender and method toString() and then we inherit the Person Object in the Student Object and use all the properties and methods of thePerson Object as well as define certain properties and methods for theStudent Object.

Polymorphism

Polymorphism is one of the core concepts of object-oriented programming languages. The Word Poly means many and morph means forms. so polymorphism means many forms. in object-oriented programming, it means various objects can share the same method, but also can override shared methods with a more specific implementation. using a real-life example, a Man can be a Student, a Doctor, etc. So a Man can perform different operations at the same time. Polymorphism can be achieved by method overriding and method** overloading**.

overloading means the same function with different signatures (parameters and return values are referred to as signatures of a function).

In the above code example, The Person and Student objects both have the same method (i.e toString()), this is called Method Overriding. Method Overriding allows a method in a child class to have the same name** (polymorphism) **and method signature as that of a parent class.

Summary

This article has described the basic features of object-oriented programming using JavaScript. In the next article, we'll look at the features JavaScript provides to support object-oriented programming.