Definition –

Software engineering is the process of analyzing user needs and designing, constructing, and testing end user applications that will satisfy these needs through the use of software programming languages. It is the application of engineering principles to software development. In contrast to simple programming, software engineering is used for larger and more complex software systems, which are used as critical systems for businesses and organizations.

A software engineer takes the software needs of end users into account and consequently develops or designs new applications. Furthermore, software engineering may involve the process of analyzing existing software and modifying it to meet current application needs.

As computer hardware becomes cheaper, the focus transfers to software systems. Large software systems may be more complex than the hardware used to run them, so there is great demand for best practices and engineering processes that can be applied to software development. There must be discipline and control during software engineering, much like any complex engineering endeavor.

In modern consumer electronics, devices in direct competition often have similar hardware and processing power, but the user experience will vary greatly depending on the software being used.

History of Software Paradigms

Since the development of the early projects of large software systems in the 1950’s and 1960’s computer scientists started to develop Software Development Life Cycle (SDLC) models to govern the whole process of development. A number of process models have been developed over the years. The purpose of these models was to be used as a guide and a conceptual scheme to manage the system software project in a systematic, formal and procedural way. They also provide a guide for the development of software applications. Software models are used to guide the various tasks of the software system project including planning, organizing, staffing, coordinating, budgeting, and directing software development activities.

Introduction

“Paradigm”, a Greek word meaning “example”, is commonly used to refer to a category of entities that share a common characteristic. Software engineering paradigms are also known as Software engineering models or Software Development Models.

In order to reduce the potential chaos of developing software applications and systems, we use software process models and paradigms that describe the tasks that are required for the building of high-quality software systems. The specific process model or paradigms used to develop a given system depends heavily on the nature of the target system. Use of software paradigms in the development of the software processes has many benefits, including supporting systematic approach and the use of standard approaches and methodologies.

The software engineering paradigm which is also referred to as a software process model or Software Development Life Cycle (SDLC) model is the development strategy that encompasses the process, methods and tools. SDLC describes the period of time that starts with the software system being conceptualized and ends with the software system been discarded after usage.

The software engineering paradigm provides the guidance to the software engineer.

A paradigm specifies the particular approach or philosophy for designing, building and maintaining software. Each paradigm has its own advantages and disadvantages which make some paradigm more suitable to be used in developing a given software system in a given situation than another.

There are common software process tasks, phases and activities that are modeled by software models. They are heavily affected by selected software paradigms. These tasks, phases and activities include:

Requirements Engineering: Software specification and functional requirements obtained from the user.

Requirements Analysis and Modeling

Architectural Engineering, implementation and Design: Production of the software system as a product

Software Testing and Validation: Activity that assures that customer specifications are met

System Delivery.

Software Evolution and Upgrading: System modification to meet continuing customer needs

System Documenting

Maintenance

The Software Engineering Paradigms (Process Models)

The four basic models are:

Waterfall model, also known as the traditional software development life cycle (SDLC).

The spiral model

Incremental process model

Agile development model

Waterfall Model

The waterfall model is also known as the linear sequential model and as classic life cycle model.

This model was developed in 1970 to make the software development process more structured. It is the oldest and most commonly used software engineering.

It demands a systematic, sequential approach to software development that begins at the requirements analysis through planning, design, coding, testing, and delivery.

The waterfall model, drawn from an engineering model is used in order to control the development of large software systems. The waterfall model is visualized as the flowchart in Figure 1. It consists of different stages which are processed in a linear fashion. The steps in the waterfall mode are: requirements analysis, planning, design, coding, testing, and delivery. Brief description of the phases in the waterfall model is presented below.

Requirements Analysis

In this phase the requirements of the software system are defined. This answers the ‘What is the software system to be developed’ question. It involves extensive user participation and ends with an approved set of requirements documented in a software requirement specification (SRS) document. This document is the basis of next stages of the project.

Design

In this phase the logical design of the system is defined. This answers the ‘How is the software system will be developed’ question. This phase uses the requirements specified in the previous phase (the SRS document) and translates them into design which will solve the problem. The design phase is an intermediate phase and bridge between ‘What’ the user/customer wants and the implemented system (code) that will be created to satisfy the requirements.

Coding

This stage of the model involves the writing of the code. The actual design is turned into a set of programs.

Testing

The code that is developed in the implementation phase is tested during the testing phase. This involves unit testing for the lowest level components, integration testing for groups of components and testing of the system as a whole.

A part of the testing phase are the verification and validation of the system for acceptance (acceptance testing). Verification checks that the system is correct (building the system right) while validation checks that the system meets the users desires (building the right system). System validation fulfils the use needs and and requires considerable user involvement.

Delivery

In this phase the system is made operational. Main activities in this phase include training of the user’s, and installation of the system. Also, in this phase the system is maintained where bugs, errors, and defects are corrected. The system is made more efficient, new requirements are added and existing functionality and features modified to meet the changing customer/user/business needs.

The Spiral Model

The spiral process model (developed by Barry Boehm in 1989) includes the same steps (requirements analysis, planning, design, coding, testing, and delivery) as the waterfall process model.

The motivation behind the development of the spiral process model was due to fact that requirements given at the beginning of the project are incomplete where requirements analysis phase and the design phase are continuously evolving as time passes. The steps go through a cyclical motion as requirements and design

The spiral model focuses on the constant re-evaluation of the design and risks involved. It can be described as being ‘iterative’ and ‘sequential’. The model can accommodate any process development model due to its generality. It is used commonly used for large and complex projects which as a result, can also be described as being expensive.

Incremental Process Model

The incremental process model allows customers to gent the developed system incrementally and part by part. They do not need to wait for the whole system to be completed. This is especially important in very large system where the completion of the whole system takes very long time. Deliverables are produced by increments where after an initial information strategy planning, the customer could get the first deliverable which is the core product. Here, the first ‘increment’ is the core product or the most important functionality of the system. Basic requirements are addressed, and the core product is produced. Non-basic requirements (some known, others unknown) are addressed later and the rest of the project remains undelivered. The core product is used and reviewed by the customer and base on customer evaluation, a plan is developed for the next increment. The plan addresses the new requirements specified by the customer of the core product to better meet the needs of the customer and the delivery of additional features and functionality. The incremental process is repeated following the delivery of each increment, until complete product is produced. The incremental process model is both evolutionary and interactive approach

Agile Development Model

The Agile development model, also known as the “Extreme Programming” model has the sole focus of time of delivery of the project. It is designed to allow software projects to be completed in the shortest time possible. Hence, agile development models are appropriate for web applications developers, which require rapid delivery of the system.

The incremental process model has the following features:

There are many agile development methods; most minimize risk by developing software in short time.

One iteration in agile development model is the Software developed in one unit of time.

Each iteration is an entire software project includes all stages that exist in the model which are planning, requirements analysis, design, coding, testing, and documentation.

An iteration does not necessarily add enough functionality to guarantee releasing the product to market. But, at the end of the iteration, there should exists an available release (without bugs).

At the end of each iteration, the development team re-evaluates project priorities.

Agile methods emphasize face-to-face communication over written documents.

A Generic View of Software Engineering

Engineering is the analysis, design, construction, verification, and management of technical (or social) entities. Regardless of the entity to be engineered, the following questions must be asked and answered:
• What is the problem to be solved?
• What characteristics of the entity are used to solve the problem?
• How will the entity (and the solution) be realized?
• How will the entity be constructed?
• What approach will be used to uncover errors that were made in the design
and construction of the entity?
• How will the entity be supported over the long term, when corrections, adaptations,
and enhancements are requested by users of the entity.

The work associated with software engineering can be categorized into three generic phases, regardless of application area, project size, or complexity. Each phase addresses one or more of the questions noted previously.

The definition phase focuses on what. That is, during definition, the software engineer attempts to identify what information is to be processed, what function and performance are desired, what system behavior can be expected, what interfaces are to be established, what design constraints exist, and what validation criteria are required to define a successful system. The key requirements of the system and the software are identified. Although the methods applied during the definition phase will vary depending on the software engineering paradigm (or combination of paradigms) that is applied, three major tasks will occur in some form: system or information engineering, software project planning, and requirements analysis .

The development phase focuses on how. That is, during development a software engineer attempts to define how data are to be structured, how function is to be implemented within a software architecture, how procedural details are to be implemented, how interfaces are to be characterized, how the design will be translated into a programming language (or nonprocedural language), and how testing will be performed. The methods applied during the development phase will vary, but three specific technical tasks should always occur: software design, code generation,and software testing.

The support phase focuses on change associated with error correction, adaptations required as the software’s environment evolves, and changes due to enhancements brought about by changing customer requirements. The support phase reapplies the steps of the definition and development phases but does so in the context of existing software. Four types of change are encountered during the support phase:

Correction. Even with the best quality assurance activities, it is likely that the customer will uncover defects in the software. Corrective maintenance changes the software to correct defects.
Adaptation. Over time, the original environment (e.g., CPU, operating system, business rules, external product characteristics) for which the software was developed is likely to change. Adaptive maintenance results in modification to the software to accommodate changes to its external environment.
Enhancement. As software is used, the customer/user will recognize additional functions that will provide benefit. Perfective maintenance extends the software beyond its original functional requirements.
Prevention. Computer software deteriorates due to change, and because of this, preventive maintenance, often called software reengineering, must be conducted to enable the software to serve the needs of its end users. In essence, preventive maintenance makes changes to computer programs so that they can be more easily corrected, adapted, and enhanced.