Search for a command to run...
I’m Tomek, software engineer, working mostly with Ruby on Rails.
I work remotely at Mixlr where every day we deliver live audio to millions of listeners.
After hours, I write, read, and help my wife run theCode.xyz
As anyone who has written code knows, there are a million ways to break it. That's why code testing is so important - it's a way to make sure that your code is doing what it's supposed to, and that it can handle everything that's thrown at it. Unit T...
What is refactoring? Refactoring is the process of improving the design of existing code without changing its functionality. As software developers, we are constantly faced with the need to improve and optimize our code. Whether it's for performance,...
Promises are one of the core features of JavaScript that allows us to write asynchronous code in a more synchronous way. Promises give us a way to handle asynchronous operations in a more linear fashion and make it easier to reason about our code. In...
What is the Pareto Principle? The Pareto Principle, also known as the 80/20 rule, is a powerful tool that can be used to improve efficiency and effectiveness in many different areas of life. The principle is simple: for many events, roughly 80% of th...
There are two main ways to reuse code in object-oriented programming: composition and inheritance. Both have their advantages and disadvantages, and the choice of which to use in a given situation is a design decision.
Composition is the act of combining objects to create a new object. The new object contains references to the other objects and can delegate behavior to them. This is often seen as a has-a relationship. For example, a Person has an Address, so we can say that the person is composed of an address.
Let's take a look at how we could express it in code:
class Address {
constructor(street, city, state) {
this.street = street;
this.city = city;
this.state = state;
}
}
class Person {
constructor(name, address) {
this.name = name;
this.address = address;
}
}
const address = new Address('123 Main St', 'New York', 'NY');
const person = new Person('John Smith', address);
console.log(person.address.street); // 123 Main St
In this example, Person is composed of its own properties and Address that is being passed to the constructor.
The advantage of composition is that it is very flexible. We can change the behavior of our Person by changing the Address object it uses (e.g add postcode to printed value). We can also create different types of Addresses, and our Person class doesn’t need to know anything about them. This also makes our code more reusable as we can use individual components in different contexts.
There are also some disadvantages to using composition in programming. First, it can require more effort to design and implement a compositional system than a monolithic one. It can also lead to code that is more difficult to debug and optimize, as the dependencies between components can be complex.
Inheritance is the act of creating a new class that is a specialized version of an existing class. The new class inherits the behavior of the existing class, and can also add new behavior of its own. This is often seen as an is-a relationship. For example, a Dog is a type of Animal.
Code example for inheritance:
class Animal {
constructor(name) {
this.name = name;
}
}
class Dog extends Animal {
constructor(name, breed) {
super(name);
this.breed = breed;
}
}
const dog = new Dog('Buddy', 'Golden Retriever');
console.log(dog.name); // Buddy
console.log(dog.breed); // Golden Retriever
In the example above, the Dog class is derived from the Animal class. The Dog class inherits the name property from the Animal class.
The advantage of inheritance is that it can be used to model real-world relationships. Our Dog is a type of Animal, so it makes sense that it would inherit from the Animal class. It allows you to reuse code from a parent class in a child class. This can save you a lot of time and effort when you are developing a new class. Inheritance can also make your code more flexible and extensible. If you need to add a new method to a child class, you can simply override the parent class's method.
However, inheritance can also make your code more complex and difficult to understand. If a child class inherits from multiple parent classes, it can be hard to keep track of which methods are inherited from which class. This can make your code more difficult to maintain and debug. Additionally, inheritance can sometimes lead to unexpected behavior. If a child class inherits a method from a parent class that has been overridden in the child class, the child class's method will be called instead of the parent class's method.
As usual in programming - it depends.
In general, you should use inheritance when you have a clear, linear relationship between the child and parent classes. For example, if you have a class hierarchy where each class adds a new layer of functionality on top of the previous one, inheritance makes sense.
Composition, on the other hand, is more flexible. It allows you to build objects from other objects, without having to follow a strict linear hierarchy. This can be useful when you want to reuse existing code or when the relationship between the child and parent classes is more complex.
There are pros and cons to both inheritance and composition, and the best way to choose between them is to understand when each one is appropriate.