Software is defined as a set of data and programming code, or instructions, that performs some certain task(s). Engineering is the sophisticated art of developing products with the application of well-defined scientific principles, techniques, and methods. Software engineering is a sub-field of computing science and engineering. It can be simply understood as the application of sound engineering principles for developing efficient, performant, and reliable software products.
Software Engineering Approaches
A software engineering approach refers to a specific way and sequence of applying engineering principles and methods to come up with a fitting software product. There are several software engineering approaches. The most important ones are:
1. SDLC (Software Development Life Cycle)
A life cycle approach to software development has distinct phases. Each of the phases pertains to specific tasks. These phases are:
- Planning and requirements gathering
There are several variants of SDLC. While the phases or tasks are the same, the sequence with which they are employed and the priority assigned to the same vary from one software development methodology to the other.
Some SDLC methodologies are:
- Big Bang
2. Continuous Integration
This approach involves merging all the developer in-progress copies to shared mainline multiple times a day. This approach is getting popular these days owing to the rapidly evolving requirements of software development.
3. Software Prototyping
Software prototyping refers to the process of creating prototypes, in-progress samples, of a software product. It is not a single full software development methodology, albeit a way to try some features in the context of some other complete software development process.
4. Incremental Development
Rather than completing one phase and then moving on to the other as in the SDLC approach, the incremental development approach to software development involves combining linear and iterative software development methodologies. Doing so helps in mitigating the underlying project risks and add more clarity to the software development process. This is immensely useful when the software product under development is too complex. The three primary variants of incremental development are:
- A set of mini versions of the Waterfall model is completed one after the other. Here, all phases of the miniature waterfall model are carried out only for a small part of the software product.
- The overall requirements are defined first and then moved on to the evolutionary, mini-Waterfall development approach involving individual increments.
- First, the Waterfall model is used for completing the development of the software concept, requirement analysis, and designing the software architecture. Next, incremental implementation is made until the final working system is successfully installed on the intended user system(s).
5. RAD (Rapid Application Development)
The Rapid Application Development approach ditches the conventional idea of ahead-of-time planning for iterative development and rapid production of prototypes. Due to the reduced amount of planning, the RAD approach enables faster writing of code as well as easy-to-change requirements, if needs be.
The RAD process begins with the development of preparatory business process models and data models by means of structured techniques. The next step involves verifying requirements and refining the data and business process models using prototyping. These steps are repeated iteratively until a suitable software product is developed.
Software engineering helps in developing reliable, secure, and robust software products by the application of several scientific methods, principles, and techniques. Once a software program is developed completely, i.e., all its requirements are met, it then goes into the maintenance phase. Here, the software receives corrections (bug fixes) and enhancements.
Over the course of a software product, there might be a change in the requirements that it needs to fulfill. At such a time, the need of the hour is software evolution . This simply means to alter and/or upgrade the software in a way to accommodate the new requirements. Several factors might contribute to the change in the original requirements for a software product.
The most important among them are:
- Evolving business conditions and factors.
- Reporting of several software defects.
- Changes made to other systems that rely on the software product.
The internet is playing a key role in the contemporary avatar of software evolution. The incessant growth in web resources and the web allows users to get information about a software product easily.
Furthermore, open-source development paves the way for anyone fascinated about a software product to get their hands on its source code and modify it to suit their liking. This enables rapid, parallel evolution through forks. Software evolution can be:
- Fully manual, based on changes made by software engineers.
- Partially automated, such as by using refactoring tools.
- Fully automated, with autonomous configuration.
Laws of Software Evolution
The laws of software evolution were given by Professor Meir M. Lehman. As such, these are also known as Lehman’s laws of software evolution. He has divided software into 3 categories:
1. S-type (static-type)
Such a software system works in strict accordance with its well-defined specs and has a 100% correct solution. The solution and method for implementing the s-type software are obvious. An s-type software is rarely subjected to changes, and hence, it is the simplest system among the trio of software systems defined by Lehman.
- Chess game
2. P-type (practical-type)
The p-type software features a collection of procedures. Such a software type is defined precisely by what the specified procedures can do. The perfect solution for the underlying problem can be reached theoretically but not practically. Although the specs can be described instantly, the solution isn’t quickly known. p-type systems have a moderate degree of software evolution. Examples:
- Download managers
3. E-type (embedded-type)
When a software program works based on a real-world environment, it is termed an e-type system. In simple words, e-type systems correspond to real-world systems. These systems are a mish-mash of various things.
For e-type systems, complete correctness for specifications isn’t possible. In such systems, we aren’t sure that what we need to have today is the same as what we need to have tomorrow and so on. Hence, the specifications are always changing. e-type software systems have a high degree of software evolution. These are the systems to which Lehman’s laws of software evolution applies to. Examples:
- Online trading software
Following are the 8 laws of software evolution:
- Conservation of Familiarity - In order to successfully apply changes to a system, familiarity with it must be retained. It includes why the system was developed and how the system was developed.
- Continuing Change - A system must continuously adapt to real-world changes. Otherwise, its degree of usefulness will gradually decline.
- Continuing Growth - For a system developed for resolving business problems, the size of implementing the changes increases following the lifestyle changes of the business.
- Feedback Systems - Systems must have multi-loop, multi-level feedback systems to be successfully enhanced or modified.
- Increasing Complexity - The complexity of a system increases when it evolves. Work is required to reduce or maintain it.
- Organizational Stability - The average effective global activity rate for an evolving system is invariant over the entire lifetime of the product.
- Reducing Quality - The quality of a system will continue to decline if there is the absence of a rigorous effort to maintain and adapt it to the evolving operational environment.
- Self-Regulation - System evolution processes are self-regulating with the product distribution, and the process measures close to normal.
There is a range of methods and steps taken during the development of a software system. These are known as software paradigms. Although these can be combined to form several categories, every one of them is contained in one another. We’ll discuss three software paradigms: the software development paradigm, software design paradigm, and the programming paradigm.
1. Software Development Paradigm
This software paradigm involves using engineering concepts, methods, and techniques to develop reliable and robust software products. It involves everything ranging from requirements gathering and software design to testing and maintenance. The important aspects of the software development paradigm are:
- Requirements gathering
2. Software Design Paradigm
This includes the various aspects of designing and developing a software product with the use of engineering procedures. It includes:
3. Programming Paradigm
This software paradigm relates to the actual coding done for developing a software product. The programming paradigm involves:
P.S. - Many aspects of the three types of software paradigms are mutual. This is so because the programming paradigm is a subset of the software design paradigm, which, in turn, is a subset of the software development paradigm.
Why Do We Need Software Engineering?
Software engineering allows software development organizations to produce reliable and robust software fulfilling a wide spectrum of requirements. Today, there is a great rate of change in user requirements as well as the targeted environment, making software engineering more important than ever. Various other reasons that have made software engineering essential when it comes to developing high-quality and reliable software products include:
As software engineering is a systematic approach, it is easier to estimate costs as well as to cut expenses that don’t add to the overall quality of the software systems. If a proper process for software development isn’t adopted, overbudgeting becomes inevitable.
2. Granting Scalability
Software systems that are not created by leveraging scientific methods and techniques suffer from scalability issues. On the other hand, software products developed using software engineering are easier to scale.
3. High Quality
The better the quality of the software development process, the better the quality of the resulting software.
4. Increasing Software Size
It is ok not to use software engineering for small-size software. As the size, however, increases, software engineering must be employed to develop such a software system efficiently.
The aim of software quality is, firstly, to check whether the software has succeeded in fulfilling its requirements, functional and non-functional. And if it has, to what extent? While functional requirements determine the what of software, non-functional requirements pertain to the how an aspect of a software product.
There are several parameters that act as the base for assessing the software quality of a software product. These are called software quality dimensions, and there are several of them. While some software quality dimensions are relevant for a particular software program, others might be important for other types of software products.
Some of the most important software quality dimensions are briefed as follows:
- Accessibility - Measures the extent to which a software product can be used comfortably by a varying number of people. This also includes people with disabilities that necessitate using additional technologies, such as screen magnification and voice recognition.
- Compatibility - This software quality dimension gauges the degree to which a software product can be used across a range of environments and platforms. This includes hardware configuration, operating system, et cetera.
- Efficiency - Gives the measure of a software program’s ability to be used while saving effort, money, time, and other resources.
- Functionality - With this software quality dimension, the extent to which a software product carries out its desired functions is estimated.
- Installability - Gauges the potential of installing a software product in a specified environment.
- Localizability - It measures the ability of a software system to be used in different environments based on cultural preferences, such as languages and time zones.
- Maintainability - This is a software quality dimension that measures the degree of ease to which a software product can be maintained i.e., the addition of new features, fixing bugs, making improvements, doing modifications, and so on.
- Performance - Gives the measure of a software product’s performance when subjected to a particular load.
- Portability - It gives out the measure of the ability of a software product to which it can be transferred from one environment to another.
- Reliability - Measures the extent of certainty to which a software product performs the specified task(s) under specific conditions and within the specified time period without producing any errors or issues.
- Scalability - It is a software quality dimension that measures the ability of a software product to be increased or decreased in terms of performance, size, etc. corresponding to changes in the host environment.
- Security - Used for calculating the ability of a software product to be protected against security issues, such as breaching of privacy, data theft, unauthorized access, et cetera.
- Testability - Gives out the measure of the extent to which a software program can be tested easily and successfully.
- Usability - Measures the degree of easiness with which a software product is used.
Software engineering is an intricate process that involves implementing scientific methods and techniques to develop effective software products. Hopefully, you will now be able to understand and appreciate software engineering better than before. With the growth in software development, the importance of software engineering is only meant to grow.
People are also reading:
Leave a Comment on this Post