What is the software engineering paradigm

Software engineering overview



Let us first understand what software engineering stands for. The term is made up of two texts, software and engineering.

software is more than just a program code. A program is an executable code that serves some computational purpose. Software is considered to be collection of executable programming code, associated libraries, and documentation. Software when made for a specific requirement is called software product.

mechanical engineering On the other hand, all is over-developing the product, using well-defined, scientific principle and methods.

Software engineering is a mechanical engineering branch engaged in developing software product using well-defined scientific principles, methods and procedures. The result of software engineering is an efficient and reliable software product.

Definitions

IEEE defines software engineering as:

(1) The application of a systematic, disciplined, quantifiable approach to the development, operation and maintenance of software; that is, the application of engineering to software.

(2) Studying the approaches as in the statement above.

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

Software engineering is the establishment and use of fair technical principles to obtain in order economical software that is reliable and efficient working on real machines.

Software evolution

The process of developing a software product using software engineering principles and methods is referred to as software evolution. This includes the initial development of software and its maintenance and updates; a desired software product is developed that meets the expected requirements.

Evolution starts from the requirement assembly process. After which the developer will create a prototype of the intended software and show it to the users to get their feedback at the early stage of software product development. The user suggests changes on which several consecutive updates and maintenance keep changing to. This process changes the original software until the desired software is carried out.

Even after the user has desired software in hand, the advancing technology and the changing requirements force the software product to change accordingly. Re-creating software from scratch and going one-on-one with requirement is not feasible. The only feasible and economical solution is to update the existing software so that it matches the latest requirements.

Software evolution laws

Lehman has passed laws for software development. He divides the software into three different categories:

  • S-types (static-types) - This is software that works strictly according to defined Specifications and solutions. The solution, and the method of achieving it, both need to be understood immediately prior to coding. The s-types software is least subject to change therefore this is the simplest of them all. For example pocket calculator program for mathematical calculations.

  • P-types (practical-types) - This is software with a collection of Procedures. This is defined by exactly what procedures can do. In this software the specifications can be described, but the solution is not Immediately Obvious. For example gaming software.

  • E-types (embedded-type) - This software works closely as the real world requirement Environment. This software has a high degree of evolution as there are various changes of laws, taxes, etc. in real world situations. For example online trading software.

E-types software evolution

Lehman has given eight laws for E-Type software evolution -

  • Continuous change - An E-Type software system must continue to adapt to the real world changes, otherwise it becomes progressively less useful.

  • Increasing complexity - As an E-Type software system evolves, its complexity tends to increase unless work is done to maintain or reduce it.

  • Maintaining familiarity - Familiarity with the software or knowledge of how it was developed, why was it developed in that particular way etc. must be kept at all costs to implement the changes in the system.

  • continuous growth - Alright In order for an E-type system to be intended to fix some business problem, its size from the implementation of the changes grows after the lifestyle changes of the company.

  • Reduction in quality - An E-type software system takes over, unless the quality is consistently maintained and adapted to a changing work environment.

  • Back systems - The E-Type software systems form multi-loop, multi-level feedback systems and must be treated as such in order to be successfully modified or improved.

  • Self-regulation - E-type system evolution processes are self-regulating with the sale of products and processes measures close to normal.

  • Organizational stability - The average effective global activity rate in a developing E-Type system is invariant over the life of the product.

Software paradigms

Software paradigms refer to the methods and steps that are taken while designing the software. There are many methods proposed and in work today, but we need to see where these paradigms stand in software engineering. These can be combined in different groups, although each of them contain in a different:

Programming paradigm is a subset of the software design paradigm that is a subset of the software development paradigm.

Software development paradigm

This paradigm is known as the software engineering paradigm, where all engineering concepts related to the development of software are applied. It includes various studies and needs assessment that helps build the software product. It consists of -

  • Requirements acquisition
  • Software design
  • programming

Software design paradigm

This paradigm is part of software development and includes -

  • design
  • maintenance
  • programming

Programming paradigm

This paradigm is closely related to the programming aspect of software development. This includes -

  • Coding
  • Testing
  • integration

Need for software engineering

The need for software engineering arises because of the higher rate of change in user requirements and the environment in which the software works.

  • Great software - It is easier to build a wall than a house or building, just as the size of the software will be great engineering has to step with to give it a scientific process.

  • Scalability - If the software process was not based on scientific and technical concepts, it would be easier to create new software than to scale an existing one.

  • costs - As the hardware industry has shown its capabilities and has very great manufacturing lower price of computer and electronics hardware. But the cost of software remains high if the appropriate process is not adapted.

  • Dynamic nature - The ever growing and customizing nature of software is hugely dependent on the environment in which the user is working. If the nature of software keeps changing, new improvements must be made in the existing one. This is where software engineering plays a good role.

  • Quality management - Better software development process offers better quality software product.

Characteristics of good software

A software product can be assessed for what it offers and how well it can be used. This software must meet the following reasons:

  • Operational
  • Transitional
  • maintenance

Mature software and handcrafted is expected to have the following characteristics:

Operational

That tells us how well software works in operation. It can be measured on:

  • budget
  • Usability
  • Efficiency
  • correctness
  • Functionality
  • reliability
  • security
  • security

Transitional

This aspect is important when the software moves from one platform to another:

  • portability
  • Interoperability
  • Reusability
  • adaptability

maintenance

This aspect pleads about how well software has the capabilities to sustain itself in the ever-changing environment:

  • Modularity
  • Maintainability
  • flexibility
  • Scalability

In short, computer science is a branch that needs well-defined technical concepts in order to produce efficient, durable, scalable software engineering, uses in-budget and on-time software products.