13 Jul 2006CSE403, Summer'06, Lecture10 Lifecycle Architecture Review: Preliminary Feedback Valentin Razmov.

Slides:



Advertisements
Similar presentations
Software Engineering Key design concepts Design heuristics Design practices.
Advertisements

General OO Concepts and Principles CSE301 University of Sunderland Harry R. Erwin, PhD.
Lecture 9 Improving Software Design CSC301-Winter 2011 – University of Toronto – Department of Computer Science Hesam C. Esfahani
High Quality Code – Style Matters  Chapter 5. Design in Construction  Chapter 31. Layout and Style Software Construction by Jeff Nogy.
(c) 2009 University of California, Irvine – André van der Hoek1June 13, 2015 – 21:42:16 Informatics 122 Software Design II Lecture 8 André van der Hoek.
10 Aug 2005CSE403, Summer'05, Lecture 15 Lecture 15: Configuration Management, Software Maintenance, and Code Reviews (Part I) Valentin Razmov.
1 Jul 2005CSE403, Summer'05, Section 02 Section 02: Life Cycle Architecture Review Valentin Razmov.
The Software Design Process CPSC 315 – Programming Studio Fall 2009.
15 Jul 2005CSE403, Summer'05, Lecture 10 Lecture 10: Incremental Releases Valentin Razmov.
(c) 2010 University of California, Irvine – André van der Hoek1June 29, 2015 – 08:55:05 Informatics 122 Software Design II Lecture 8 André van der Hoek.
13-Jul-15 Refactoring II. Books Design Patterns is the classic book by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides Basically a catalog.
3/15/05H-1 © 2001 T. Horton CS 494 Object-Oriented Analysis & Design Evaluating Class Diagrams Topics include: Cohesion, Coupling Law of Demeter (handout)
CS 4240: The OO Paradigm Revisited Readings: Chap. 1 of Design Patterns Explained OO (some review) Coupling, cohesion.
Design II Today: Design Principles…can we define them intro.12.ppt CS 121 “Ordering Chaos” “Mike” Michael A. Erlinger.
1/19 Component Design On-demand Learning Series Software Engineering of Web Application - Principles of Good Component Design Hunan University, Software.
“Enhancing Reuse with Information Hiding” ITT Proceedings of the Workshop on Reusability in Programming, 1983 Reprinted in Software Reusability, Volume.
Ch:10 Component Level Design Unit 4. What is Component? A component is a modular building block for computer software Because components reside within.
SOFTWARE DESIGN (SWD) Instructor: Dr. Hany H. Ammar
CSE 331 SOFTWARE DESIGN & IMPLEMENTATION MIDTERM REVIEW Autumn 2011.
© 2004 Capgemini - All rights reserved SOLID - OO DESIGN PRINCIPLES Andreas Enbohm, Capgemini.
CSSE 374: More GRASP’ing for Object Responsibilities
SWE © Solomon Seifu ELABORATION. SWE © Solomon Seifu Lesson 12-5 Software Engineering Design Goals.
CSE 403, Spring 2008, Alverson Software Design “There are two ways of constructing a software design: one way is to make it so simple that there are obviously.
Incremental Design Why incremental design? Goal of incremental design Tools for incremental design  UML diagrams  Design principles  Design patterns.
CS 4233 Review Feb February Review2 Outline  Previous Business – My.wpi.edu contains all grades to date for course – Review and contact.
SE-2811 Software Component Design Week 1, Day 2 (and 1-3 and 2-1) SE-2811 Dr. Josiah Yoder Slide style: Dr. Hornick 1.
06 Jul 2006CSE403, Summer'06, Lecture08 Lecture 08: Requirements Gathering Techniques (Part II) Valentin Razmov “The goal of requirements engineering is.
05 Jul 2006CSE403, Summer'06, Lecture07 Administrivia Informal feedback meetings with LCO groups FantasySportsLeague: still to come today Individual assignment.
Software Design Patterns Curtsy: Fahad Hassan (TxLabs)
High Cohesion Low Coupling Old Standards for Object Oriented Programming.
The Strategy Pattern SE-2811 Dr. Mark L. Hornick 1.
Design Patterns: Elements of Reusable Object- Orientated Software Gamma, Helm, Johnson, Vlissides Presented By: David Williams.
Five design principles
Design Patterns Introduction
SOFTWARE DESIGN AND ARCHITECTURE LECTURE 31. Review Creational Design Patterns – Singleton Pattern – Builder Pattern.
11 Jul 2005CSE403, Summer'05, Lecture 08 Lecture 08: Best Practices for Software Design (Part I) Valentin Razmov.
CS 4240: Rethinking Some OOP Ideas and Terms for OOA&D Readings: Chap. 8 in Shalloway and Trott (referred to as S&T in these slides) Wikipedia on information.
Software Design 1.1 CPS 108, Spring 2006 l Object oriented programming and design, we'll use Java and C++  Language independent concepts including design.
Design and Planning Or: What’s the next thing we should do for our project?
Evaluating an Object-Oriented Design ©SoftMoore ConsultingSlide 1.
Design. Practices Principles Patterns What are the characteristics of good design? What are good solutions to common design problems? How do we go about.
Design Patterns in Context ©SoftMoore ConsultingSlide 1.
Principles of Object Oriented Design
High Quality Code – Style Matters  Design in Construction  Layout and Style Software Construction by Jeff Nogy.
Component Design Elaborating the Design Model. Component Design Translation of the architectural design into a detailed (class-based or module- based)
An object's behavior depends on its current state. Operations have large, multipart conditional statements that depend on the object's state.
Duke CPS Programming Heuristics l Identify the aspects of your application that vary and separate them from what stays the same ä Take what varies.
07 Jul 2006CSE403, Summer'06, Lecture10 Lecture 10: Core Principles and Best Practices for Software Design (Part I) “Treat design as a wicked, sloppy,
05 Jul 2006CSE403, Summer'06, Lecture08 Lecture 08: Techniques for Gathering Requirements Valentin Razmov “The goal of requirements engineering is to develop.
09 Aug 2006CSE403 Summer'06 Lecture 19b Lecture 19: Software Quality (Part II) Valentin Razmov Conway’s Law: “The structure of a computer program reflects.
Microsoft Advertising 16:9 Template Light Use the slides below to start the design of your presentation. Additional slides layouts (title slides, tile.
Beginning Software Craftsmanship Brendan Enrick Steve Smith
Deliverables: Zero-Feature Release Build process, installation process, code repository, automated testing framework, bug tracking system Maybe no tests.
14 Jul 2005CSE403, Summer'05, Lecture 09 Lecture 09: Fundamental Principles and Best Practices for Software Design Valentin Razmov.
27 Jul 2006CSE403, Summer'06, Lecture 15 Midterm Exam Statistics Other statistics: Average: 40.6 Median: 42.3 Std Dev: 6.2 Max: 46.5 Min: 28 Easiest Problems:
Mantas Radzevičius ifm-2/2
Best Practices for Software System Design
Lecture 11: Scheduling, Estimation, and Prioritization
Adaptive Code Umamaheswaran Senior Software Engineer
Component-Level Design
lecture 08, OO Design Principle
Beta Release Retrospective
Lecture 03: Software Lifecycle Models
Lecture 09: Software Architecture (Part I)
Software Design Lecture : 14.
CSE 303 Concepts and Tools for Software Development
Questions First On class? On project? On material we’ve discussed?
Informatics 122 Software Design II
Questions First On class? On project? On material we’ve discussed?
Lecture 07: Team Environment Issues (Part I)
Presentation transcript:

13 Jul 2006CSE403, Summer'06, Lecture10 Lifecycle Architecture Review: Preliminary Feedback Valentin Razmov

13 Jul 2006CSE403, Summer'06, Lecture10 Lecture 10: Core Principles and Best Practices for Software Design (Part II) “Treat design as a wicked, sloppy, heuristic process. Don’t settle for the first design that occurs to you. Collaborate. Strive for simplicity. Prototype when you need to. Iterate, iterate, and iterate again. You’ll be happy with your designs.” -- Steve McConnell, Code Complete (2 nd ed.), Ch. 5 Valentin Razmov

13 Jul 2006CSE403, Summer'06, Lecture10 Outline Best practices for software design Time-tested software design principles With examples Valentin Razmov

13 Jul 2006CSE403, Summer'06, Lecture10 Resources “Code Complete”, 2 nd ed., by Steve McConnell Ch. 5: “The Pragmatic Programmer”, by Andrew Hunt and David Thomas Ch. 2 (section 7), Ch. 5 (section 26) “Agile Software Development – Principles, Patterns and Practices”, by Robert C. Martin See handout “Design Patterns Explained”, by Alan Shalloway and James Trott “On the Criteria to be Used in Decomposing Systems into Modules”, by David Parnas Valentin Razmov

13 Jul 2006CSE403, Summer'06, Lecture10 Best Practices for Software Design (discussed previously) Create at least three independent designs and choose the best one among them. Keep it simple (a.k.a. KISS principle). Ask yourself how you may test your components. Do not invest too much into visualizing early designs – they will change substantially. Learn to use design patterns. Consider if there are single points of failure or bottlenecks in your designs. Use abstractions as much as possible. Encapsulate changing components; fix the interfaces between them. Favor composition over inheritance. Valentin Razmov

13 Jul 2006CSE403, Summer'06, Lecture10 Principles for Good Design: Loose/Weak Coupling Avoid unnecessary dependencies between modules. Law of Demeter: “Any method of an object should call only methods belonging to itself, to any parameters that were passed in to the method, to any objects it created, or to any directly held component objects.” Example: What is wrong with the following code? public void showBalance (BankAccount acct) { Money amt = acct.getBalance(); printToScreen (amt.printFormat()); } Valentin Razmov

13 Jul 2006CSE403, Summer'06, Lecture10 Principles for Good Design: Single Responsibility Principle Also, principle of strong cohesion “A class should have only one reason to change.” “God object” metaphor Example 1: Not storing state in a GUI class. Model-View-Controller (MVC) pattern helps to avoid this. Example 2: How is the principle violated below? interface Modem { public void dial (String pno); public void hangup(); public void send (char c); public char recv(); } Valentin Razmov

13 Jul 2006CSE403, Summer'06, Lecture10 Principles for Good Design: Open-Closed Principle “Software entities (classes, modules, functions, etc.) should be open for extension but closed for modification.” Example: Extending an abstract class (with as many new subclasses as needed) rather than modifying an existing class to accommodate each new addition. The designer chooses what changes to anticipate and what parts of the system to “fix” (and assume that they won’t change). Valentin Razmov