Last week we discussed the importance of loosely coupled code, but what does that really mean? Understanding how our code is connected can be tricky, and one tool for reasoning about this connection is called connascence. In this article, we’ll explore five types of static coupling – also known as connascences.

Why Loosely Coupled Code Matters

Coupling in code refers to the degree to which different parts are connected and dependent on each other. While some level of connection is necessary for our code to work, too much coupling can make it difficult to maintain or change individual components without affecting others. Connascence helps us identify these connections so we can manage them effectively.

Connascence comes in two flavors: static and dynamic. Static connascence refers to the connections that can be discovered by simply looking at our code, while dynamic connascence requires running it to reveal its secrets. We’ll focus on the former this week and save the latter for next time.

The Five Types of Static Coupling

There are five distinct ways in which static coupling occurs: Connascence of name, type, location, configuration, and behavior. Each one represents a different level of connection between code components. Recognizing these types can help us write more modular and maintainable software.

The Weakest Form of Coupling

Connascence of name is the weakest form of coupling – it’s also known as loosest or most desirable. This occurs when two things have to agree about the name given to a particular variable, method, or function. For instance:

If we declare a procedure like this: function DoSomething(): void { // Code that does something }, then any call to it must use its exact name – in this case ‘DoSomething’. Changing the name of something requires updating all references elsewhere.

This type of coupling might seem obvious, but limiting ourselves to connascence of name is an admirable goal. It’s a fundamental level that we should strive for whenever possible.

Coupling by Type: A Crucial Connection

Connascence of type occurs when two entities must agree on the data types used within their interactions – such as method parameters or return values. Consider this example:

If a class is declared with methods like so: class SomeClass { processWidget(aWidget: Widget, aAction: WidgetActionType): boolean { // Function logic goes here return false; } }, then any calling code must provide the exact types required by ‘processWidget’ – namely, a widget and an action type.

This level of coupling is stronger than connascence of name but still considered weak or acceptable. It’s necessary for our code to function properly, especially when it comes to interacting with different classes or objects.

Understanding these types can help us create more modular and easier-to-maintain software by identifying areas where we might want to decouple components further.

The next article will delve into the remaining two forms of static coupling – location, configuration, and behavior. These reveal even deeper connections within our code that are crucial for efficient development practices.

Conclusion

Coupling in code is a complex issue, but by recognizing different types of connascence we can better manage how parts interact with each other. Whether it’s through naming conventions or data type requirements, understanding these connections allows us to write more maintainable and scalable software.

Next week will explore the remaining two forms of static coupling – location, configuration, and behavior. These aspects are just as crucial for effective development practices.

Inspired by

• https://www.infoworld.com/article/4038367/five-kinds-of-static-code-coupling.html

Sources

• flickr.com