Software Engineering

Software is the intangible essence that allows a CPU to deliver value, like thoughts in the brain. It is extremely important to learn how to create, update, and even destroy these elements to ensure excellent performance, both in the CPU and in the brain.

With that being said, let’s break the words Software Engineering in two part:

– Software is a container of instructions that accomplish specific operations in a virtual environment. This container can work alone or be interconnected with other containers, creating a communication ecosystem within an operating system, which is software within software.

– Engineering is the process of designing, building, testing, maintaining, and improving something that serves a particular purpose and provides cost-effective solutions to problems

While everyone can build software, not everyone can build excellent, valuable, and adaptable software. That’s why we need a method, a strategy, a knowledge base from others (accumulated experience), and of course, innovative ways to see the world, adapt, and convert ideas into value and this is exactly what Software Engineering is.

Lets see some principles for developing Software
*some principles could overlap them selves

A good software engineering process involve different good practices

Modularity: Is a good practice to encapsulate the data of the object and its functions, and treat this container as a module (sometimes referred to as packages).
Encapsulation: Is the process of creating a black box around the logic of an object to hide its functionality to external componentes. It keeps the system and each element secure.
Interface vs Implementation: Keeping loose coupling is the way to prevent minor changes in one element from necessitating unexpected changes in others. In this context, an interface acts like a door to our black box, and the implementation is what happens inside the house.
Information hiding: The best way to keep the system secure in this concurrent environemnt is just returning simple information and hiding the work-how of each object to external objects.
Black box: Each object treat each object as a black box, just put an input and receive a simple output without needing to know how that task was done.

It’s not just about how machines manage data and produce a return, but about how we can ensure every system possesses these three attributes: security, speed, and scalability.

Most software applications tend to grow, and it is not just the coding but also the maintenance of the code that is important. To keep the structure maintainable and separated, the module pattern allows you to split your code into smaller, reusable pieces and package them in a container called a ‘module‘.

//According to Adam Smith, the more specific and simple task a human has to do, the more effective and agile it will become. It’s the same with the software.

The module will control the functions, operations, and privacy of each element within itself (encapsulation) and will act as a proxy for them with other modules in the system.

Approaches for creating software

As with many arts, sciences and works, the design of software has grown according to the necessities and the new discoveries. It also includes the technology available in certain times and of course the hardware capacities. 

We have faced a lot of different scenarios and have created different methods to accomplish our goals. In that try, there are a couple of models (Software Development Lifecycle Models) that highlight into all this ecosystem.

The Waterfall Model

This is one of the most classic models to create software. It just establishes all the instruments, ingredients and devices we need to create from the beginning.

• Requirements – This initial phase determines exactly what we are going to develop. It’s like understanding the thoughts we need to form before speaking them.
• Design – In this phase, we determine how we are going to build the product. This is often broken down into two parts:
  • Preliminary Design identifies the major building blocks of the project and decides on any Commercial Off-The-Shelf (COTS) components to purchase instead of developing internally.
  • Detailed Design provides a thorough breakdown of modules along with the external interface of those modules. It is detailed enough to allow individual programmers to know exactly what their coding assignments are.
• Coding – Individual programmers code their modules and carry out Unit Testing to ensure that their part of the project works correctly. This step translates the thought-out design into executable instructions.
• Testing / Integration – The modules developed by individual programmers are combined and tested together. This integration testing ensures that the entire system works cohesively in a stable version.
• Release – The product is released and is made available for use by end-users
• Maintenance – The product is maintained, ensuring that it continues to function effectively and adapting to any new requirements or issues that arise.

Key Features of the Waterfall Model include:

• Starting with a clear definition of what we are building, ensuring everyone understands the goals before moving to implementation.
• Conducting thorough validation and verification at each phase to confirm accuracy and completeness.
• Prioritizing meticulous design and comprehensive documentation to guide development and maintain clarity.
• Ensuring that the focus is on accurate requirements and design from the beginning to prevent costly errors later.
• Encouraging continuous review and adaptation, allowing for incremental improvements even within a structured approach.

But … Doesnt the world change everyday? What we thought we needed before could be completely different from what we need now? In contrast to the assumptions underlying the waterfall model, developers have learnt that is often impossible to define all requirements upfront. Using the Waterfall model could lead to the creation of extensive documentation before any coding begins, which could become obsolete before it’s even used.

Agile Development is a methodology that doesn’t specify exactly how software should be developed, but it outlines principles for doing so and identifies what is valuable for the process, emphasizing flexibility, collaboration, and rapid delivery of working software.

Key points:

– Individuals and interactions over processes and tools
– Working software over comprehensive documentation
– Customer collaboration over contract negotiation
– Responding to change over following a plan
– Iterative and incremental development

* They also came up with a list of 12 principles they thought should be followed in software development. You can see the manifesto and principles here:

http://agilemanifesto.org/

Concluding

Software development is not a static field; it encompasses various areas that must be thoroughly developed. Great and insightful authors have contributed their extensive experience and provided us with a robust set of tools to achieve our software objectives. There isn’t a master solution for every aspect of the software development cycle, and, fortunately (for the sake of discovering new knowledge), it is essential to be familiar with all these aspects to determine which approach best suits our requirements, considering that each project is unique and will need different methods to succeed.

A rule of thumb: Always focus on the big picture first and then proceed incrementally, rather than making small, disconnected increments that do not align with the core business or its requirements. Aim to use both Waterfall and Agile methodologies simultaneously, adopting what suits best from each one according to your needs (easier said than done, but that’s how it works best).

Hope you see why this journey is too exciting and we are just scratching the surface. Let’s continue learning and building on what has been done, understanding what must be avoided, and of course, discovering new ideas to contribute to one of the most beautiful and powerful engineering disciplines known as Software Engineering.

Thanks for reading.

A.nd.I 👋