Software Engineering
Learning Objectives
- You know the term software engineering and you know of challenges related to software engineering.
Defining software engineering
The first uses of the term software engineering can be traced to the 1960s, where it was first used to highlight a service that a company provided. Then, it was used to outline an aspect of the engineering profession, and later at a NATO conference, it was used to highlight the importance of building software in contrast to engineering hardware.
Nowadays, the term has multiple definitions. As an example, the ISO/IEC/IEEE Systems and Software Engineering Vocabulary provides two definitions for software engineering, which are as follows:
-
“systematic application of scientific and technological knowledge, methods, and experience to the design, implementation, testing, and documentation of software”
-
“application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software; that is, the application of engineering to software”
Merging these definitions, software engineering could be viewed as a systematic, disciplined, and quantifiable approach to applying scientific and technological knowledge, methods and experience to the design, implementation, testing, documentation, operation, and maintenance of software.
Like the definitions, software engineering has evolved over the years. The evolution has stemmed from the evolution of algorithms, programming languages and tools, software development methodologies and processes, the growing complexity of software systems, and the improvements in the skills of software engineers.
Almost since the emergence of the term, software engineering has also been associated with challenges related to it. The term software crisis was coined almost at the same time with the term software engineering, in the 1960s, to describe the challenges related to building software. The challenges included the increasing complexity of software systems, the difficulty of managing software projects, and the difficulty of building software that meets the needs of the users.
Many of these issues are still relevant today, especially when building larger systems. The addition of large language models to the process does not necessarily mitigate such challenges. As an example, as large language models are good at generating content, they can be used to generate content that is not necessary (or matching the needs of the user), leading to bloated codebases that are harder to maintain.
An additional twist comes from the use of software as the users may not always use the systems in the intended way, as described in the following XKCD comic, Fig. 1.
Source: https://xkcd.com/2021/
Contemporary software engineering
Contemporary software engineering is more and more about teamwork, building software together with others, and nurturing the growth of skills (and software) of the team over time. That is, software engineering is not just about building software, but also about building software in a way that is understandable to others.
At the same time, with the increasing use of libraries and frameworks, software engineering is also more and more about software reuse. Large language models have been trained with text and code written by others, and thus they can also generate text and code similar to the code they have been trained with — that is, they could be seen as a tool for increasing software reuse.
However, the software reuse aspect of large language models extends only to the code that has been written before. Large language models do not have information beyond the code they have been trained with or that is provided as a part of the prompt. This means that when a new software library is released, or the API of an existing library is updated, the models would very likely produce code using deprecated libraries — in such a case, the usefulness of AI assistants can be low.
In the broader context of contemporary software engineering, the reuse of software can also lead to problems. As libraries and frameworks can build on top of other libraries and frameworks, it is possible that some parts of the chain are neglected.
The following XKCD comic, Fig. 2, illustrates the problem of modern software engineering, where the software is built on top of other software, which is built on top of other software, and so on.
Source: https://xkcd.com/2347/
Unfortunately, the above comic is not an exaggeration. Some open source software developers have become frustrated at the situation of maintaining software effectively for free, and there are examples of developers intentionally breaking software to make a point.
As an example of intentional breaking of software, the maintainer of a popular library colors, which is downloaded millions of times each week, added an infinite loop to the package. As a result, effectively all applications that relied on the library and that were updated to match the newest version of the library stopped working.