ISDP2: Information system development toolkit -UNIT 2 THE PROCESS MODEL

INTRODUCTIONThe key to making the computer system perform business applications is application software. Whether an organization makes its own or buys it, application software must be developed. As a systems analyst (go to Module 2, Unit 6 to refresh your memory about system analysts} you will be directly involved in developing application software. Thus you should know how computer programs are written and used. With the increased use of personal computers, you may be writing short programs for your own use. Many managers who know how to program in a high-level language are finding they are able to write programs that help them do their job. Since application software is vital to every organization, you should have an understanding of what a computer program is and how it is written.OBJECTIVESBy the end of this unit, you should be able toExplain the waterfall model of SDLC developmentExplain the role of programming languages in system design
  • Overview

Programs can be written in machine language, assembler language, symbolic languages, high-level language, or other types of languages. Over the years, there has been a trend toward writing application software in high-level languages. A programming language should possess the following characteristics to be considered high-level:

  1. The language is relatively independent of a given computer system.
  2. Each statement in the language translates into several instructions in machine language.
  1. The language is natural and uses abbreviations and words used in everyday communication.
  1. The language is independent of machine language instructions and other pieces of system software except for the language compiler.
  1. The language is not experimental in nature and exists on more than one computer system.

Since there are over 200 high -level programming languages that meet the above qualifications, it would be impossible to investigate all of them in any detail. This should be covered by your other courses on computer programming. The purpose of this module is to discuss the general approaches to using programming languages as tools for developing information systems.

  • Programming languages

As we have seen in this course, the development of a large piece of software — the ultimate end-goal of system design — is an engineering task, to be approached with the same care as the construction of a big building, for example, and with the same attention to cost, reliability, and maintainability of the final product. Again as we have seen in earlier units, the software-engineering process is usually described as consisting of several phases, variously defined but in general consisting of: (1) identification and analysis of user requirements, (2) development of system specifications (both hardware and software), (3) software design (perhaps at several successively more detailed levels), (4) implementation (actual coding), (5) testing, and (6) maintenance.

Since the early 1980s, increasingly sophisticated tools have been built to aid the software developer and to automate as much as possible, the development process. Such computer-aided software engineering (CASE) tools span a wide range of types, from those that carry out the task of routine coding when given an appropriately detailed design in some specification language, to those that incorporate an expert system to enforce design rules and eliminate software defects prior to the coding phase.

As the size and complexity of software grow, the concept of reuse has becomes increasingly important in software engineering, since it is clear that extensive new software cannot be created cheaply and rapidly without incorporating existing program modules (subroutines, or pieces of computer code). One of the attractive aspects of object-oriented programming is that code written in terms of objects is readily reused. As with other aspects of computer systems, reliability—usually rather vaguely defined as the likelihood of a system to operate correctly over a reasonably long period of time—is a key goal of the finished software product. Sophisticated techniques for testing software have therefore been designed. For example, a large software product might be deliberately “seeded” with artificial faults, or “bugs” if they are all discovered through testing, there is a high probability that most actual faults likely to cause computational errors have been discovered as well. The tools for designing end- user systems are programming languages. Let us look at a little history first.

  • Early languages

Programming languages are the languages in which a programmer writes the instructions that the computer will ultimately execute. The earliest programming languages were assembly languages, not far removed from the binary-encoded instructions directly executed by the machine hardware. Users soon (beginning in the mid-1950s) invented more convenient languages.

COBOL, FORTRAN, and their descendants, such as Pascal and C, are known as imperative languages, since they specify as a sequence of explicit commands, how the machine is to go about solving the problem at hand; this is not very different from what takes place at the machine level. Other languages are functional, in the sense that, programming is done by calling (i.e., invoking) functions or procedures, which are sections of code executed within a program. The best-known language of this type is LISP (List Processing), in which all computation is expressed as an application of a function to one or more “objects.” Since LISP objects may be other functions as well as individual data items (variables, in mathematical terminology) or data structures, a programmer can create functions at the appropriate level of abstraction to solve the problem at hand. This feature has made LISP a popular language for artificial intelligence applications, although it has been somewhat superseded by logic programming languages such as Prolog (Programming in Logic). These are nonprocedural or declarative languages, in the sense that, the programmer specifies what goals are to be accomplished but not how specific methods are to be applied to attain those goals. Prolog is based on the concepts of resolution (akin to logical deduction) and unification (similar to pattern matching). Programs in such languages are written as a sequence of goals. A recent extension of logic programming is constraint logic programming, in which pattern matching is replaced by the more general operation of constraint satisfaction. Again, programs are a sequence of goals to be attained, in this case the satisfaction of the specified constraints.




This unit has introduced you to the programming language environment, which the systems designer must familiarize himself with if he or she is to design a new information system.

SEE ALLAdd a note
Add your Comment