Hey, welcome to a brand new series on Xylophone. In this series, we would get a broad but effective overview of the process of software engineering and how it affects our work as developers. Hope you enjoy it 😋.
Software engineering is the study of how computer programs are made and how to make those methods more efficient and reliable. It is also the systematic approach to building software as a team using various ways. In other words, these methods can vary.
Even though programming is the creation of software, software engineering goes beyond programming. Software engineering involves the lifecycle of how software is made, how much quality it contains, and how it is even deployed and maintained. So it is safe to say that programming is part of software engineering.
The reason why emphasis is put on the approach to creating is that it involves a lot of people working together to build high-quality robust systems. As a result, these processes have to be flexible, adaptable, well-communicated and documented.
An engineering approach to building software is necessary because if it is not done through tried and tested team-oriented strategies, the software won't stand the test of time and cannot be maintained to sustain the basic quality of life. Think about the software that helps airplanes fly being made haphazardly, the result?
The reason why large, successful companies excel at building great products at scale is that they either follow laid-down software creation techniques combined with amazing tools or they invent theirs.
Short Software History
Want to know why we use engineering to develop software? Here's why...
In the not-so-distant past, hardware dominated the scenes of technology. For example, massive computers that did not have much capacity dominated the tech industry.
But along the way, software started becoming more important since it was more malleable and adaptable, and it became higher in demand. However, this demand for more software was faced with two challenges.
No! a lack of developers was not a problem. First of all, to build software you needed a huge team effort, and since teams didn't have a laid-down approach to building software, teams frequently went into chaos, flunking deadlines and doing awful.
In addition, this hampered developer productivity. What appeared was an embarrassing gap between what was needed and what was created.
A study done on the software industry showed that for an average of $ 7 million spent on software products, $ 5 million was of it was wasted on unusable or user-unfriendly software.
This dilemma led to the NATO Engineering Conference of 1968 to discuss how best to make software development a more profitable and sustainable venture. The conference gave birth to software production as an engineering discipline.
The Way Forward
The approach agreed on was to break down software via systematic and formal approaches. Systematic in the sense that software is broken down into repeatable and adaptable methods. Formal because any method has to be approved and agreed upon by a team.
In the realm of software production, numerous processes can differ in implementation but are similar in principles. Some mainstream software processes that we could look at in this series are:
Waterfall - involves developing software completely before releasing.
Evolutionary prototyping - involves modifying software through linear feedback.
Unified Software Process
Agile - a more flexible approach to building software in stages based on feedback and scope changes.
Despite the processes and principles applied, software development generally goes through the following phases.
Requirements engineering - Requires talking to customers and stakeholders to see what kind of software is needed and the features and problems to be solved.
Design - Details the software process to be used, milestones to be met, tools needed, and team organization.
Implementation - Writing code and bringing design to life.
Validation and Verification - Testing code to see if they work as expected.
Maintenance - Responding to customers to see how the software works in real-time, adding and removing features, debugging, and making sure it keeps working after it is deployed.
Tools of the Trade
Tools help improve productivity and efficiency. To be effective on any software engineering team, you must develop a good understanding of the tools you want to work with. Tools help maintain an organized approach to coping with an ever-increasing software size and complexity. Examples of how tools have helped software development:
Development: From punch cards to Integrated Development Environments(IDEs).
Debugging: Imagine having to read punch cards one after the other. Now we have debugging tools, some built into IDEs.
Teamwork: Tools that aid in Version control like Git help teams track changes to the software products.
Software engineering is the systematic approach to software development. It involves a lot, but the most basic thing is to understand why we need software engineering.
In this article, we have looked at an overview of the what and why of software engineering, in the coming articles of this series, we would look into the how of software engineering.
Stay tuned, and happy engineering 🏗.