2/2/06;  10/6/06
CONCISE INTRODUCTION TO
SOFTWARE DEVELOPMENT
AN INTERFACE TO THREE INTEGRATED ONLINE PRESENTATIONS

"Many people tell the story of the CEO of a software company who claimed that his product would be object-oriented
               because it was being written in C++ [Java, Smalltalk, etc.]. Some tell the story without knowing that it is a joke."
-Adele Goldberg

"We can write good or bad programs with any tool.
Unless we teach people how to design, the languages matter very little."
-David Parnas

In its "most fundamental form", software development is the "programming" of a computer (although the word "programming" is actually a misnomer for the current strategies for software development!  "Modeling" is a more accurate term, as well will see during this presentation.).   Nicholas Werth, the designer of the Pascal programming language, said that a program consisted of its algorithm (the detailed method of solution) and its data structures (the way associated data is organized). This basic view was the foundation of "structured programming", a strategy for efficiently developing software in the 70's and 80's which was based on the systematic, efficient development of algorithms.  In the 80's and 90's the techniques of structured programming were generalized into a higher level strategy called object-oriented software development (OOSD) (often called "object-oriented programming", or object technology), which, although immature, is definitely the "wave of the present AND the future".  Regardless of the strategy (structured programming, OOSD, - or ANYTHING ELSE!), the essence of software development has always been, and always will be, a "divide and conquer" approach in which  complex tasks are "modularized", i.e. divided into smaller, manageable tasks.  In the early days of computing (as well as in current university computer science curricula), programming was essentially an individual undertaking. However, as software became more sophisticated, software development evolved into a group enterprise.   Now "computer programming" has given way to "Software Engineering" which utilizes preexisting software components in the design, production, and maintenance of software as if it were an engineering project involving a team; typically, team members assume responsibility for different modules of the software.  In object oriented software engineering, "programming" has been superseded by "modeling", i.e. modeling real world systems in software (instead of coding "programs"); consequently, the result of object oriented software development is a software "architecture" - NOT a "program"!  The following presentations are intended to illustrate the meaning of "modeling", "software architectures", and "software engineering" and to emphasize the importance of viewing software development in these terms (instead of old fashioned programming).

Regardless of the strategy for developing software, the basic approach is the same: (1) we analyze the system we want to implement (code) in software, (2) we design an abstract model of the system, and (3) finally, we implement our model in a programming language. (This is a simplified view of software development which has many manifestations, but these differences are irrelevent to this presentation.)  The key point that needs to be recognized is that in both the analysis and design phases, a programming language is irrelevant.  (Of course, if we are using an object oriented approach, we must use an object oriented language to implement our model; also, different computer languages have different strengths and weakneses.  Therefore, the language independence of the analysis and design phases is not "strictly" true, but, to keep is simple, we will assume this.)  Therefore, we need a way of representing our language independent design.  There is only one international standard, in the object oriented paradigm,  for doing this, the Unified Modeling Language.

This document is an interface (reader's "doorway") to three integrated, online learning modules which systematically introduce and justify the "object oriented" approach to software development in general as well as our curriculum for teaching this approach in the computer science department at Frostburg State University.  This begins with an overview of the two basic ways to modularized software (structured programming and OOSD) and then, in the last two documents, focuses on the most modern approach, OOSD using the UML for analysis and design.

1. MODULARIZATION OF SOFTWARE introduces the key concept of modularization which is the foundation of every software development strategy.  The separation of monolithic software into highly cohesive, loosely coupled modules characterizes the "divide and conquer" approach to software development. (Note that divide and conquer is the foundation of all problem solving activities.)  This presentation compares the two basic ways to modularize software, "Structured Programming" and "Object Oriented Software Development", in preparation for focusing on the latter, OOSD, in the subsequent two presentations.
   
2. AN INTUITIVE INTRODUCTION TO OBJECT ORIENTED SOFTWARE DEVELOPMENT USING THE UML continues the discussion of software modularization by focusing on OOSD and "modeling".  It attempts to introduce the basic concepts of OOSD in an intuitive way by showing you that you would probably end up with the same way of doing things if you were designing a way to develop software based on the concept of objects.  Hopefully this will emphasize that, although OOSD is a complex task, its basic ideas are simple - and are based on common sense.
   
3. AN ABRIDGED OVERVIEW OF UML CLASS DIAGRAMS completes the introduction to OOSD by giving a concise, abridged, summary of the "constructs" (things from which software is "constructed") of OOSD provided in the UML, the ONLY international standard for representing OOSD.  Although some advanced details are left for subsequent presentations (in more advanced courses), all of the basic features of OOSD using UML class diagrams are documented here; the "class diagram" is one of several UML diagrams - but it is, by far, the most important type, at least for beginners.  In effect, this presentation is a "categorized reference" for (an efficient summary of) everything "introduced" in the preceding presentations.