what is software engineering and its characteristics

Software Engineering Definition:-

• Definition of Engineering

Application of science, tools and methods to find cost effective solution to problems

• Definition of SOFTWARE ENGINEERING

Software engineering is a systematic approach to the development, operation

maintenance and requirements of the software.

• Software engineering is the application of science and mathematics by which the

capabilities of computer equipment’s are maid useful to man via computer program,

procedures and associated documents.

• Software engineering is a set of 4 elements

• Tools

• Methods

• Process

• Quality.

• The technical – how tools for building a software it includes project planning

estimation of the project system and software requirement analysis design of data

structure architecture & algorithms procedures.

• Software engineering tool provides automated & semi-automated support for

methods.

• When tools are integrated so that the support can be made for software development is

called CASE (Computer Added Software Engineering).

• CASE combine software, hardware & software engineering database. Software

engineering procedures define the sequence in which methods will be applied.

Software Engineering characteristics:-

Software is a logical rather than a physical system element therefore software has characteristic that

are different then hardware component.

1. Software is developed or engineered; it is not manufacture in the classical sense.

• In both activities software development and hardware manufacturing, high quality is achieved
through good design, but the manufacturing phase for hardware can introduce quality
problems that are nonexistence (or easily corrected) for software.
• Both activities depend on people, but the relationship between people applied and work
accomplished is entirely different. Both activities require the construction of a product, but the
approaches are different.

2. Software does not wear out failure.

  

• Figure (A) depicts failure rate as a function of time for hardware. The relationship often called
the “bathtub curve” indicates that hardware exhibits relatively high failure rate early in its life.
(This failures are often attributable to design or manufacturing defects);
• Defects are corrected and the failure rate drops to a steady state level (hopefully quite low)
for some period of time.
• As time passes, however, the failure rate rises again as hardware components suffer from the
cumulative effects of dust, vibrations, abuse, temperature extremes, etc. Stated simply,
hardware begins to wear out.
Software is not susceptible to the environmental maladies that cause hardware to wear out.

As shown in figure (B), the failure rate curve for software shows that, undiscovered defects
will cause high failure rates early in the life of a program.
• These are corrected (without introducing other errors) and the curve flattens as shown in
figure (B).
• Software doesn’t wear out, but it does deteriorate(go down). During the software life, it will
undergo change (maintenance).
• As changes are made, it is likely that some new defects will introduced, causing the failure
rate cure to spike. Before the curve can return to the original steady-state failure rate,
another change is requested, causing the curve to spike again. Slowly, the minimum failure
rate level begins to rise the software is deteriorating due to change.
• Hardware component wears out; it is replaced by a spare part. There are no software spare
parts.
• Every software failure indicates an error in design or in the process through which design
was translated into machine executable code.
• Therefore, software maintenance involves considerably more complexity than hardware
maintenance.
3. Most software is custom built rather than being assembled from existing components.
 Reusability is an important characteristic of high quality software component.
 A software component should be designed and implemented so that it can be reused in many
different programs.
 Modern reusable components encapsulate both data and the processing that is applied to the
data, enabling the software engineer to create new applications from reusable parts.
 For e.g. today’s interactive interfaces are built using reusable components that enable the
creation of graphics windows, pull down menus and a wide variety of interaction
mechanisms.
Software components are built using a programming language that has a limited vocabulary.
An explicitly defined grammar and well-formed rules of syntax and semantics.
 At the lowest level, the language mirrors the instruction set of the hardware.
 But Sometimes reusable components does not fulfill the requirement there may be some
changes we want but because of its complexity of code means we have to understand the
whole component for making some changes to it , which is very complex task instead of this
we can create a custom component.