NYC June 2 "Design by Contract", Bertrand Meyer presentation 
Author Message
 NYC June 2 "Design by Contract", Bertrand Meyer presentation

(C) Copyright 1997 by Object Developers Group, Inc. All Rights Reserved.

Title:        "Software Design by Contract:
               Object Oriented Software Construction"
Speaker:      Bertrand Meyer, Interactive Software Engineering

Date:         Monday June 2
Time:         7-9pm
Location:     NY Coliseum, Columbus Circle (57th St), NY NY
              as part of the Object Expo 97 Conference (SIGS)
              http://www.*-*-*.com/

Group:        Object Developers Group, Inc
RSVP:         Requested, please use: http://www.*-*-*.com/

              Preregistered people may be sent email with exact room #
Cost:         Voluntary $5 contribution ( http://www.*-*-*.com/ )
              Free to Object Expo attendees.

Abstract:     * Design by contract:
                how to build software that works the first time around
              * How to use inheritance well, and detect misuses
              * Concurrency, distribution, client-server and the
                Internet

Bio:          Bertrand Meyer is one of the pioneers of object technology
              and of modern software engineering for business
              productivity.  As president of ISE, Inc.
              ( http://www.*-*-*.com/ ) he has led the development of
              successful O-O products and libraries totaling many
              thousands of classes.

              He has originated many seminal concepts of object
              technology, including the principles of "Design by
              Contract" for building safe mission-critical software,
              as well as such techniques as repeated inheritance,
              once routines, assignment attempts, etc.

              He has just released the second edition of his classic
              book: "Object-Oriented Software Construction", Prentice
              Hall, 1997 ( http://www.*-*-*.com/ ),
              1296 pages plus CDROM, a definitive and comprehensive
              survey of all aspects of Object Technology, from
              methodology to persistence, concurrency, distribution,
              project management, Design by Contract, analysis methods
              and many design patterns.

              Some of his other books include:
              * "Object Success"
                (presentation of object technology for managers)
              * "Object-Oriented Applications"
                (description of successful O-O projects)
              * "Reusable Software"
                (principles of reusable software design)
              * "Introduction to the Theory of Programming Languages"
              * "Eiffel: The Language"

              Bertrand Meyer is
              * Editor of the Prentice Hall Object-Oriented Series
                    http://www.*-*-*.com/
              * Chairman of the TOOLS conference series
                    http://www.*-*-*.com/
              * Editor of the Object Technology dept of IEEE Computer
                    http://www.*-*-*.com/
              * Associate member of the applications section of the
                   French Academy of Sciences.
              * Frequent keynote speaker at international conferences
              * Consultant for Fortune 500 companies

Doorprizes:   (2) books: "Object-Oriented Software Construction", 2nd ed
              (1) book:  "Object Success"
              (1) book:  "Reusable Software"
              These books are courtesy of Prentice Hall,
              Professional & Technical Reference group,
                    http://www.*-*-*.com/

              (xx copies) C++ Report technical magazines,
              courtesy of SIGS Publications, http://www.*-*-*.com/

Background:   // (comments added by Saul Rosenberg)

              * Design by contract:
                how to build software that works the first time around

              Building software should be an engineering discipline,
              that methodically and predictably produces reliable
              software (examples: ISO 9000, and SEI software maturity)

              We are far from that ideal, and unfortunately many (most)
              large software projects fail on their first few execution
              attempts, due to poor interface design and unforeseen
              interactions.  Indeed, it is expected and the norm for the
              iterative development cycle to include a phase for "real
              world testing and debugging".

              This may be acceptable on many projects, especially small
              ones.  But is quite costly when each attempt involves big
              ticket toys, such as space rockets, airplanes, industrial
              plants, etc.  Example: Ariane 5 rocket disaster (1996,
              $0.5 Billion) lost due to a software debugging interface
              error.

              Most organizations have had fatal software failures on
              early or changed versions. It can be very costly, not just
              when large hardware is involved, but with any major field
              installation/deployment, or when your products are
              embedded in others, etc.

              ((In my opinion, the root cause is that we still have
              difficulty generating reliable large scale software. First
              time failures are a symptom.  Please note that for many
              projects, getting something to work the first time per se
              should not be the goal.  The true effort should be to
              improve our software development process, with the major
              benefit of producing solid systems, that reliably handle
              their environment and robustly respond to unexpected
              changes.  The mark of quality of such a system, and a
              metric that shows that we truly understand how to put them
              together, is that they work all the time, including the
              first time.))

              (Sidebar: yes, as our tools and languages slowly improve
              we're getting better at larger systems, but then again the
              scale of the problems we tackle are also getting larger :)

              Many large scale software programs sold today operate with
              significant lists of known bugs.  Bluntly, this shows that
              software is not [yet] an engineering discipline.  (Also
              indicates frantic vendors doing Beta testing on their
              customers :-).  One of the techniques to reduce problems:

              When large teams are working on critical projects, the OO
              Analysis and Design phases should eventually work their
              way down to fully detailing what each procedure requires
              to operate, and expectations on the state in which it
              leaves the system.

              These may be documented by the use of "preconditions"
              and "postconditions" within the source code.
              * "Preconditions" are necessary (but not sufficient?)
                status conditions before it may be assumed the procedure
                is safe to proceed.
              * "Postconditions" reflect the normal exit status
              Typically, these conditions will be invariants for the
              class at each stage.

              If an exception occurs, it requires some very careful
              coding to be sure the invariants are still preserved.
              (This is a good reason to avoid using exceptions, they
              should be a last resort when there is no other way)

              In Meyer's Eiffel, conditions are part of the language,
              with the bonus that the compiler can assume these
              relationships, and do extra optimizations.

              In C++, conditions are often implemented via the "assert"
              macro, however these either generate fatal error messages
              or hard-to-handle exceptions.  (When exceptions are
              included, how many possible exit paths are there from each
              C++ method in your code?  Does your "comprehensive" test
              program cover each of these paths?  Unlikely!)

              High level "assert" conditions are often mixed with lower
              level "debugging" tests, and thus it is often hard to
              capture the essentials, perhaps for automated testing of
              "use cases" (Jacobson) or Requirements analysis.

              The big ticket failures may grab the headlines, but the
              principles and practices learned from "Design by Contract"
              can be applied at all project sizes, to ensure reliable
              systems that handle both common and infrequent conditions.

Audience:     * Question: Do I need to know or care about the Eiffel
              language to benefit from this session?
              * Answer: No, his talk primarily concerns "OO Software
              Construction", and "Software Design by Contract", to
              produce reliable software.  Eiffel is not the focus.

/\/\/\/\/\/\

To Add / Change / Delete your name from the ODG email list, see
        http://www.*-*-*.com/
Newsletters with meetings info
        http://www.*-*-*.com/

Enjoy the meetings





Mon, 15 Nov 1999 03:00:00 GMT  
 NYC June 2 "Design by Contract", Bertrand Meyer presentation

(C) Copyright 1997 by Object Developers Group, Inc. All Rights Reserved.

**** Meeting Date Change ****

The "Software Design by Contract" presentation by Bertrand Meyer
is changed to >->-> WEDNESDAY, JUNE 4, 7-9PM <-<-<

The Topics remain the same:
   * Design by contract:
     how to build software that works the first time around
   * How to use inheritance well, and detect misuses
   * Concurrency, distribution, client-server and the Internet

Date:         Wed June 4, 7-9pm
Location:     NY Coliseum, Columbus Circle, NY NY
              (where 59th St, Broadway and 8th Ave intersect)
              room number "Mezz 2" (mezzanine? 2)
Cost:         Free.  All are welcome to attend
RSVP:         Appreciated, to http://www.objdev.org/register

Info:         http://www.objdev.org/news

This is part of the Object Expo 97 Conference (SIGS)
http://www.sigs.com/conferences/oeny97

Enjoy
Saul Rosenberg



Tue, 16 Nov 1999 03:00:00 GMT  
 
 [ 2 post ] 

 Relevant Pages 

1. FS: "Eiffel, The Language", book by Bertrand Meyer on eBay

2. Bertrand Meyer ,Sydney Presentation: Fri, 28 Nov, 4-6pm

3. Call to Boycott Bertrand Meyer (C2BBM) in his home town NYC

4. Justification for "design by contract"

5. Justification for "design by contract"

6. how to apply "design by contract"

7. NYC-STUG June meeting 6/17 - Presentation by Gemstone and PocketSmalltalk Tutorial

8. "Reusable Software ..." by B. Meyer

9. Book FS: B.Meyer "Object Success"

10. NYC LOCAL: Tuesday 10 June 2003 Lisp NYC: Kenny Tilton will expound on Alan Kay's "Everything is a cell."

11. NYC LOCAL: Tuesday 10 June 2003 Lisp NYC: Kenny Tilton will expound on Alan Kay's "Everything is a cell."

12. string.join(["Tk 4.2p2", "Python 1.4", "Win32", "free"], "for")

 

 
Powered by phpBB® Forum Software