Unit 12: Systems Design and Development

After reading this chapter, you should be able to:

• Describe the process of designing, programming, and debugging a computer program
• Explain why there are many different programming languages and give examples of several
• Explain why computer languages are built into applications, operating systems, and utilities
• Outline the steps in the life cycle of an information system and explain the purpose of program maintenance
• Explain the relationship between computer programming and computer science
• Describe the problems faced by software engineers in trying to produce reliable large systems

Grace Murray Hopper Sails on Software

More than any other woman, Grace Murray Hopper helped chart the course of the computer industry from its earliest days into the present. Throughout most of her career, Hopper remained anchored to the Navy. Grace Hopper worked on the Mark I, Mark II, and Mark III computers, as well as the UNIVAC I.

She also played central roles in the development of the first compiler (a type of computer language translator that makes most of today's software possible) and COBOL, the most widely used language for developing business software.

But Hopper's greatest impact was probably the result of her tireless crusade against the "We've always done it that way" mindset. From the early days of computing, she worked to persuade businesses to embrace the new technology.

Programming is a specialized form of the age-old process of problem solving. Problem solving typically involves four steps:

• Understanding the problem
• Devising a plan for solving the problem
• Carrying out the plan
• Evaluating the solution

The programming process can also be described as a four-step process, although in practice these steps often overlap:

• Defining the problem
• Devising, refining, and testing the algorithm
• Writing the program
• Testing and debugging the program

Most programming problems are too complex to solve all at once. To turn a problem into a program, a programmer typically creates a list of smaller problems, which can be broken into subproblems that can be subdivided in the same way. This process, called stepwise refinement, is similar to the process of developing an outline before writing a paper or a book.

Programmers sometimes refer to this type of design as top-down design, because the design process starts at the top, with the main ideas, and works down to the details.

The result of stepwise refinement is an algorithm&endash;a set of step-by-step instructions that, when completed, solves the original problem.

Programmers typically write algorithms in a form called pseudocode&endash;a cross between a computer language and plain English. When the details of an algorithm are in place, a programmer can translate it from pseudocode into a computer language.

Stepwise Refinement:

Once the problem is clearly defined, stepwise refinement can be used to produce a detailed algorithm.

Control Structures:

Control structures are logical structures that control the order in which instructions are carried out. The three basic control structures are sequence, selection, and repetition:

1. A sequence control structure is a group of instructions followed in order from the first through the last. The sequence is the default structure; that is, it applies unless a statement says otherwise.
2. A selection (or decision) control structure is used to make logical decisions&endash;to choose between alternate courses of action depending on certain conditions. It typically takes the form, "If (some condition is true) then (do something) else (do something else)."
3. A repetition control structure is a looping mechanism. It allows a group of steps to be repeated several times, usually until some condition is satisfied.

Just about any computer program can be constructed from these three control structures.

Testing the Algorithm

The next step is testing the algorithm to check the logic of the algorithm.

When testing is complete, the algorithm is ready to become a program. Because the algorithm has the logical structure of a program, the process of coding&endash;writing a program from the algorithm&endash;is simple and straightforward.

Into the Computer

A program needs to be entered into the computer's memory, saved as a disk file, and translated into the computer's native machine language before it can be executed, or run.

To enter and save the program, we can use a text editor. A text editor is like a word processor, but it lacks the formatting features required by writers.

To translate a program into machine language, we need translation software. The translator program might be an interpreter (a program that translates and transmits each statement individually) or a compiler (a program that translates an entire program before passing it on to the computer).

A typical compiler software package is an integrated programming environment, including a text editor, a compiler, a debugger to simplify the process of locating and correcting errors, and a variety of other programming utilities.

Syntax errors are violations of the "grammar" rules of a programming language.

After you correct errors and compile a program, you run the program to test for logic errors&endash;errors in the logical structure that cause differences between what you want the program to do and what it actually does.

There are hundreds of programming languages, ranging from professional programming tools to languages for users.

Machine Language and Assembly Language

Machine Language: Every computer has a native language&endash;a machine language.

From the machine's point of view, machine language is all binary. Machine language programs are hard to write, read, and debug.

Assembly Language: The programming process became easier with the invention of assembly language; language that's logically equivalent to machine language but is easier for people to read, write, and understand. In assembly language, programmers use alphabetic codes that correspond to the machine's numeric instructions.

To bridge the communication gap between programmer and computer, a program called an assembler translates each assembly language instruction into a machine language instruction.

Assembly language programming is still considered low-level programming; that is, it requires the programmer to think on the machine's level and to include an enormous amount of detail in every program. Most programmers today think and write on a higher level.

High-level Languages:

High-level languages, which fall somewhere between natural human languages and precise machine languages, were developed during the early 1950s to simplify and streamline the programming process.

Languages like FORTRAN and COBOL made it possible for scientists, engineers, and business people to write programs using familiar terminology and notation rather than cryptic machine instructions.

Interpreters and compilers translate high-level programs into machine language. Besides being easier to write and debug, high-level programs have the advantage of being transportable between machines. Transporting a program to a new machine isn't always that easy.

Multilingual Machines

These are some popular high-level languages:

• FORTRAN (Formula Translation)
• COBOL (Common Business Oriented Language)
• LISP (List Processing)
• BASIC (Beginner's All Purpose Symbolic Instruction Code)
• Pascal
• C and C++
• Ada
• PROLOG (Programming Logic)
• LOGO

Programming Methodologies: In the short history of computer programming, computer scientists have developed several new methodologies that have made programmers more productive and programs more reliable.

Structured Programming

Computer scientists developed structured programming to make the programming process easier and more productive. A structured program doesn't depend on the GoTo statement to control the logical flow. Instead it's built from smaller programs called modules, or subprograms, that are in turn made of even smaller modules. The programmer combines modules using the three basic control structures: sequence, repetition, and selection.

The Pascal and Ada languages were designed to encourage structured programming and discourage "spaghetti code." The success of these languages prompted computer scientists to develop versions of BASIC and FORTRAN that were conducive to structured programming.

Object-Oriented Programming

In object-oriented programming (OOP), a program is not just a collection of step-by-step instructions or procedures; it's a collection of objects. Objects contain both data and instructions, and can send and receive messages.

With OOP technology, programmers can build programs from prefabricated objects in the same way builders construct houses from prefabricated walls.

SmallTalk, the original OOP language, is still widely used for object-oriented programming, but many other languages now include object technology. C++ is a popular dialect of C that supports object-oriented programming.

Object-oriented tools and techniques are becoming common in databases, multimedia authoring tools, and other software environments.

Programming with Pictures

Visual programming tools allow programmers to create large portions of their programs by drawing pictures and pointing to on-screen objects, eliminating much of the tedious coding of traditional programming.

Languages for Users:

Some languages are designed to meet the more modest needs of computer users.

Macro Languages:

Many user-oriented languages are intended to allow users to create programs called macros that automate repetitive tasks. User-oriented macro languages (also called scripting languages) are built into many applications, utilities, and operating systems.

Fourth-Generation Languages:

Many experts suggest that languages have evolved through four generations: machine language, assembly language, high-level languages, and fourth-generation languages, sometimes called 4GLs.

Each language generation is easier to use and more like natural language than its predecessors.

• 4GLs use English-like phrases and sentences to issue instructions.
• 4GLs are nonprocedural. Pascal, C, and BASIC are procedural languages&endash;tools for constructing procedures that tell the computer how to accomplish tasks. Nonprocedural languages allow users to focus on what needs to be done, not on how to do it.
• 4GLs increase productivity.

One type of 4GL is the query language that allows a user to request information from a database with carefully worded English-like questions. A query language serves as a database user interface, hiding the intricacies of the database from the user. SQL (Structured Query Language) is the standard query language for most database applications today.

Component Software:

Component software tools may reverse the trend toward mega-applications by allowing users to construct small custom applications from software components. More and more software programs, including operating systems, are designed with extensibility in mind. The popular new Java language (discussed in earlier chapters) and the simpler JavaScript variant are especially useful for creating cross-platform components called applets.

Two new systems&endash;OpenDoc (developed by Apple with IBM and Novell) and OLE (developed by Microsoft)&endash;provide standardized support for component software at the system-software level.

If successful, these systems might radically change the software industry.

The Future of Programming?

Three trends concerning the future of programming seem likely:

• Programming languages will continue to evolve in the direction of natural languages like English.
• The line between programmer and user is likely to grow hazy.
• Computers will play an ever-increasing role in programming themselves.

Programs are part of larger information systems&endash;collections of people, machines, data, and methods organized to accomplish specific functions and to solve specific problems.

An information system has a system life cycle&endash;a sequence of steps or phases it passes through between the time the system is conceived and the time it is phased out. The phases of the system life cycle are: investigation, analysis, design, development, implementation, maintenance, and retirement. We'll consider each phase from the point of view of the systems analyst&endash;the computer professional primarily responsible for developing and managing a system as it progresses through these phases.

Investigation

System investigation involves defining the problem&endash;identifying the information needs of the organization, examining the current system, determining how well it meets the needs of the organization, and studying the feasibility of changing or replacing the current system.

After completing the initial investigation of the problem, a systems analyst produces a feasibility study to help management decide whether to continue with the system analysis.

Analysis

During the analysis phase the systems analyst gathers documents, interviews users of the current system (if one exists), observes the system in action, and generally gathers and analyzes data to help understand the current system and identify new requirements.

Design

The investigation phase focuses on why, the analysis phase focuses on what, and the design phase focuses on how. In many cases the design phase produces a prototype system&endash;a limited working system or subsystem to give the users and management an idea of how the completed system will work.

Development

After the design is completed, the actual system development can begin. A large part of the development schedule is devoted to testing the system. Members of the system development team perform early testing to locate and eliminate bugs. This initial testing is known as alpha testing. Later, potential users who are willing to work with almost-finished software perform beta testing and report bugs to the developers.

Implementation

When the testing is completed and known bugs have been eradicated, the new system is ready to replace the old one. In some cases the new system is run in parallel with the old system until the analyst is confident that the new system is stable and reliable.

Maintenance

The maintenance phase involves evaluating, repairing, and enhancing the system. For commercial programs, bugs and refinements are handled by occasional maintenance upgrades, typically labeled with incremental version numbers like 1.01 or 2.0a. For large custom systems, maintenance involves a continual process of evaluating and adjusting the system to meet organizational needs. In either case, maintenance usually lasts throughout the lifetime of the system.

Retirement

At some point in the life of a system, ongoing maintenance isn't enough. Because of changes in organizational needs, user expectations, available technology, and other factors, the system no longer meets the needs of the users or the organization. At that point it's time to phase it out in favor of a newer system and begin another round of the system life cycle.

The programmer depends on tools and ideas developed by computer scientists&endash; professionals who work in the academic discipline called computer science. Computer science is a relatively new discipline with ties to electrical engineering, mathematics, and business.

Many computer scientists prefer to call the field computing science, because it focuses on the process of computing rather than on computer hardware. Some areas of specialization within computer science&endash;database management, graphics, artificial intelligence, and networks, for example&endash;provide academic underpinnings for specific categories of computer applications.

Other branches of computer science deal with concepts that can apply to almost any type of computer application. These include:

•  
• Computer theory. The most mathematical branch of computer science, computer theory, applies the concepts of theoretical mathematics to computational problems.
• Algorithms. Many computer scientists focus on algorithms&endash;the logical underpinnings of computer programs.
• Data structures. If algorithms describe the logical structure of programs, data structures determine the logical structure of data. Data structures range from simple numeric lists and tables (called arrays) to complex relations at the core of massive databases.
• Programming concepts and languages. Programming language specialists strive to design better programming languages to make it easier for programmers to turn algorithms into working software.
• Computer architecture. Straddling the boundary between the software world of computer science and the hardware world of computer engineering, computer architecture deals with the way hardware and software work together.
• Management information systems. Management information systems (MISs) are part computer science, part business. MIS specialists apply the theoretical concepts of computer science to real-world, practical business problems.
• Software engineering. Software engineering is a relatively new branch of computer science that attempts to apply engineering principles and techniques to the less-than-concrete world of computer software.

Software Problems

According to one survey, 75 percent of all system development undertaken in the United States is either never completed or, if it is completed, is not used.

Although software prices rise, there's no corresponding increase in the reliability of software. Ever since Grace Hopper pulled a moth from the Mark I's relay, bugs have plagued computers, often with disastrous consequences.

Software errors can take a variety of forms, including syntax errors, logic errors, clerical errors, capacity errors, and judgment errors. According to one study, 15 to 20 percent of attempts to remove program errors actually introduce new errors!

Software Solutions

Computer scientists and software engineers are responding to reliability and cost problems on four main fronts:

• Programming techniques. So far, structured programming is the best known and most successful technique for increasing programmer productivity and program reliability.
• Programming environments. Today's best programming tools include sophisticated text editors, debuggers, record-keeping programs, and translators, all interwoven into a seamless graphic work environment. In recent years CASE (computer-assisted software engineering) tools have emerged, allowing analysts and programmers to automate many of the tedious and error-prone steps involved in turning design specifications into programs.
• Program verification. Software engineers would like to be able to prove the correctness of their programs in the same way mathematicians prove the correctness of theorems. Computer scientists have developed program verification techniques that work well for small programs. Unfortunately these techniques don't work with the complex commercial programs people depend on today.
• Clean-room programming. One new experimental approach to software development is modeled after microchip manufacturing techniques. Clean-room programming combines formal notation proofs of correctness and statistical quality control with an evolutionary approach to programming.
• Human management. Project management techniques from business and engineering have been applied successfully to many software engineering projects. These human management techniques have more to do with person-to-person communication than with programmer-to-machine communication.

Software engineers have failed to keep up with the fast-paced evolution in computer hardware, and it's still incredibly difficult to produce reliable, cost-effective software.

algorithm, alpha testing, applets, assembler, assembly language, beta testing

CASE tools, coding, compiler, component software, computer architecture, computer science, control structure

data structure, fourth-generation language (4GL), high-level language, information system, interpreter

logic error, machine language, macro (scripting) language, management information systems (MIS), module (subprogram)

object-oriented programming (OOP), programming, program verification, prototype, pseudocode

software engineering, stepwise refinement, structured programming, syntax error, system life cycle, systems analyst

testing, top-down design, visual programming

 Computer Literacy On-Line

Shelley Cashman Site | SAM | WebCT | Syllabus | Lecture Outline | Lab Assignments | Glossary | Helpful Links | Home