What is Software Engineering?
Computer software has become a driving force in today world. It is the core engine that drives business decision – making. It serves as the basis for modern scientific investigation and engineering problem-solving. It is a key factor that differentiates modern products and services. It is embedded in systems of all kinds like
- Transportation (App-based, inhouse transportation systems, online booking centers )
- Medical (App-based)
- Telecommunications (App-based, automatic billing etc)
- Military(intelligence gathering, decision making, simulations etc)
- Industrial processes(ERP systems, demand-supply chain, SCM, feedback etc)
- Entertainment(App-based, on-demand, ticket reservation system )
- Office products
The list is almost endless. Software is virtually inescapable in the modern world. It affects nearly every aspect of our lives and has become pervasive in our commerce, our culture, and our everyday activities.
Definition of software
The technology consists of Instructions (computer programs) which provide the desired functionality, work and performance when executed. Data structures, which allow the programs to manipulate information appropriately. Documents explaining how the services are run and used Can, be built for a particular company or for a general market.
How software is important in our lives?
Today software is everywhere, everything runs on software, your mobile, TV, computer. You order an ambulance and it is about 15 minutes away from your door, how do you think this is possible? Only without apps is this possible, NO. Software not only helps us in our leisure time but is relevant in numerous ways as well.
Use Quora as an example. Where would you drop your questions if there were no such sites as Quora or Google? In addition, how sans software would such sites exist? It supports us with our questions. Links us to relatives. Spreads and what not post for support during the crisis.
In addition, all of this much easier than the days of old. Where can you live in such an appliance-oriented world without such basic yet essential software, which is very useful in everyday life? Therefore, I think that this is enough to make you understand the importance of software in our daily lives.
- The main property is that the Software is engineered by making plans, not manufactured
- The software does not wear out, it means that it can be used at any time perfectly but it may need some updates and things to add.
- Software is custom-built according to user demand.
In this picture, it is showing that software may deteriorate but it may not wear out it means that with the passage of time we need to update it but the previous version of the same software is stabled like windows 98 or XP.
- System software
- Application software
- Engineering/scientific software
- Embedded software
- Product-line software
- WebApps (Web applications)
- AI software
- Ubiquitous computing—wireless networks
- Netsourcing—the Web as a computing engine
- Open source—“free” source code open to the computing community
- Legacy software – old software
Software Related Problems
- What if the Software cannot be delivered to the user on time
- PARY The expense of creating and sustaining much more than is expected at the beginning of time
- Have bugs in codes that cannot be properly treated
- PARY Does not meet the requirements of the customer at the end of the delivery
- During the development process of the program, evaluating improvement is difficult to manage.
What is Software Process?
Computer Processes is a cohesive collection of activities designed to define, design, execute and test software systems. A model of a software process is an abstract representation of a process that provides a process definition from some specific perspective. There are several different processes in the program but they all involve:
- Specification specifying what should be achieved by the system
- Layout and implementation-defining program structure and system implementation
- Validation – checking that it is doing what the client wants
- Evolution – to adjust the program in response to changing customer requirements.
The application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software is called software engineering. The term software engineering was popularized by F. L. Bauer during the NATO Software Engineering Conference in 1968.
It encompasses techniques and procedures, often regulated by a software development process, with the purpose of improving the reliability and maintainability of software systems.
The discipline of software engineering includes knowledge, tools, and methods for software
requirements, software design, software construction, software testing, and software maintenance tasks.
Software engineering is related to the disciplines of computer science, computer
engineering, management, mathematics, project management, quality management, software ergonomics, and systems engineering.
Types of Software Process Model
Software procedures, methodologies and frameworks vary from standardized prescriptive measures that an organization may use directly in day-to-day operations, to versatile frameworks that an organization uses to build a custom collection of measures that are customized to the needs of a particular project or community. In certain cases, an agency named “sponsor” or “maintenance” distributes an official collection of documents detailing the operation.
Software Process and Software Development Lifecycle Model
One of the software development process’s basic notions is SDLC models, which stands for models of the Software Development Life Cycle. Several life cycle models for growth have been built to achieve specific goals needed. The models define the different process stages and the order in which they are performed. Below are the most commonly used, common and important SDLC models:
- Waterfall model
- V model
- Incremental model
- RAD model
- Agile model
- Iterative model
- Spiral model
- Prototype model
The waterfall model is a breaking of some project activities into linear sequential stages like into similar stages or steps, where each step depends on the previous one’s deliverables and corresponds to a task specialization. In other areas of engineering design, the approach is common.
- It is commonly used where we have fixed requirements and everything is in sequence.
The V-model is a creation framework that can be considered an extension of the waterfall model and is an example of a more general V-model. Instead of going down linearly, the process steps are bent upwards after the coding phase to form the typical V shape.
The V-Model demonstrates the relationship between each step of the life cycle of production and its corresponding step of testing. The horizontal and vertical axes represent the completeness of time or project (left-to-right) and the abstraction degree (coarsest-grain abstraction) respectively.
The incremental construct model is a software development approach where the model is built, implemented and checked incrementally (a little more is added each time) before the product is done. This involves both development and maintenance. The product is described as finished if it satisfies all of its requirements.
Through iteration passes through the phases of specifications, design, coding and testing. Then any subsequent release of the framework adds functionality to the previous release until all planned functionality has been implemented. This approach blends the features of the waterfall model with the iterative prototyping method.
An iterative life-cycle model does not attempt to begin with a full specification of specifications by concentrating first on the original, simpler user features collection, which then slowly become more complex and more detailed before the desired framework is completed. The theory of gradual growth can also be used liberally and interchangeably when following an iterative approach.
The iterative life-cycle model does not attempt to begin with the full specification of the requirements by focusing first on the original, simpler user features set, which will gradually become more complex and more comprehensive before the desired structure is completed. Gradual growth theory can also be used liberally and interchangeably by using iterative methods.
The rapid development of the application was a reaction to plan-driven waterfall processes developed in the 1970s and 1980s, such as the Structured Systems Analysis and Design Method (SSADM). Rapid Application Development (RAD) is often referred to as adaptive software development.
RAD is a gradual prototyping approach to software development where end-users can have better input when testing a live program, rather than dealing solely with documentation. This places less focus on planning and more focus on an adaptive cycle.
RAD may result in a lower level of refusal when the application is put into service, but this performance is most often at the expense of drastic project costs and schedule overruns. The RAD approach is particularly well suited for the development of software that is driven by user interface requirements. These GUI builders are also referred to as fast application development tools.
The spiral model, first defined by Barry Boehm in 1986, is a risk-driven software development process model that was implemented to resolve the shortcomings of the conventional waterfall model. A spiral model looks like a circle with many loops.
The exact number of spiral loops is unknown and can vary from project to project. This model promotes risk reduction and the project is implemented in loops. That spiral loop is referred to as a step of the software development process.
The spiral model, first described by Barry Boehm in 1986, is a risk-driven software development process model that has been introduced to overcome the limitations of the traditional waterfall model. A spiral model looks like a circle with many loops in it.
The exact number of spiral loops is unknown and may vary from project to project. This model promotes risk reduction and the project is being implemented in loops. This spiral loop is referred to as a step in the development of software.
Agile is the umbrella term for a collection of approaches and practices based on the ideals and principles articulated in the Agile Manifesto, a way of thinking that enables teams and companies to evolve, adapt rapidly to changing demand and reduce risk. Organizations can be agile using many of the current systems, such as Scrum, Kanban, Lean, and Extreme Programming (XP) and so on.
The Agile movement is offering alternatives to conventional project management. Agile methods are usually used in software development to help companies adapt to unpredictability, which refers to a community of iterative development-based software development methodologies where requirements and solutions evolve through collaboration between self-organizing cross-functional teams.
The Agile movement offers alternatives to conventional project management. Agile methods are usually used in software development to help businesses adapt to unpredictability, which refers to a community of iterative development-based software development models where changes are implemented to develop through cooperation between self-organizing cross-functional teams.
Software Life Cycle Development Stages(SDLC)
A software development life cycle is the process followed by the team when developing software systems, from the initial stage of requirement gathering, all the way through to maintenance and support of the system.
SDLC is also known as software systems development or application development. An SDLC should result in a high-quality system that meets or exceeds customer expectations, within the agreed time and cost estimates. The software should work effectively and efficiently in the current and planned platforms. The software should also be cost-effective to enhance its infrastructure and is cheap to maintain.
SDLC is a systematic approach to problem-solving and is composed of several phases, each comprised of multiple steps. All software development must go through the stages listed below:
- Business Requirements Gathering
- Feasibility Analysis
- Functional Requirements Gathering and Analysis
- Release & Maintenance
Lets us see each of these steps one by one
Business Requirements Gathering
Every Software development project should start with this stage where the customer’s expectations for which the software to be developed are gathered. These are the initial requirements. The Stakeholders or the Customers/ Clients are interviewed for gathering the information at the initial level, which would include the following questions.
- What are the Business Vision, Strategy, Objectives, goals and key success factors to be achieved by the software being developed?
- What are the key business issues and their impact?
- What are the current problems or triggering an opportunity to design the software?
- Is the idea responsiveness to market or market need or need of hours?
- What is the key information to make business decisions?
- What is the missing information impacting the decision?
- What is the range of analytic capability required for this development?
- Is there any financial impact – budgetary constraints?
Based on the business need and technology aspect, the experts analyze the feasibility of designing the software. There can be multiple rounds of meetings to decide on the feasibility.
Functional Requirements Gathering and Analysis
Once the feasibility analysis is done, the process moves forward to gather the actual functional requirements. The experts may ask several questions to gather in-depth ideas.
- For web-based application, is there any need for session maintenance in terms of database or memory?
- What is the Session time out period? The life cycle of session data?
- What is the Browser compatibility of the application? IE, Netscape, Chrome etc? Which
NFRs(Non Functional Requirements)
User Interface/ Sessions related questions:
- The number of users accessing the system per day, peak hours, off-peak hours. Or any other such requirements?
- The number of users accessing the system for specific transactional information on per day, peak hours, off-peak hours?
- The number of transactions, simultaneous transactions, type of transactions, size of each transaction?
External Interface related queries:
- How many external interfaces have been identified for the system?
- For each of the external interfaces have the interface declarations been decided upon?
Database related queries:
- What are the entities or data items that you use? (The forms, documents etc are a good source of data)
- How are these entities related to each other?
- What is the precedence/ logical flow of such a relationship?
- What other communication modes do you use?
- What master data is to be stored?
- Where is this data generated? Is it manually entered, or does it come from an
external system or is it a result of an activity or is it a temporary data?
- Is the source of all data known and understood?
- What is the expected size of the database?
- What is the rate at which the data grows?
- History data of how many years have to be stored?
Internationalization related queries:
- Does the application need to deal with multiple currencies?
- What kind of functionality is required to deal with multiple currencies?
- Does the application need support for multiple languages?
- What kind of support is required? i. e. is it for the entire application or limited to certain modules of the application.
- What are the languages it should support?
Software design is a process of problem-solving and planning for a software solution. After the purpose and specifications of software are determined, software developers will design or employ designers to develop a plan for a solution. It includes low – level component and view. algorithm implementation issues as well as the architectural view.
In this phase, the software development process, the software ‘ s overall structure, and its nuances are defined. In terms of the client/ server technology, the number of tiers needed for the package architecture, the database design, the data structure design, etc, are all defined in this phase.
A software development model is then created. Analysis and Design are very crucial in the whole development cycle. Any glitch in the design phase could be very expensive to solve in the later stage of software development. Much care is taken during this phase. The logical system of the product is developed in this phase.
Major Design Considerations- Software depends on the below qualities
There are many aspects to consider in the design of a piece of software. The importance of each should reflect the goals the software is trying to achieve. Some of these aspects are:
- Extensibility – New capabilities can be added to the software without major changes
to the underlying architecture.
- Usability- It shows how some new users can learn it, fast, and get their work done easily.
- Efficiency- It simply means that it does not waste resources such as CPU time and memory due to lack of proper management.
- Reliability – The software is able to perform a required function understated
conditions for a specified period of time. It simply means that it does what it is required to do without failing
- Fault – tolerance – The software is resistant to and able to recover from component
- Robustness – The software is able to operate under stress or tolerate unpredictable
or invalid input. For example, it can be designed with resilience to low memory conditions.
- Security – The software is able to withstand hostile acts and influences.
- Maintainability – The software can be restored to a specified condition within a specified period of time. For example, anti-virus software may include the ability to boost periodically receive virus definition updates in order to maintain the software ‘ s effectiveness. It can be easily changed and maintained on-demand on the given time.
- Compatibility – The software is able to operate with other products that are designed for interoperability with another product. For example, a piece of software may be backwards compatible with an older version of itself.
- Reusability – The modular components designed should capture the essence of the functionality expected out of them and no more or less. This single-minded purpose renders the components reusable wherever there are similar needs in other designs. Its parts can be used in other projects in future, so reprogramming is not needed.
- Modularity – The resulting software comprises well – defined, independent
components. That leads to better maintainability. The components could be then implemented and tested in isolation before being integrated to form a desired software system. This allows the division of work in a software development project.
A software designer or architect may identify a design problem, which has been solved by others before. A template or pattern describing a solution to a common problem is known as a design pattern. The reuse of such patterns can speed up the software development process, having been tested and proved in the past.
Software Design Levels
Architectural Design-The architectural design is the most abstract form of the framework. This defines the device as a system with a variety of components communicating with each other. At this level, designers are given the idea of the proposed solution domain.
High-level design – High-level design splits the idea of ‘single entity-multiple object’ in architectural design into a less abstract view into subsystems and modules and demonstrates how they communicate with each other. The high-level design focuses on how the device can be implemented in the form of modules along with all its components. This understands the modular structure of each subsystem and the relationship and interaction of each other.
Advanced Design-Detailed design deals with the implementation of part of what has been used as a structure and its sub-systems in the previous two projects. More information on the modules and their implementations. Defines the logical structure of each module and its interfaces to interact with other modules.
Design methodologies aim to provide a template process or a framework for the actual design of a system. They aim to simplify the actual process of designing a and aim to enforce some standard design principles, which improve the quality of design.
One of the earlier design methodologies is the Responsibility Driven Design (RDD). It forms the basis of the URDAD, the Use Case Responsibility – Driven Analysis and Design method which aims to generate a technology-neutral design which is then mapped onto one ‘ s choice of implementation architecture and technologies.
Software design documentation may be reviewed or presented to allow constraints, specifications, and even requirements to be adjusted prior to programming. Redesign may occur after review of a programmed simulation or prototype.
It is possible to design software in the process of programming, without a plan or requirement analysis, but for more complex projects this would not be considered a professional approach. A separate design prior to programming allows for multidisciplinary designers and Subject Matter Experts (SMEs) to collaborate with highly skilled programmers for software that is both useful and technically sound.
The design must be translated into a machine-readable form. The code generation step performs this task. If the design is performed in a detailed manner, code generation can be accomplished without much complication.
Programming tools like compilers, interpreters, debuggers, etc. are used to generate the code. Different high-level programming languages like C, C + +, Pascal, and Java are used for coding. With respect to the type of application, the right programming language is chosen.
In communications, a code is a rule for converting a piece of information into another form or representation, not necessarily of the same type. In communications and information processing, encoding is the process by which information from a source is converted into symbols to be communicated. Decoding is the reverse process, converting these code symbols back into information understandable by a receiver.
Computer programming (often shortened to programming or coding) is the process of writing, testing, debugging/ troubleshooting, and maintaining the source code of computer programs. This source code is written in a programming language.
The code may be a modification of an existing source or something completely new. The purpose of programming is to create a program that exhibits a certain desired behaviour (customization). The process of writing source codes requires expertise in many different subjects, including knowledge of the application domain, specialized algorithms and formal logic.
Software testing is the process used to assess the quality of computer software. Software testing is an empirical technical investigation conducted to provide stakeholders with information about the quality of the product or service under test, with respect to the context in which it is intended to operate. This includes, but is not limited to, the process of executing a program or application with the intent of finding software bugs.
Quality is not absolute. It is value to some person. With that in mind, testing can never completely establish the correctness of arbitrary computer software; testing furnishes a criticism or comparison that compares the state and behaviour of the product against a specification.
As per IEEE “Testing is the process of exercising or evaluating a system or system component by manual or automated means to verify that it satisfies specified requirements”.
There could any definition of software testing but essentially they all mean- “Does the
software behave as specified? “
How the error occurs?
The software faults occur through the following way-
A programmer makes an error (mistake), which results in a defect (fault, bug) in the software source code. If this defect is executed, in certain situations the system will produce wrong results, causing a failure, not all defects will necessarily result in failures.
For example, defects in dead code will never result in failures. A defect can turn into a failure when the environment is changed. Examples of these changes in the environment include the software being run on a new hardware platform, alterations in source data or interacting with different software.
Role of SQA
Software testing may be viewed as an important part of the software quality assurance (SQA) process. In SQA, software process specialists and auditors take a broader view of software and its development. They test and change the software engineering process itself to reduce the number of faults that end up in defect rate. What constitutes an acceptable defect rate depends on the nature of the software.
An arcade area video game designed to simulate flying an aeroplane would presumably have a higher tolerance for defects than software used to control an actual airline. Similar to medical science, an operation simulation may have higher a higher tolerance for defects than software used to do an actual human operation or diagnostics.
Although, there are close links with SQA testing departments often exist independently and there may be no SQA areas in some companies.
Read more here about on Software Testing.
Release & Maintenance
Release and Maintenance activity involves the followings:
- File conversion
- System testing
- System changeover
- New system becomes operational
- Staff training
- Corrective maintenance
- Perceptive maintenance nom
- Adaptive maintenance
Common challenges in software development:
If requirements are not clear, incomplete, too general, or not testable, there will be problems.
If too much of work is crammed in too little time, problems are inevitable.
No one will know whether or not the program is any good until the customer complains or systems crash.
Requests to pile on new features after development is underway, extremely common.
If developers do not know what ‘ s needed or custom erroneous expectations, problems are guaranteed.
Software verification and validation
Software Project Management, Software Testing and software development, verification (V&V) is the method of validating that the software system meets the requirements and fulfils its stated function. It can also be referred to as software quality assurance, which is normally the responsibility of software developers as part of the life cycle of software development.
In simple terms, software testing is “Assuming we can build X, does our program accomplish its goals without any glitches or gaps?” but at the other hand, software validation is “Was X how we should have built? Does X fulfil the high-level requirements?”
Verification and certification are not the same things, but they are often confused. The discrepancy was briefly expressed by Boehm as
Verification: Are we building the right product?
Validation: Are we creating the right product for you?
“Building the right product” ensures that the device properly applies the requirements while “Building the right product” refers back to the needs of the customer. In certain cases, written specifications are required for both formal procedures and protocols to assess compliance.
Creating the right product requires the use of the Requirements Specification as input for the next step of the development process, the design process, the result of which is the Design Specification. This also requires the use of the Model Specification to feed the design cycle.
That when a process output correctly implements its input specification, the software product is one step closer to final verification. When the performance of a method is wrong, developers do not create the product that stakeholders want correctly. This form of verification is called “verification of the artefact or specification.
“Creating the right product means developing a specification of specifications that incorporates the needs and expectations of the software product stakeholders. When such an item is incomplete or wrong, the developers would not be able to create the product they want. It is a type of “validation of artefact or specification.”
Note: Verification begins before Validation and then runs parallel until the software product is released.