IN
All
Articles
Books
Experts
Videos

How to put Engineering into Software Development

Updated on September 13, 2023
4 min read

Like building with LEGO, master the art of modular software design for flexibility and efficiency. Abstract away complexities, prioritize cohesion, and achieve the perfect balance in coupling. Revolutionize software, one elegant module at a time with these tips and tricks.

Software engineering is a multifaceted discipline that encompasses learning and managing complexity. The principles of modularity, abstraction, cohesion, separation of concerns and coupling management play a pivotal role in creating robust, maintainable, and flexible systems. Drawing inspiration from various forms of engineering, Dave Farley took the audience through valuable lessons about compartmentalizing software systems during YOW! London 2022. Just as aeronautical engineers design aircraft with modular components for maintainability and adaptability, software engineers should strive for modular, abstract, and loosely coupled code to enhance flexibility and usability.

The Iterative Approach

One of the core principles of engineering is iteration. The iterative approach involves making incremental improvements based on feedback. This method allows engineers to build something that works and then refine it over time. In the world of software development, this means starting with a functional product and continuously improving it based on user feedback and changing requirements.

Feedback and Control systems

Feedback mechanisms help engineers understand whether they are moving closer to or further from their goals. Feedback can come from various sources, such as user testing, monitoring system performance, or reviewing code quality. Harnessing feedback allows for informed decision-making and continuous improvement.

Incrementalism and Adaptability

Incrementalism involves making changes gradually and steadily. It allows engineers to add new features or components while maintaining a stable foundation. This approach is crucial in software development, where the ability to adapt to evolving requirements is essential. By building incrementally, software engineers can respond to changing user needs and technology advancements more effectively.

Working Experimentally

Engineering is not about always being right, it's about learning from mistakes. Embracing experimentation means being willing to take risks and accepting the possibility of failure. However, experiments are conducted in a controlled environment ensuring that any mistakes are valuable learning experiences.

Empirical Learning

Empiricism is at the heart of engineering. It emphasizes the practical impact of ideas in the real world. Engineers need to understand how their solutions affect the environment and society. In software development, this means focusing on real-world applications and assessing the actual impact of software on users, businesses, and society as a whole.

Managing Complexity

Software systems have become incredibly complex with intricate networks of components and interactions. To tackle this complexity, software engineers must excel at learning and managing it. Here are five principles for effectively managing complexity:

Modularity – the Building Block for Maintainable Software

Modularity involves breaking down a complex system into smaller, self-contained modules. Each module serves a specific purpose, can be maintained separately, and can even be replaced with a more efficient alternative when needed. Even in tightly cohesive systems, like smartphones, there are distinct components performing separate tasks. This modularity allows for flexibility and the ability to compose systems in different ways.

In the past, software development lacked modularity. For example, early printer interactions required developers to write specific code for each printer model. With the introduction of printer drivers and abstractions, the printing process became modular, freeing applications from the intricacies of printer hardware.

Consider a piece of code containing a 361-line if statement. By reorganizing it into smaller, modular functions and introducing clear abstractions, you enhance the code's modularity. This step makes it easier to manage and reuse components, leading to more maintainable software.

Abstraction and Simplifying Complexity

Abstraction is the process of simplifying complex systems by hiding unnecessary details while exposing essential functionalities. Much like modern car steering, where the mechanics are abstracted away behind a steering wheel, software should provide clear and simplified interfaces for interaction.

Abstraction empowers developers to work on specific tasks without concerning themselves with the inner workings of other components. It promotes flexibility and allows for the easy replacement of underlying implementations.

Abstracting code implicates creating clear interfaces and reducing the complexity of interactions. For instance, transforming a detailed database interaction into a high-level "place an order and get a response" instruction simplifies the code, making it more understandable and adaptable.

How Cohesion Keeps Related Things Together

Cohesion refers to the degree to which the elements within a module are related to one another. High cohesion means that elements within a module work closely together to achieve a specific purpose. In software design, keeping related functionalities together enhances maintainability and comprehensibility.

Separation of Concerns

Separation of concerns is the practice of isolating different aspects of a system to focus on one job at a time. This separation simplifies code, making it easier to understand and maintain. A key aspect of this principle is breaking down code into smaller, independent units that handle specific tasks.

Imagine a complex system with multiple interconnected components. Applying separation of concerns involves isolating each component's responsibilities. This approach results in clear, modular code that is easier to manage and update.

Coupling and Managing Dependencies

Coupling refers to the level of dependency between different modules or components in a system. Loose coupling is preferred, as it reduces the interdependencies between modules, making the system more flexible and easier to modify. Managing coupling is essential for maintaining the freedom to change individual parts of a system without causing widespread disruptions.

When making changes to a system, it's crucial to consider the impact on other components. Using adapters or translation layers can help manage coupling by abstracting interactions and providing a buffer for changes. This approach allows for system updates without affecting other parts.

Essentially, by embracing engineering principles such as iteration, feedback, incrementalism, experimentation, and empiricism, software engineers can develop robust solutions that adapt to changing requirements and have a meaningful impact on society. As the complexity of software systems continues to grow, the application of engineering principles becomes even more crucial in delivering successful outcomes.