Code Reuse : Why it matters

Code Reuse

Code reuse is the use of existing software to create new software.

We leverage code reuse to help solve either repetitive or complex tasks so that we are not repeating ourselves, we reduce errors, and we achieve more complex goals.

Code Reuse Trade-offs

On the plus side, we reuse code because we trust that it does its job well, so we don't have to test it all over again. It saves time and effort since the code has already been proven to work.

However, there's a downside too. Reusing code can mean adding dependencies that make our project bigger, more complex, and potentially riskier. It's like needing just a spoon but bringing along the whole kitchen.

Code Reuse Constructs

Code reuse can be performed using several structural techniques

Method Call

We can wrap functional logic within a method within our own code base. We can make calls to this method from the places that require that task performed.

Classes

We can capture state and functional abstractions in a set of classes. This adds some modularity to related reusable method calls.

Interfaces

Abstract interfaces can be defined as placeholders for things needed but supplied elsewhere. This could be because of different options provided or details being supplied elsewhere.

Modules

Reusable constructs can be packaged into separate physical modules so that they can be flexibly used or not used by our application.

Composition

Composition involves building complex types by combining objects of other types rather than inheriting from them. It promotes code reuse by composing objects with the required functionality.

Abstract Classes

Abstract classes provide a base class that cannot be instantiated on its own but can define common methods and properties that other classes can inherit. They may contain both abstract methods (without an implementation) and concrete methods (with an implementation).

Generics

Generics allow you to create classes, interfaces, and methods that can operate on any specified data type while providing type safety. This promotes code reuse by enabling generic programming.

Utility Classes

Utility classes contain static methods and fields that are reusable across different parts of the application. They are commonly used for reusable code like mathematical functions, string manipulations, or general-purpose utilities.

Design Patterns

Design patterns like Singleton, Factory, Decorator, Strategy, etc., help in designing reusable, maintainable, and scalable code.

Code Reuse Styles

There are two basic styles of code reuse.

1. Libraries: Libraries are modules of reusable code that are invoked on-demand by our code base. our code is in total control of the library call flow. Examples: JSON or XML parser
2. Frameworks: Frameworks are different from callable libraries — in that they provide some level of control or orchestration. Our code base is under the control of the framework. This is called "Inversion of Control".