System and Application Software are Obsolete! Sooner or later. Do you agree?

Note: We will address several questions related to this issue.

The Next Question: What is an alternative?

A fuse is a standard device found in any electrical system. Examples include a home, an automobile, a power tool, and many more. The fuse is common and comes in a relatively small variant of the required application and the amperage or load the fuse is expected to carry. For a particular application and load, fuses are typically interchangeable. If the FUSE fails, the circuit is open and will not conduct electricity. Plug in a new fuse, and the circuit is complete and resumes operation.

How many software programs are there in the world? Joseph Newcomer, Former Chief Software Architect (1987–2010) and Author have 14.7K replies and 3.7M answer views. Billions. Probably not trillions. But certainly, more than hundreds of millions. Some are one line long. Some are a hundred million lines long. And everything in between.

These software programs have insidious problems, such as:

• Lack of reliability.

• Lack of stability/unstable

• Excessively costly (billions) to build, purchase, and operate.

• Brittle

• Software projects continue to fail at an alarming rate.

This data immediately prompts two questions:

1. Is it a problem with the project methodology or how organizations administer software engineering projects?

2. Is it a problem with the quality of software engineers available within the marketplace?

There is plenty of blame; however, these are not the root causes of the failings of contemporary software applications and software products.

The problems are manifold:

1. Every software solution must be targeted for an operating platform, and invariably, a software engineer or team of engineers must build out not only the functional capabilities of the software but also must deliver the plumbing of the software itself. The multitude of questions must be addressed at the commencement of a software engineering project:

a. How does information move within the application?

b. What algorithms and patterns will be used, and which will be avoided?

c. How do different components interact?

d. Is there a need for a message bus?

e. Will the application employ services?

f. How is information stored, retrieved, rendered, reported, and transmitted to consumers of other details?

g. What are the performance requirements of the application?

h. What is the mechanism for recovering from routine application failures? Or catastrophic failures?

i. How do we prevent the application from suffering from design constraints that effectively lock the application from evolving to meet changing requirements over time?

j. How can we prepare for inevitable changes in requirements and ensure the integrity of the application across many design changes?

Functional and non-functional requirements must be vetted, and a solution that satisfies these questions and many more is needed. Plus, there needs to be a holistic methodology for efficiently documenting a software application's functional and non-functional requirements, neither at its inception nor throughout its lifecycle. Approaches to writing these requirements are as diverse as the number of software architectures today. For example, FUSE employs a holistic approach to software architecture; software design and applications are simply artifacts of the architecture and design.

We could spend hundreds of pages analyzing the many weaknesses of contemporary software engineering practice, but the purpose of our research is different. The compendium of research into the failures of modern software methods is vast, and each new methodology and technique introduced addresses point solutions to only specific problems and weaknesses in software engineering. Unfortunately, no unified and holistic software approach addresses the issues with prior methods.

One may ask, "How so?" or, "How did we get into this desperate situation?

Unfortunately, this specific line of questioning perpetuates the problem and keeps the software engineering community on the wrong track. The question pre-supposes that minor tweaks to how software is engineered are adequate to "fix" the problems that genius software engineers have bequeathed to our world. We cannot just tweak things as has been tried before. We cannot replace zero methodologies with waterfalls to fix how projects are managed. We need to replace waterfall with agile and get a better outcome.

We have made meaningful advances in Software Engineering in the past 50 years. Waterfall methodology was an essential improvement over the diverse approaches used before Waterfall methods were introduced. Object-Oriented Analysis, which led to Object-Oriented Design and Object-Oriented programming, was a similarly crucial step forward. This object orientation motivated the Gang of Four to introduce their notion of systems of patterns, ushering the concepts of patterns into the contemporary world of software engineering. So pervasive was this concept and so widely adopted that it is unlikely to find any software undertaking that does not employ the idea of patterns today.

However, if this is the case, why are the artifacts of software not improving markedly? Why do we still have failures with alarming frequency across all software projects? Shouldn't we expect more from software projects that employ the correct techniques and methods? However, again, this question needs to be corrected. It assumes that we can adjust a small error here or there and solve the fundamental and conceptual problems of software architecture, software design, and software development. There is little more to be done.

More Mohamed Fayad's questions See All
Similar questions and discussions