3391ch17.pdf
(
331 KB
)
Pobierz
Microelectronics, Second Edition
17
Software Design and
Development
17.1 Introduction
........................................
17
-
1
17.2 The Notion of Software
.............................
17
-2
17.3 The Nature of Software Engineering
.................
17
-5
17.4 A New Approach
....................................
17
-
9
17.5 Apollo On-Board Flight Software Effort: Lessons
Learned
.............................................
17
-
10
17.6 Development Before the Fact
........................
17
-12
17.7 Development Before the Fact Theory
................
17
-15
17.8 Process
.............................................
17
-
15
Margaret H. Hamilton
17.9 Select the Right Paradigm and then Automate
........
17
-
17
17.1 Introduction
A computer system can be neatly compared with a biological entity called a superorganism. Composed
of software, hardware, peopleware and their interconnectivity (such as the internet), and requiring all to
survive, the silicon superorganism is itself a part of a larger superorganism, for example, the business.
It could be a medical system including patients, drugs, drug companies, doctors, hospitals and health
care centers; a space mission including the spacecraft, the laws of the universe, mission control and the
astronauts; a system for researching genes including funding organizations, funds, researchers, research
subjects, and genes; or a financial system including investors, money, politics, financial institutions, stock
markets, and the health of the world economy.
Whether the business be government, academic, or commercial, the computer system, like its biological
counterpart, must grow and adapt to meet fast changing requirements. Like other organisms, the business
has both physical infrastructure and operational policies which guide, and occasionally constrain, its
direction and the rate of evolution, which it can tolerate without becoming dysfunctional.
Unlike a biological superorganism, which may take many generations to effect even a minor hereditary
modification, software is immediately modifiable and is, therefore, far superior in this respect to the
biological entity in terms of evolutionary adaptability. Continuity of business rules and the physical
infrastructure provides a natural tension between “how fast the software can change” and “how rapidly
the overall system can accept change.”
As the brain of the silicon superorganism, software controls the action of the entire entity, keeping in
mind, however, it was a human being that created the software.
In this chapter we will discuss the tenets of software, what it is and how it is developed, as well as the
precepts of software engineering, which are the
methodologies
by which ideas are turned into software.
17
-
1
© 2006 by Taylor & Francis Group, LLC
17
-2
Microelectronics
17.2 The Notion of Software
Software is the embodiment of logical processes, whether in support of business functions or in control
of physical devices. The nature of software as an instantiation of process can apply very broadly, when
modeling complex organizations, or very narrowly as when implementing a discrete numerical algorithm.
In the former case, there can be significant linkages between re-engineering businesses to accelerate the
rate of evolution—even to the point of building operational models which then transition into application
suites and thence into narrowly focused implementation of algorithms. Software thus has a potentially
wide range of application, and when well designed, it has a potentially long period of utilization.
Whereas some would define software as solely the code generated from programming language state-
ments in the compilation process, a broader and more precise definition includes requirements, specifi-
cations, designs, program listings, documentation, procedures, rules, measurements, and data, as well as
the tools and reusables used to create, test, optimize, and implement the software.
That there is more than one definition of software is a direct result of the confusion about the very
process of software development itself. A 1991 study by the Software Engineering Institute (SEI) (1991)
amplifies this rather startling problem. The SEI developed a methodology for classifying an organization’s
software process maturity into one of five levels that range from Level 1, the
initial level
(where there is
no formalization of the software process), to Level 5, the
optimizing level
where methods, procedures, and
metrics are in place with a focus toward continuous improvement in software reliability. The result of
this study showed that fully 86% of organizations surveyed in the US were at Level 1 where the terms “ad
hoc,” “dependent on heroes,” and “chaotic” are commonly applied. And, given the complexity of today’s
applications including those that are internet based, it would not be surprising to see the percentage of
Level 1 organizations increase. Adding to the mix are the organizations that think the so called order
mandated by some techniques serves only to bring about more chaos, confusion, and complexity; or at
least spend many more dollars for what they believe delivers little, no, or negative benefit.
Creating order from this chaos requires an insightful understanding into the component parts of software
as well as the development process. Borrowing again from the world of natural science, an entelechy is
something complex that emerges when you put a large number of simple objects together. For example,
one molecule of water is rather boring in its utter lack of activity. But pour a bunch of these molecules into
a glass and you have a ring of ripples on the water’s surface. If you combine enough of these molecules
together, you wind up with an ocean. So, too, software: by itself, a line of code is a rather simple thing. But
combine enough of them together and you wind up with the complexity of a program. Add additional
programs and you wind up with a system that can put a person on the moon.
Although the whole is indeed bigger than the sum of its parts, one must still understand those parts if the
whole is to work in an orderly and controlled fashion. Like a physical entity, software can “wear” as a result
of maintenance, changes in the underlying system and updates made to accommodate the requirements
of the ongoing user community. Entropy is a significant phenomenon in software, especially for Level 1
organizations.
Software at the lowest programming level is termed
source code
. This differs from
executable code
(i.e.,
that which can be executed directly by the hardware to perform one or more specified functions) in that it
is written in one or more programming languages and cannot, by itself, be executed by the hardware until
it is translated into machine executable code. A programming language is a set of words, letters, numerals,
and abbreviated mnemonics, regulated by a specific syntax, used to describe a program (made up of lines
of source code) to a computer. There are a wide variety of programming languages, many of them tailored
for a specific type of application. C, one of today’s more popular programming languages, is used in en-
gineering as well as business environments, whereas object-oriented languages, such as C++ (Stroustrup,
1997) and Java (Gosling et al., 1996), have been gaining acceptance in both of these environments. In
fact Java has become a language of choice for internet based applications. In the recent past, engineering
applications have often used programming languages such as Fortran, Ada (for government applications)
and HAL (for space applications) (Lickly, 1974), while commercial business applications have favored
common business oriented language (COBOL). For the most part one finds that in any given organization
© 2006 by Taylor & Francis Group, LLC
Software Design and Development
17
-3
there are no prescribed rules that dictate which languages are to be used. As one might expect, a wide
diversity of languages is being deployed.
The programming language, whether that be C (Harbison, 1997), Java, COBOL, C++, C# or something
else, provides the capability to code such logical constructs as that having to do with:
User interface:
Provides a mechanism whereby the ultimate end user can input, view, manipulate,
and query information contained in an organization’s computer systems. Studies have shown that
productivity increases dramatically when visual user interfaces are provided. Known as
graphical
user interfaces (GUIs)
, each operating system provides its own variation. Some common graphical
standards are Motif for Unix (including Linux) systems, Aqua for the Macintosh Operating System
and Microsoft Windows for PC-based systems.
Model calculations:
Perform the calculations or algorithms (step-by-step procedures for solving a
problem) intended by a program, for example, process control, payroll calculations, or a Kalman
Filter.
Program control:
Exerts control in the form of comparisons, branching, calling other programs,
and iteration to carry out the logic of the program.
Message processing:
There are several varieties of message processing. Help-message processing is
the construct by which the program responds to requests for help from the end user. Error-message
processing is the automatic capability of the program to notify and then recover from an error during
input, output, calculations, reporting, communications, etc. And, in object-oriented development
environments, message processing implies the ability of program objects to pass information to
other program objects.
Moving data:
Programs store data in a data structure. Data can be moved between data structures
within a program; moved from an external database or file to an internal data structure or from
user input to a program’s internal data structures. Alternatively, data can be moved from an internal
data structure to a database or even to the user interface of an end user. Sorting, searching, and
formatting are data moving and related operations used to prepare the data for further operations.
Database:
A collection of data (objects) or information about a subject or related subjects, or a
system (for example, an engine in a truck or a personnel department in an organization). A database
can include objects such as forms and reports or a set of facts about the system (for example, the
information in the personnel department needed about the employees in the company). A database
is organized in such a way as to be easily accessible to computer users. Its data is a representation of
facts, concepts, or instructions in a manner suitable for processing by computers. It can be displayed,
updated, queried, and printed, and reports can be produced from it. A database can store data in
several ways including in a relational, hierarchical, network, or object-oriented format.
Data declaration:
Describes the organization of a data structure to the program. An example would
be associating a particular data structure with its type (for example, data about a particular employee
might be of type person).
Object:
A person, place, or thing. An object contains data and a set of operations to manipulate
data. When brought to life, it knows things (called
attributes
) and can do things (to change itself or
interact with other objects). For example, in a robotics system an object may contain the functions
to move its own armature to the right, while it is coordinating with another robot to transfer yet
another object. Objects can communicate with each other through a communications medium
(e.g., message passing, radio waves, internet).
Real time:
A software system that satisfies critical timing requirements. The correctness of the
software depends on the results of computation, as well as on the time at which the results are
produced. Real-time systems can have varied requirements such as performing a task within a
specific deadline and processing data in connection with another process outside of the computer.
Applications such as transaction processing, avionics, interactive office management, automobile
systems, and video games are examples of real-time systems.
© 2006 by Taylor & Francis Group, LLC
17
-4
Microelectronics
Distributed system:
Any system in which a number of independent interconnected processes can
cooperate (for example processes on more than one computer). The client/server model is one of
the most popular forms of distribution in use today. In this model, a client initiates a distributed
activity and a server carries out that activity.
Simulation:
The representation of selected characteristics of the behavior of one physical or ab-
stract system by another system. For example, a software program can simulate an airplane, an
organization, a computer, or another software program.
Documentation:
Includes description of requirements, specification and design; it also includs
comments that describe the operation of the program that is stored internally in the program, as
well as written or generated documentation that describes how each program within the larger
system operates.
Tools:
The computer programs used to design, develop, test, analyze, or maintain system designs
of another computer program and its documentation. They include code generators, compilers,
editors,
database management systems (DBMS)
, GUI builders, simulators, debuggers, operating
systems and software development, and systems engineering tools (some derived or repackaged
from earlier tools that were referred to in the nineties as
computer aided software engineering (CASE)
tools), that combine a set of tools, including some of those listed above.
Although the reader should by now understand the dynamics of a line of source code, where that line
of source code fits into the superorganism of software is dependent on many variables. This includes the
industry the reader hails from as well as the software development paradigm used by the organization.
As a base unit, a line of code can be joined with other lines of code to form many things. In a traditional
software environment many lines of code form a program, sometimes referred to as an application program
or just plain application. But lines of source code by themselves cannot be executed. First, the source code
must be run through a
compiler
to create
object code
. Next, the object code is run through a
linker
, which
is used to construct
executable code
. Compilers are programs themselves. Their function is twofold. The
compiler first checks the source code for obvious syntax errors and then, if it finds none, creates the
object code for a specific operating system. Unix, Linux (a spinoff of Unix), and Windows are all examples
of operating systems. An operating system can be thought of as a supervising program that manages the
application programs that run under its control. Since operating systems (as well as computer architectures)
can be different from each other, compiled source code for one operating system cannot be executed under
a different operating system, without a recompilation.
Solving a complex business or engineering problem often requires more than one program. One or more
programs that run in tandem to solve a common problem is known collectively as an application system
(or system). The more modern technique of object-oriented development dispenses with the notion of
the program altogether and replaces it with the concept of an object (Goldberg and Robson, 1983; Meyer
and Bobrow, 1992; Stefik and Bobrow, 1985; Stroustrup, 1994).
Where a program can be considered a critical mass of code that performs many functions in the attempt
to solve a problem with little consideration for object boundaries, an object is associated with the code
to solve a particular set of functions having to do with just that type of object. By combining objects
like molecules, it is possible to create more efficient systems than those created by traditional means.
Software development becomes a speedier and less error-prone process as well. Since objects can be
reused, once tested and implemented, they can be placed in a library for other developers to reuse. The
more the objects in the library, the easier and quicker it is to develop new systems. And since the objects
being reused have, in theory, already been warranted (i.e., they have been tested and made error free),
there is less possibility that object-oriented systems will have major defects.
The process of building programs and/or objects is known as software development, or software engi-
neering. It is composed of a series of steps or phases, collectively referred to as a development life cycle. The
phases include (at a bare minimum): an analysis or requirements phase where the business or engineering
problem is dissected and understood, a specification phase where decisions are made as to how the re-
quirements will be fulfilled (e.g., deciding what functions are allocated to software and what functions are
© 2006 by Taylor & Francis Group, LLC
Software Design and Development
17
-5
allocated to hardware); a design phase where everything from the GUI to the database to the algorithms
to the output is designed; a programming (or implementation) phase where one or more tools are used
to support the manual process of coding or to automatically generate code, a testing (debugging) phase
where the code is tested against a business test case and errors in the program are found and corrected,
an installation phase where the systems are placed in production, and a maintenance phase where mod-
ifications are made to the system. But different people develop systems in different ways. These different
paradigms make up the opposing viewpoints of software engineering.
17.3 The Nature of Software Engineering
Engineers often use the term systems engineering to refer to the tasks of specifying, designing, and simu-
lating a non-software system such as a bridge or electronic component. Although software may be used
for simulation purposes, it is but one part of the systems engineering process. Software engineering, on
the other hand, is concerned with the production of nothing but software. In the 1970s industry pundits
began to notice that the cost of producing large-scale systems was growing at a high rate and that many
projects were failing or, at the very least, resulting in unreliable products. Dubbed the software crisis, its
manifestations were legion, and the most important include
Programmer productivity:
In government in the 1980s, an average developer using C was expected
to produce only 10 lines of production code per day (an average developer within a commercial
organization was expected to produce 30 lines a month); today the benchmark is more like two to
five lines a day while at the same time the need is dramatically higher than that, perhaps by several
orders of magnitude, ending up with a huge backlog. The National Software Quality Experiment
(NSQE) completed a 10-year research project in 2002 that compared the productivity of systems
today with that of systems 10 years ago. The assumption at the outset was that the productiviity of
today’s systems would be much higher given all the more “modern” tools including a proliferation
of commercial packages and object-oriented languages that are now available; but they were wrong.
Not only did the productivity not increase, it decreased (NSQE, 2002). Further NSQE concluded
that there would need to be a significant breakout in the way software is designed and developed
in order to achieve a factor of 10 reduction in defect rate.
Programmer productivity is dependent on a plethora of vagaries: from expertise to complexity
of the problem to be coded to size of the program that is generated (Boehm, 1981). The science of
measuring the quality and productivity of the software engineering process is called
metrics.
As in
the diverse paradigms in software engineering itself, there are many paradigms of software measure-
ment. Today’s metric formulas are complex and often take into consideration the following: cost,
time to market, productivity on prior projects, data communications, distributed functions, perfor-
mance, heavily used configurations, transaction rates, online data entry, end user efficiency, online
update, processing complexity, reusability, installation ease, operational ease, and multiplicity of
operational sites.
Defect removal costs:
The same variables that affect programmer productivity affect the cost of
debugging the programs and objects generated by those programmers. It has been observed that
the testing and correcting of programs consumes a large share of the overall effort.
Development environment:
Development tools and development practices greatly affect the quan-
tity and quality of software. Most of today’s design and programming environments contain only
a fragment of what is really needed to develop a complete system. Life cycle development environ-
ments provide a good example of this phenomena. Most of these tools can be described either as
addressing the upper part of the life cycle (i.e., they handle the analysis and design) or the lower
part of the life cycle (i.e., they handle code generation). There are few integrated tools on the market
(i.e., that seamlessly handle both upper and lower functionalities). There are even fewer tools that
add simulation, testing and cross-platform generation to the mix. And it would be hard put to find
any tools that seamlessly integrate system design to software development.
© 2006 by Taylor & Francis Group, LLC
Plik z chomika:
Januszek66
Inne pliki z tego folderu:
Back Seat_ A Mumbai Tale - Aditya Kripalani.mobi
(755 KB)
Brief Wondrous Life of Oscar Wao, The - Junot Diaz.opf
(3 KB)
Don't Make Me Think, Revisited_ - Steve Krug.mobi
(9256 KB)
M. T. Anderson - Norumbegan 03 - The Empire of Gut and Bone # (v5.0).epub
(2209 KB)
M. T. Anderson - Norumbegan 02 - The Suburb Beyond the Stars # (v5.0).epub
(2105 KB)
Inne foldery tego chomika:
Dokumenty
Galeria
LUDLUM ROBERT
Midi - Kar
Mszał Rzymski PL
Zgłoś jeśli
naruszono regulamin