Modern Software Development Reader (1) - Modernization and Learning from the Past

Exploring the modernization of future software development
Next time: Is waterfall becoming obsolete?

Insights into the modernization of software development

"Software development is modernized with the latest technology"
"The fusion of the latest technology and traditional technology is the essence of modernization"

These are the words of the two people in the illustration, and they represent the new way of software development, the insights of modernization. In this reader series, we will look at the modernization of software development as modern software development.

Definition of modernization and the difference from migration

Modernization is renewing the entire target with modern technology. On the other hand, migration is renewing a part of the target with modern technology. In other words, the difference between the two is whether the target is the whole or a part. Note that as a definition of modernization, there is also a definition that the whole is reconstructed with the latest technology, but for this difference, please refer to the latest technology and modern technology items below.

(Reference) Latest technology, modern technology, and conventional technology (legacy technology)

Latest technology is technology that has newly emerged within the last few years. Examples include generative AI and no-code development. Also,
modern technology includes not only the latest technology but also technology that appeared more than a few years ago and is useful technology that has not been replaced even in modern times by other technologies. For example, Agile software development is technology from over 20 years ago and is not the latest technology, but it is modern technology that is still perfectly valid today. Waterfall development is also a technology that is still valid today, although there are arguments about it. On the other hand,
conventional technology (legacy technology) is past technology and is technology that has become obsolete in modern times. However, due to past entanglements, there are technologies that remain in some parts even today. Examples include full-scratch development and unstructured programming. Some people define waterfall development as an obsolete legacy technology.

Modernization technology insight: "The right person in the right place"

When using modernization to renew the entire target, modern technology does not have to be just the latest technology. Therefore, selecting the right technology for the right place from among modern technologies to renew the entire target is the insight of modernization. In other words,
modernization is the selection of technology for the right place is important.

Modernization policy insight: "Negative example and learning from the past"

We select the right technology for the right place as the technology for modernization. The insights that are useful at this time are the insights of "negative example" and "learning from the past". The insight is to use the bad parts of conventional technology as a negative example to modernize with modern technology, and to learn from conventional technology with the idea of learning from the past and fuse it with modern technology to modernize. We will look at these insights.

Negative example - Learn from others' mistakes

Why is it necessary to modernize software development? It is because conventional software development is bad. Using that as a negative example, we modernize with modern technology. Here, we will look at bad patterns of conventional technology, anti-patterns.

Examples of negative examples

(1) Spaghetti programming

Spaghetti programming is programming that creates unstructured program code. The main cause of this unstructured code lies in the destruction of the repetition structure by branch instructions. Program code that destroys the repetition structure includes the following: (a) goto statements (including throw statements, etc.) for exception handling, etc. (b) Exceptional escape from repetition by break statements or continue statements during repetition (c) Intersecting branch instructions. For example, a program that frequently uses the above instructions in Java becomes

spaghetti code

.

For this spaghetti programming, it is necessary to adopt "structured programming" which programs with only a small number of structures (e.g., sequential, branch, repetition structures). This is modern technology.

(2) Cowboy coding

Cowboy coding is when each programmer programs as they please, like a cowboy running through the wilderness alone. In Agile software development, there is a tendency to become this cowboy coding because of the code-first approach. To prevent this, it is necessary to establish

coding standards and naming conventions included in them, and create standard rules to bind programmers so that each programmer does not program as they please. This becomes modern technology.

(3) Vibe Coding

Vibe coding is giving instructions for program creation to generative AI in natural language to generate and build code. The term 'vibe' comes from music terminology, referring to creating music based on a 'vibe' or feel, and it implies programming based solely on that feeling.
Toy programs for specific purposes can be created this way, but it is difficult to use vibe coding (with current AI) for large-scale, general-purpose practical programs.

To generate general-purpose programs with AI, it is necessary to solve the symbol grounding problem in AI. The symbol grounding problem is the issue of connecting terms (symbols) to their meanings in the real world. This could be called the eternal challenge of Artificial General Intelligence (AGI). If this problem is not solved, vibe coding will remain an anti-pattern that is only useful for creating toy programs for specific purposes.

Learning from the Past - Revisiting Traditional Technologies and Fusing Them with the Latest Technologies

Among modern technologies other than the latest ones, there are many that will remain useful in the future. Why these technologies have not been replaced by newer ones and why they still survive today are important perspectives, and it is crucial to consider how to fuse them with the next generation of the latest technologies.
Furthermore, it is also important to re-examine traditional technologies that have fallen out of use to understand why they were popular at the time and why they faded away; this provides hints, including lessons learned from failures, when considering the latest technologies.
Connecting these key points to new technologies and fusing them is truly the concept of "learning from the past".

Examples of Learning from the Past

(1) Functional Programming

Functional programming is programming with functions that have no side effects, much like mathematical functions. Because functional programming has no side effects, you can freely combine programs to create new ones.

For this reason, functional programming is a fundamental technique for programming with generative AI. Also, functional programming tends to allow for programming with minimal structures (sequence, branching, recursive structures), similar to structured programming.

In this way, the concepts of functional programming will be applied to new programming paradigms.

(2) Quantitative Quality Analysis

IPA publishes the Software Development Analysis Data Collection, which serves as a data set for quantitative quality analysis. In this analysis data collection, traditional technologies such as SLOC (Source Lines Of Code) and FP (Function Point) in waterfall development are used as measures of software scale.

On the other hand, modern development methods such as agile development, no-code/low-code development, and vibe coding will also likely involve analyses that integrate with the aforementioned quantitative quality analysis.

Summary - Modernization and Learning from the Past

In this issue, as the introduction to the first part of the Modern Software Development Reader, I introduced the guideline "Modernization and Learning from the Past". Modernization is not about discarding the past, nor is it about continuing exactly as in the past; it is about modernizing by fusing traditional technologies with modern technologies based on the concept of learning from the past.

As an introduction, I have presented abstract guidelines and simple examples, but from the next issue onwards, we will look at concrete modern software development. Modernization is in your hands.

(References)

IPA
IPA Software Development Analysis Data Collection (Quantitative Quality Analysis)
IPA DXIT Forum (Information related to modern software development)
IPA Software Development Survey (Modern software development survey)

NOTE Magazine
Rules of Programming
IPA Software Development Analysis Data Collection Textbook
Introduction to Functional Programming
Agile Development Analysis - Rules of Agile Development
Software Development Manga FAQ
Manga Reader: Introduction to Software Analysis
IPA Software Survey and Analysis