Forum for Academic Software Engineering Volume 3, Number 7, Fri Nov 19 15:18:03 CST 1993 (FASE # 17) Topics: Re: Teaching OO Using CASE Tools Help for test planning SOFTWARE ENGINEERING CLASSES VIA LIVE SATELLITE BROADCASTS! SE-735 Software Construction with Ada (Jorge Diaz-Herrera) SE-751 Software Verification & Validation (Dr. Auernheimer) SE 732 Software Design (Dr.Firth) SE-756 Software Creation and Maintenance (Dr. Firth) A------------------------------------------------------- From: Mary_Shaw@cs.cmu.edu Subject: Teaching OO Keith, You say, > I taught a senior-level design course last spring, concentrating on OOD > and Smalltalk, and my experience compells me to agree. Whereas many > students caught on early to OO, some never could shake the old > procedural paradigm. Their projects looked like monolithic C > programs, with little objectification; where objects were created, they were > delegated no meaningful resposibilities. Of course, if you taught O-O to the freshmen, then some would never shake the habit, and all their subsequent programs would look like dreary object programs with nothing but objectification anywhere you looked. Yes, it's hard to break the initial habits. But break them you must, if you expect the students ever to be able to select among the design alternatives available to them. Waiting until the senior year is too late. Mary PS: I assume you know about the licensing/certification flap that was going on at ICSE. If not, ask Mario Barbacci where it stands. A------------------------------------------------------- From: "David Budgen" Subject: Using CASE Tools Keith, As a fairly recent subscriber to FASE, I don't know whether the issue of using CASE tools for teaching has already been discussed in these columns, but if it hasn't, I'd be interested to find out what views others take. We have something of a debate going on at present about whether or not it is useful (and financially viable) to use CASE tools with both undergraduate and postgraduate courses in software analysis and design. (So I am talking here of `upper-CASE' tools, possibly used to draw DFDs, ERDs etc.) To summarise as fairly as I can: Camp A argues that: * students should be exposed to CASE tools as a part of their learning experience, and should be encouraged to make use of them; * ideally, these CASE tools should be fairly state of the art, and should be representative of those that they might later encounter in industry. Camp B argues that: * students should be learning about the principles of analysis and design, and while it may be useful to have CASE tools as diagram drawing aids, the added baggage that real CASE tools carry with them (in terms of configuration control etc) impede the learning process; * it takes too long for students to learn to use most commercial CASE tools, and the return is not commensurate with the effort expended; * industrial-standard CASE tools tend to be expensive to licence, and we risk being tied to a vendor. My own past experience (admittedly now three years old), was that students on a group design project taking about six to eight weeks were reluctant to get to grips with the CASE tool, and preferred to use simpler general-purpose drawing tools to record their design model. However, while I incline therefore towards Camp B, I feel that if students had access to fairly simple and user-friendly teaching versions of CASE tools, they might find it helped with constructing and adjusting their models. As I don't have any experience of using this approach, it is difficult to make any systematic appraisal of the options. I'm not aware of any very widely-available `simple' CASE tools, perhaps not helped by the wide variations in design strategies and notations, but I'd be interested to hear if anyone has used such forms, and indeed about the experiences of others in teaching in this area. David Budgen (PS My book `Software Design' is due to be published by Addison-Wesley in December, and I admit that I have ducked the issue of CASE tools in that. I feel that the jury is still out on the whole issue of the benefits that the current generation of tools provides! We also have a paper in the proceedings of the 1993 `Software Engineering Environments' Conference that examines some of our concerns about many current upper-CASE tools.) A------------------------------------------------------- From: kpierce@uc.d.umn.edu (Keith Pierce) Subject: Help for test planning I just finished grading team projects produced in our senior software engineering class, and, once again, I'm not happy with the products. Once again, despite my constant protests in class, most teams skimped on specifications and design, and rushed to coding to "get something running". I post this to ask for help in getting students to view testing more importantly. The conventional attitude of students is "lets run it a few times to see if it works." When it works a few times, they think they are done, and hand in the product. For this last project, several teams submitted voluminous output of a few test runs, but without any annotation of what the test run was supposed to prove. It proved to me only that their software is capable of producing voluminous output. It seems to me that what's missing is any test planning. What should we test for? What cases are likely to find flaws? What is the anticipated output of a test case? How do we verify that actual output matches anticipated output? Is the coverage complete? Test planning ought to start at the specification phase with acceptance and system test plans, continue through architectural design with integration test plans, and on to detailed design with unit test plans. There ought to be tremendous educational value in requiring test plannin of students. In particular, early test planning can clarify specifications, interfaces, etc. Next quarter, I will require test planning in the course project. So I could simply require them to do a test plan before implementation. But they don't know what that means. Where can I find guidance for my students in going about test planning? Standard texts don't seem to help. Our present text, by Schach, never mentions test planning even once. Pressman includes a section on test planning in his outline for a specification document, and says it's important, but then never mentions it again. Beizer, in "System Testing and Quality Assurance", is silent on planning, and seems to imply that serious thinking about testing only begins after implementation (this is inferred from a very quick scan of the text. My apologies if I'm wrong). Any views on implementing independent test teams within a student project? Any help would be appreciated. I'll summarize responses to this newsgroup. Keith Pierce, Professor 327A Heller Hall Department of Computer Science Phone: 218-726-7194 University of Minnesota, Duluth FAX: 218-726-6360 Duluth, MN 55812-2496 email: kpierce@d.umn.edu A------------------------------------------------------- From: jr@sei.cmu.edu (Joel Reed) Subject: SOFTWARE ENGINEERING CLASSES VIA LIVE SATELLITE BROADCASTS! You may be familiar with the Software Engineering Institute (SEI) at Carnegie Mellon University for its state-of-the-art seminars, symposia, prominent faculty and leading technical publications. But did you know the SEI's advanced technical education classes are now being broadcast nationwide to all kinds of technical organizations, on the National Technological University (NTU) Satellite Network? In January, you can choose from four SEI courses. NTU offers academic credit and non-credit registration options for students who participate in the following courses. Each course will be broadcast live and interactively from Carnegie Mellon University. Find out if your organization is a subscriber to the NTU Network. If it is, you may register for the interactive broadcasts as well as videotape the course for later review. ***for more information, contact your site coordinator or call NTU at (303) 495-6425 or to register for credit call (303) 495-6408. ** Look for detailed course descriptions following this post. Course no. Course name Instructor Time/Days Units ------------- ----------- ---------- ---- ----- 17-721, Sec A Software Design Robert Firth 10:30/TR 9 SE 732 SI 17-761, Sec A Software Creation SE 756 SI and Maintenance Robert Firth 2:00/TR 9 17-741, Sec A Software Construction SE 735 SI with Ada J. Diaz-Herrera 10:30/MW 9 17-762, Sec A Software Verification SE 751 SI and Validation Brent Auernheimer 2:00/MW 9 ----------------------------------------------------------------------------- A------------------------------------------------------- From: jr@sei.cmu.edu (Joel Reed) Subject: SE-735 Software Construction with Ada (Jorge Diaz-Herrera) SOFTWARE ENGINEERING CLASSES VIA LIVE SATELLITE BROADCASTS! TITLE: Software Construction with Ada Presented by Jorge L. Diaz-Herrera Live Broadcasts: 10:30am-12:00noon ET, Mondays & Wednesdays, Jan 12 through Apr 27, 1994 Sponsored by: Software Engineering Institute at Carnegie Mellon University via the National Technology University: Advanced Technology & Management Programs ***for more information, contact your site coordinator or call NTU at (303) 495-6425. To register for credit call (303) 495-6408 and refer to class number SE 735-SI. **In the Pittsburgh, PA vicinity, contact Joel Reed at (412) 268-7632 OR email jr@sei.cmu.edu. COURSE DESCRIPTION: Two basic technologies form the core of the topics covered in this course, namely software reuse and the Ada programming language. Reusability, however, depends on the availability of process procedures and analysis and design methods promoting reuse, and on the existence of standard, domain independent bindings (industry or otherwise) for components or subsystems. Therefore, additional topics include domain analysis, object-oriented technology and library mechanisms, concurrency and external (hardware) interfaces. COURSE OBJECTIVES: At the end of the course participants will be able to: --Define technical principles of component-based software development --Have an understanding of design with reuse and design for reuse --Assess linguistic requirements for reusalbe components and why Ada is a viable tool for component-based software development --Provide a sound description of the basic tenets of object-oriented design and its relation to reuse --Prepare concurrent software specifications and design structures in Ada --Be familiar with tools, models and notations to use domain specific component libraries and some existing standard Ada bindings. PREREQUISITES: Working knowledge of the Ada language. However, the course materials include a separate (optional) overview of the language. Knowledge of the software life cycle, software engineering goals and principles and design methodologies. It is desirable that participants have already taken a software design/construction course and that they are familiar with basic object-oriented paradigm concepts. Likely to have three to five years' experience in various aspects of software development and/or software engineering education. COURSE OUTLINE BY TOPICAL AREAS: Software Engineering Principles and Ada Ada Overview Software Construction with Reuse: Fundamental Models Technical Aspects of Software Reuse Component Specification Software Composition Software Construction for Reuse: Ada Components Ada Reuseability Guidelines: Design Ada Reuseability Guidelines: Generics Ada Reuseability Guidelines: Exceptions Ada Reuseability Guidelines: OOT Real-Time Software Construction The Ada Tasking Model Reuse Issues in Concurrency Object-Oriented Concurrency and Distribution Client/Server Model Component Libraries Software Engineering Environments Organizing Component Libraries A------------------------------------------------------- From: jr@sei.cmu.edu (Joel Reed) Subject: SE-751 Software Verification & Validation (Dr. Auernheimer) SOFTWARE ENGINEERING CLASSES VIA LIVE SATELLITE BROADCASTS! TITLE: Software Verification and Validation Presented by Dr. Brent Auernheimer Live Broadcasts: 2:00pm-3:30pm noon ET, Mondays & Wednesdays, Jan 12 through Apr 27, 1994 Sponsored by: Software Engineering Institute at Carnegie Mellon University via the National Technology University: Advanced Technology & Management Programs ***for more information, contact your site coordinator or call NTU at (303) 495-6425. To register for credit call (303) 495-6408 and refer to class number SE 751-SI. **In the Pittsburgh, PA vicinity, contact Joel Reed at (412) 268-7632 OR email jr@sei.cmu.edu. COURSE DESCRIPTION: Software Verification and Validation addressses the theory and practice of ensuring high quality software products. Topics covered include quality assessment, proof of corrrectness, testing, and limitations of verification and validation methods. COURSE OBJECTIVES: After completing this course, you should be able to: --Prepare an effective test plan --Analyze a test plan --Apply systematic integration testing --Prove a module correct --Plan and conduct a technical review PREREQUISITES: Students should have a working knowledge of set theory and predicate calculus. A course in discrete mathematics usually satisfies this requirement. COURSE OUTLINE BY TOPICAL AREAS: Introduction Product Quality (Review) Walkthroughs In-class Review Inspections In-class Inspection Cleanroom Proofs Natural Deduction Invariant Assertions Arrays Procedures Weakest Preconditions Symbolic Evaluation Program Development Review: Mid-term Unit Testing Overview Structural Dataflow Analysis Partition Analysis Coverage Limitations System Testing Integration Performance Analysis Performance Testing Regression Environments, Tools Safety Metrics, Reliability A------------------------------------------------------- From: jr@sei.cmu.edu (Joel Reed) Subject: SE 732 Software Design (Dr.Firth) SOFTWARE ENGINEERING CLASSES VIA LIVE SATELLITE BROADCASTS! TITLE: Software Design Presented by Dr. Robert Firth Live Broadcasts: 10:30am-12:00noon ET, Tuesdays and Thursdays, Jan 13 through Apr 28, 1994 Sponsored by: Software Engineering Institute at Carnegie Mellon University via the National Technology University: Advanced Technology & Management Programs ***for more information, contact your site coordinator or call NTU at (303) 495-6425 or to register for credit call (303) 495-6408 and refer to class number SE 732-SI **In the Pittsburgh, PA vicinity, contact Joel Reed at (412) 268-7632 OR email jr@sei.cmu.edu. COURSE DESCRIPTION: Design is a central activity of software development. This Software Design course covers several differnt methods and languages for expressing designs. The process of assessment is also covered. COURSE OBJECTIVES: After completing this course, students should be able to use at least one method to design large systems. They will know how to choose the appropriate method and notation for a problem class, and will be able to evaluate designs created by others. PREREQUISITES: Students should have a good working knowledge of programming-in-the-small. Experience in designing small systems is helpful. COURSE OUTLINE: 1. The Software Development Process and the Role of Design 2. Classification of Design Methods 3. Basic Principles of Design Methods 4. Statecharts - Description 5. Statecharts - Worked Example 6. MASCOT - Description 7. MASCOT - Worked Example 8. OOD - Description 9. OOD - Worked Example 10. Z - Description 11. Z - Worked Example 12. Comparision and Critique of Design Methods 13. A Brief History of Design Methods 14. Mid-term Review 15. Application Domains and Design Paradigms 16. Domain Analysis and Domain Architecture 17. Information Systems Design - Problems 18. Information Systems Design - Paradigms 19. Real-Time Systems Design - Problems 20. Real-Time Systems Design - Paradigms 21. User Interface Design - Problems 22. User Interface Design - Paradigms 23. Exercise in Domain-Based Design 24. Application Development Systems 25. Designing for Software Reuse 26. Final Review A------------------------------------------------------- From: jr@sei.cmu.edu (Joel Reed) Subject: SE-756 Software Creation and Maintenance (Dr. Firth) SOFTWARE ENGINEERING CLASSES VIA LIVE SATELLITE BROADCASTS! TITLE: Software Creation and Maintenance Presented by Dr. Robert Firth Live Broadcasts: 2:00pm-3:30pm noon ET, Mondays & Wednesdays, Jan 12 through Apr 27, 1994 Sponsored by: Software Engineering Institute at Carnegie Mellon University via the National Technology University: Advanced Technology & Management Programs ***for more information, contact your site coordinator or call NTU at (303) 495-6425. To register for credit call (303) 495-6408 and refer to class number SE 756-SI. **In the Pittsburgh, PA vicinity, contact Joel Reed at (412) 268-7632 OR email jr@sei.cmu.edu. COURSE DESCRIPTION: Software creation is the art of transforming a software design into code. Software maintenance is the act of maintaining existing software, keeping it functioning to the satisfaction of the user. This course describes techniques for performing each of those acts. Topics include alternatives to coding, language concepts, the role of standards and style, the role of tools, performance analysis, regression analysis, and other maintenance-specific subjects. COURSE OBJECTIVES: After completing this course, you should: --Know several aternatives for generating code --Be able to identify good coding style and practices --Know what features of languages assist or inhibit good coding practices --Be able to improve the performance of implemented software --Be familiar with tools to help coding and maintenance --Understand the tradeoffs in maintaining software form PREREQUISITES: Students taking this course should have experience in creating and testing simple programs, and should have seen complex programs. COURSE OUTLINE BY TOPICAL AREAS: 1. Introduction to Software Creation 2. Analyzing Software Designs 3. Building Software Artifacts 4. Implementation Metrics and Costing 5. Software Reuse - Principles 6. Software Reuse - Practices 7. Software Prototyping Systems 8. Application Generators 9. Creating New Software 10. Software Quality Assurance 11. Software Defect Prevention 12. Software Defect Removal 13. Midterm Review 14. Introduction to Software Maintenance 15. Causes and Management of Software Evolution 16. Maintenance Environments and Tools 17. Dealing with Errors 18. Requirements Evolution 19. Technology Evolution - Principles 20. Technology Evolution - Practice 21. Building Long-Lived Software 22. Exercise in Software Rejuvenation 23. Reverse Engineering 24. Software Performance Improvement 25. Software Quality Improvement 26. Final Review E------------------------------------------------------------------- FASE V3 N7 Send newsletter articles to fase-submit@d.umn.edu or fase@d.umn.edu Send requests to add, delete, or modify a subscription to fase-request@d.umn.edu Send problem reports, returned mail, or other correspondence about this newsletter to fase-owner@d.umn.edu or kpierce@d.umn.edu Keith Pierce, Editor Laurie Werth, Advisory Committee Department of Computer Science Dept. of Computer Science University of Minnesota, Duluth Taylor Hall 2.124 Duluth, MN 55812-2496 University of Texas at Austin Telephone: (218) 726-7194 Austin, Texas 78712 Fax: (218) 726-6360 Telephone: (512) 471-9535 Email: kpierce@d.umn.edu Fax: (512)471-8885 Email: lwerth@cs.utexas.edu