MEGA programming - Chaims - PowerPoint

Document Sample
MEGA programming - Chaims - PowerPoint Powered By Docstoc
					    CS466: Tools and Processes for
              Software

                   Gio Wiederhold
                  Dorothea Beringer
                 Anca-Juliana Stoica




September 1999     Overview Software Engineering   1
                   Goals, Lectures

Goal:
      » Overview of some important topics of software engineering
      » Basis for future studies - ongoing education
             • UML modeling
             • Design patterns
             • Software development process models
             • Software reuse, component-oriented software
               development
             • Software cost estimation
             • ...
      » Different views, invited speakers




September 1999            Overview Software Engineering             2
                    Sign Up

• check out http://www-db.stanford.edu/cs446




September 1999     Overview Software Engineering   3
                        Assignments
• Modeling with UML
     – Assignment 1: Actors and Use Cases, Domain Model, for an
       electronic bookstore
     – Assignment 2: Design Model and Interaction diagrams for same
       problem as in assignment 1
     – Assignment 3 (reverse engineering): Given a small software package
       and an incomplete use case model, make the interaction diagrams,
       the class diagram, a state chart, and try to model two additional
       features

• Design Patterns
     – Assignment 4: apply and detect design patterns while modeling two
       (three) smaller problems

• Cost Estimation
     – Assignment 5: Develop an estimate for a software product using tools
       and models: getting problem solution, analysis of results, option
       analysis, opportunity analysis, personnel impact, addressing the
       risks, model calibration

September 1999              Overview Software Engineering                  4
                 Books for Assignments

UML modeling:
• "UML distilled", by Martin Fowler, 1997/1999
  or another UML book

Design Patterns:
• "Design Patterns", by Erich Gamma, Richard Helm,
  Ralph Johnson, John Vlissides, 1994
  or another book containing the GoF design patterns




September 1999         Overview Software Engineering   5
                 Assignments: how to

     – Teams of two allowed for some assignments

     – Assignment 4 and 5: plan ahead!

     – Due dates: mostly Monday, yet plan for previous Friday!
       No late days!

     – Modeling assignments: require thinking and redoing. Goal is
       not to have just a model, but to have a good model!




September 1999            Overview Software Engineering              6
         Reading for specific lectures
• "No Silver Bullet: Essence and Accidents of Software
  Engineering", for Sept. 27

• "A Spiral Model of Software Development and Enhancement", for
  Oct. 6

• A case study for the lecture on software reuse organizations, for
  Oct. 13

• "Risk Management for Software Development", for Oct. 16

• "Software Cost Estimation", "Estimating work with use cases", for
  Nov. 17



September 1999           Overview Software Engineering                7
                        NO Silver Bullet...
Why no easy remedies?
• Progress in hardware and thus possibilities for ever
  more complex software

• Inherent characteristics of software (essence):
           »     invisibility, many dimensions, hard to visualize
           »     complexity, non-linear in scaling up
           »     conformity, arbitrary complexity, interfaces
           »     changeability, no classic production, glue, takes over soft
                 parts of processes


• Accidental difficulties:
           » ...


September 1999                  Overview Software Engineering              8
Tools and Processes for Software (1)
What do we need to develop a software system?
• Basic tools: Languages, Compilers, Debuggers
• Basic know how: Basic tools, Language
  features, Algorithms, ...
• More advanced tools: Libraries, Databases,
  Window-systems, Distribution-systems, …
• More advanced know how: Features of
  advanced tools and their languages, Distributed
  architectures, Solutions to specific problems, …


Let’s start developing the new baggage-control system
for the next new airport….
                       or do we need something else?
September 1999      Overview Software Engineering       9
Processes and Tools for Software (2)
no               c o n t r o l,                      i.e. for larger
                        projects
                   ( > a few hours):
          - results not predictable
             - schedule unknown
           - organizational chaos
        - random communication




 project                                       mana
September 1999       Overview Software Engineering                10
Processes and Tools for Software (3)

damaged good
     s
unpredictable and unexpected
          behavior




quality assur
     ance
September 1999   Overview Software Engineering   11
Processes and Tools for Software (4)


   ad hoc handc
      rafting



      engineering
                    - planning
                 - documenting
                      - testing
September 1999     Overview Software Engineering   12
    Risk analysis              Silver Bullets                           Life-cycles

                                    Reuse                                    Design Patterns
  Use-case driven                                      Maintenance
                            IEEE standards                               Evolutionary
    Prototyping                                    SEI PMM
                                                                              Iteravite
                              ISO 9000     User acceptance                         Spiral
     Quality                                                            Paradigms Waterfall
   assessment         Requirements
                                           Frameworks          Component-
                       engineering
    Reviews                                                    management
                  Participative                    Objectory
       Inspection development                                 Configuration-
                                Activities                     management
Requirements Analysis                    Object-oriented
 elicitation                                                    UML
                      Design                                     Booch
        Phases
                           Walkthroughs  Team buildingTesting     Process models
        RAD                                                    CASE-tools
                   Software metrics               Reliability
    Viewpoints                                Milestones                               Modeling
                            Project metrics                           Cost estimation techniques
                      TQM
     September 1999                   Overview Software Engineering                        13
                     Standards (1)

There exist many standards:                    Booch
• Process models, e.g. Spiral model
                                            UML
  of Boehm, Objectory of Rational
• SEI Capability Maturity Model      SEI CMM

• IEEE standards, e.g. requirements
  document,                           IEEE standards

• ISO standards, e.g. ISO 9000 - 9001
                                                         ISO 9000



Many companies have in-house standards:
    – complementing public standards (e.g. ISO 9000)
    – adaptations of public standards, methods and models

September 1999           Overview Software Engineering              14
                 Standards (2)
 Standards describing overall Software Process Maturity




September 1999                             http://www.software.org/quagmire/
                    Overview Software Engineering                      15
                            Standards (3)
http://www.ansi.org/catalog, search for software engineering
•     1: IEEE 610.12-1990 : Standard Glossary of Software Engineering Terminology
•     3: IEEE 1348-1995 : Recommended Practice for the Adoption of CASE
•     4: IEEE 1219-1993 : Software Maintenance
•     5: ANSI Z94.7 -1998 : Engineering Economy
•     7: IEEE 1008-1987 : Software Unit Testing
•     8: IEEE 1028-1988 : Software Reviews and Audits
•     9: IEEE 1063-1989 : Software User Documentation
•     10: ANSI/AIAA R-013-1992 : Software Reliability
•     11: IEEE 1045-1993 : Software Productivity Metrics
•     12: IEEE 1044-1994 : Classification for Software Anomalies
•     15: ANSI/ANS 10.3-1995 : Documentation of Computer Software
•     16: IEEE 828-1990 : Software Configuration Management Plans
•     17: IEEE 829-1983 (R1991) : Software Test Documentation
•     18: IEEE 1042-1987 : Guide to Software Configuration Management
•     19: IEEE 1058.1-1987 : Software Project Management Plans
•     20: IEEE 1061-1993 : Software Quality Metrics Methodology
•     21: ANSI/NISO Z39.67-1993 : Computer Software Description
•     ………………...
    September 1999               Overview Software Engineering                      16
             Dividing up the time-scale
• having milestones, phases, activities
• having models describing it (life-cycle models,
  process models)
• having standards describing or requiring these models
                                           Evolutionary
                                                Iterative     Prototyping
Process models      Life-cycles
                                                     Spiral
                                                      Waterfall
    Milestones
                   Phases                                          Objectory
                                   Activities

Inception
                   Req. elicitation
  Elaboration
                        Analysis                              IEEE standards
    Construction
                            Design
        Transition                                                   ISO 9000
                           Implementation
                                Maintenance
September 1999              Overview Software Engineering                   17
                          Modeling
How do I catch and communicate my thoughts,
 concepts, and plans?

                                                             Patterns
 Modeling
techniques
                              Paradigms                    Design patterns
   Booch                                                  Architecture patterns
     UML                  Object-oriented                        Frameworks
       VDM                 Use-case driven
          Z                     Data driven
                                  Risk driven
                                  Architecture driven
             CASE-tools




September 1999            Overview Software Engineering                     18
                           What - When?
                  Activities                                    Modeling
                                                               techniques
        Analysis
      Design                      Risk analysis                      Booch
Implementation                                                         UML
  Testing                                                                VDM
                                Project reviews
                                                                            Z


                                Process models
              Phases                                             Milestones


                     Inception                        Prototypes
                       Elaboration
                         Construction                            wwwwhh
                             Transition                          when, what, who, where,
                                                                 how, how much
 September 1999                Overview Software Engineering                      19
                       Money - People
A software development project costs money.
A software development project is carried out by people.



                                                                      Viewpoints
  Project metrics
                                RAD
  Cost estimation                                         Team building
                         Prototyping


                                                                  Paradigms
                   Milestones

                                                                Object-oriented
                 Process models                                  Use-case driven

September 1999                  Overview Software Engineering                      20
                               Supermen
                                              Requirements
• What is the problem?                         engineering
                                                                    User acceptance

                                                    Participative
                                                    development      Viewpoints

• What is the best,




                                                                                  Prototyping
                                                               Reviews
  yet appropriate solution?                               Walkthroughs
                                                         Inspection
                                                         Testing

• Bugs, bugs,                                          Quality
                                                     assessment
                 Reliability
                                                         Phases          Milestones


Frameworks             Design Patterns                  Analysis
                                                          Design

September 1999                 Overview Software Engineering                               21
                                       Order
                           Configuration-
  Standards
                            management
                                                            Modeling
                                                           techniques


                                                                      CASE-tools
                            Component-
  Standards
                            management


Process model                         Components

      Cost estimation                                 Frameworks

                   Teambuilding                                   Design Patterns
                                      Reuse
  September 1999                  Overview Software Engineering                     22
 Quality                                                                                                Project
Assurance                                                                                             Management
  quality personnel                                                                                      project leader


                            Risk analysis                                       Life-cycles
                                                    Reuse                           Design Patterns
                          Use-case driven                         Maintenance
                                            IEEE standards                  Evolutionary
                            Prototyping                         SEI PMM
                                                                                 Iteravite
                                              ISO 9000 User acceptance               Spiral
                             Quality                                      Paradigms Waterfall
                           assessment       Requirements
                                                               Frameworks         Component-
                           Reviews            engineering
                                         Participative                            management
                                                                       ObjectoryConfiguration-
                               Inspectiondevelopment Activities
                        Requirements   Analysis                                   management
                                                             Object-oriented
                         elicitation        Design                                  UML
                                Phases                                               Booch
                                                 WalkthroughsTeam building Testing Process models
                              RAD                                                        CASE-tools
                                          Software metrics                 Reliability
                           Viewpoints                         Milestones                     Modeling
                                            Project metrics                 Cost estimation techniques
                                     TQM




                   programmers,
                   developers
                               Software
                              Engineering
  September 1999                          Overview Software Engineering                                                   23
                                                                                                   Business
Engineering
                                                                                                   Sciences
 Sciences


                       Risk analysis                                    Life-cycles
                                               Reuse                        Design Patterns
                     Use-case driven                         Maintenance
                                       IEEE standards                  Evolutionary
                       Prototyping                         SEI PMM
                                                                             Iteravite
                                         ISO 9000 User acceptance                Spiral
                        Quality                                      Paradigms Waterfall
                      assessment       Requirements
                                                          Frameworks          Component-
                      Reviews            engineering
                                    Participative                             management
                                                                  ObjectoryConfiguration-
                          Inspectiondevelopment Activities
                   Requirements Analysis                                      management
                                                        Object-oriented
                    elicitation        Design                                   UML
                           Phases                                                Booch
                                            WalkthroughsTeam building Testing Process models
                           RAD                                                 CASE-tools
                                     Software metrics            Reliability
                      Viewpoints                         Milestones                    Modeling
                                       Project metrics                Cost estimation techniques
                                TQM




                                    Social
                                   Sciences
  September 1999                   Overview Software Engineering                                         24