What is Software Engineering?

What is Software Engineering?

Software Engineering indicates several things, but to fully comprehend it, you must understand each component of the phrase. It comprises two words, namely Software + Engineering = Software Engineering.

What is Software?

Software is more than simply program code. A program is a piece of executable code that performs some kind of processing. Software is defined as a collection of executable programming code, accompanying libraries, and documentation. When software is created to meet a specific need, it is referred to as a software product.

What is Engineering?

Engineering is the process of designing and constructing something (such as machines, structures, software, and so on) by employing best practices, concepts, and methodologies. An engineer, designs, builds, and analyses software products using information and standards (principles).

• Software engineering is a discipline of engineering concerned with the creation of software products using well-defined scientific concepts, methodologies, and procedures. The result of software engineering is a dependable and efficient software product.

IEEE Definition of Software Engineering

IEEE defines software engineering as:

1. The application of a systematic, disciplined, quantifiable approach to software development, operation, and maintenance; that is, the application of engineering to software.
2. The study of approaches as in the above statement.

Fritz Bauer's Definition of Software Engineering

Fritz Bauer, a German computer scientist, defines software engineering as:

• Software engineering is the establishment and use of sound engineering principles to obtain economically reliable software that works efficiently on real machines.

Why Software Engineering?

Early on, software development was relatively basic; therefore, software development was simple; nevertheless, as technology advanced, software became more complicated, and projects became more difficult. A development team was now required to make thorough plans and designs, test them, create intuitive user interfaces, and integrate everything into a system.

What was the Software Crisis?

• Many software development projects failed throughout the late 1960s.
• Many software projects went over budget. The result was faulty software that was costly to maintain.
• A large code base was difficult and expensive to maintain.
• Many pieces of software need to be more capable of meeting the customer's ever-increasing demands.
• The complexity of software projects increased as hardware capability improved.
• Demand for new software grew faster than the ability to create new software.

The Solution

The challenges were solved by changing a disorganized coding effort into a software engineering discipline. The engineering models aided businesses in streamlining operations and delivering software that met customer expectations.

• In the late 1970s, software engineering principles were widely used.
• The automation of the software engineering process and the emergence of (CASE) Computer-Aided Software Engineering occurred in the 1980s.
• In the 1990s, there was a greater emphasis on the management components of projects, such as quality standards and processes such as ISO 9001.

Evolution of Software Engineering

Software evolution refers to creating a software product using software engineering principles and practices. This comprises the early development of software, as well as its maintenance and upgrades until the intended software product is created and meets the expected requirements.

The process of evolution begins with the gathering of requirements. Following that, developers produce a prototype of the proposed program and exhibit it to users to gather feedback early in the software product development process. Users suggest changes, which cause several subsequent product updates and maintenance. This method returns to the original software until the desired software is obtained.

Even after the user obtains the desired software, evolving technology and requirements require the software product to alter accordingly. Recreating software from scratch and working one-on-one with requirements is close to impossible. The only realistic and cost-effective solution is to update existing software to meet the most recent standards.

Software Evolution Laws

In software engineering, the laws of software evolution refer to a set of regulations proposed by Lehman and Belady concerning software evolution beginning in 1974. The rules define a balance between factors that propel discoveries on the one hand and forces that restrict growth on the other. The laws have been changed and extended multiple times during the last few decades.

Lehman qualified the use of such regulations in his 1980 article by differentiating three types of software:

• An S-program is written to a precise specification of what that program can perform.
• A P-program is developed to carry out specific procedures that completely define what the program is capable of.
• An E-program is developed to execute some real-world task; how it should behave is heavily dependent on the environment in which it runs, and such a program must adapt to changing requirements and situations in that environment.

The laws apply only to the last category of systems. Eight laws were formulated, they are:

• Continuing Change:
  An E-type system must be constantly updated, or it will gradually become unsatisfactory.
• Increasing Complexity:
  The complexity of an E-type system grows as it evolves unless efforts are made to maintain or reduce it.
• Self Regulation:
  The distribution of product and process metrics is close to normal in E-type system evolution processes; they are self-regulating.
• Conservation of Organisational Stability:
  In an evolving E-type system, the average effective global activity rate remains constant across the product's lifetime.
• Conservation of Familiarity:
  To ensure the satisfactory evolution of an E-type system, everyone associated with it, such as developers, sales employees, and users, must maintain mastery of its content and behavior. Excessive development erodes that mastery. As a result, the average incremental growth remains constant as the system evolves.
• Continuing Growth:
  To ensure user contentment during the life of an E-type system, its functional content must be constantly increased.
• Declining Quality:
  Unless an E-type system is consistently maintained and adapted to operating environment changes, its quality will appear to be diminishing.
• Feedback System:
  E-type evolution processes are multi-level, multi-loop, multi-agent feedback systems that must be treated as such if considerable progress over any plausible baseline is to be achieved.

Characteristics of Good Software

The factors are divided into three categories:

• Operational
• Transitional
• Maintenance

Operational Characteristics

These factors are related to the software's outside quality. Some of them are:

• Reliability: means that the software should not fail during execution and be free of flaws.
• Correctness: The software should match all of the customer's needs.
• Integrity: The software should not have any unintended consequences.
• Efficiency: The software must use storage space and time wisely.
• Usability: The program should be simple enough for anyone to use.
• Security: The software should protect the data from external threats.
• Safety: The software developed should not be detrimental to the environment or life.

Transitional Characteristics

When moving software from one platform to another, the elements of these characteristics have a crucial impact. Some of these elements are:

• Interoperability:
  software can use information transparently.
• Reusability:
  It is reusable if we can use the program for a different purpose after making minor changes to the code.
• Portability:
  It is demonstrated when software can perform the same functions in multiple settings and platforms.

Maintenance Characteristics

Maintenance characteristics deal with the software's internal role and inform us about its ability to sustain itself in a changing environment.

• Maintainability:
  The software should be simple for the development team to maintain.
• Flexibility:
  The software should be adaptable to changes.
• Extensibility:
  There should be no difficulty in growing the number of functions performed by the software.
• Testability:
  The software should be simple to test.
• Modularity:
  A software product has high modularity if it can be separated into separate independent sections and modified and tested independently.
• Scalability:
  It entails the software's capacity to be easily upgraded.

Software Paradigm

Software paradigms are the approaches and stages used in the development of software. Many approaches have been proposed and are in use today, and we need to see where these paradigms stand in software engineering. These can be divided into several categories, albeit each is contained inside the others:

Software Development Paradigm

It applies all engineering concepts to software development. It covers numerous research and demand gathering that aid in the development of the software product. It is made up of:

• Collecting requirements
• Software design
• Programming

Software Design Paradigm

This paradigm is a part of Software Development and includes:

• Design
• Maintenance
• Programming

Programming Paradigm

This paradigm is intimately associated with the programming part of software development. This includes:

• Coding
• Testing
• Integration

Additional Resources

1. Software Engineer vs Software Developer