Agile Design.

Slides:



Advertisements
Similar presentations
Modular Design Using Subroutines (functions later)
Advertisements

Design Validation CSCI 5801: Software Engineering.
Unit 6 Assignment 2 Chris Boardley.
Procedural programming in Java
COMPSCI 105 S Principles of Computer Science 12 Abstract Data Type.
Systems Analysis, Prototyping and Iteration Systems Analysis.
Lecture 9 Improving Software Design CSC301-Winter 2011 – University of Toronto – Department of Computer Science Hesam C. Esfahani
SOLID Object Oriented Design Craig Berntson
Object-Oriented Metrics. Characteristics of OO ● Localization ● Encapsulation ● Information hiding ● Inheritence ● Object abstraction.
To Be Explicit Eric Avery Software Design Classes, Objects, Instantiation – clear as mud???????? How easy can your design be changed? VERY.
Debugging CPSC 315 – Programming Studio Fall 2008.
Object-Oriented Metrics
Lecture 4A: Modular Design IT 202—Internet Applications Based on notes developed by Morgan Benton.
Software Development Overview CPSC 315 – Programming Studio Spring 2009.
Software Development Overview CPSC 315 – Programming Studio Spring 2008.
Programmable Logic Controllers (PLCs) This course deals with PLCs, Programmable Logic Controllers. PLCs are the industrial computer/controllers that are.
Test-Driven Development “Test first, develop later!” –OCUnit.
Xenios Papademetris Departments of Diagnostic Radiology and Biomedical Engineering Yale University School of Medicine.
1 EECS 231 ADVANCED PROGRAMMING. 2 Staff Instructor Vana Doufexi Ford Building, 2133 Sheridan, #2-229 Teaching Assistant.
© Janice Regan, CMPT 128, Jan CMPT 128 Introduction to Computing Science for Engineering Students Creating a program.
CLASS DESIGN PRINCIPLES Lecture 2. The quality of the architecture What is a good design? It is the design that at least does not have signs of “bad”.
GENERAL CONCEPTS OF OOPS INTRODUCTION With rapidly changing world and highly competitive and versatile nature of industry, the operations are becoming.
Welcome to OBJECT ORIENTED PROGRAMMIN Date: 10/09/2014 Prepared By Prepared By : VINAY ALEXANDER PGT(CS) KV jhagrakhand.
CSE 303 – Software Design and Architecture
Top-Down Design and Modular Development
Program Design CMSC 201. Motivation We’ve talked a lot about certain ‘good habits’ we’d like you guys to get in while writing code. There are two main.
Modular Programming. Modular Programming (1/6) Modular programming  Goes hand-in-hand with stepwise refinement and incremental development  Makes the.
Facts and Fallacies of Software Engineering (Rob Glass) CSE301 University of Sunderland Discussed by Harry R. Erwin, PhD.
OODP Prudent OO Design. OODP-2 The Pillars of the Paradigm Abstraction Encapsulation Hierarchy –Association, Aggregation –Inheritance Polymorphism.
SWE © Solomon Seifu ELABORATION. SWE © Solomon Seifu Lesson 12-5 Software Engineering Design Goals.
Designing classes How to write classes in a way that they are easily understandable, maintainable and reusable 5.0.
Cs413_design04.ppt Design and Software Development Design : to create a functional interface that has high usability Development : an organized approach.
Software Development Overview CPSC 315 – Programming Studio Spring 2013.
Incremental Design Why incremental design? Goal of incremental design Tools for incremental design  UML diagrams  Design principles  Design patterns.
Elements of OO Abstraction Encapsulation Modularity Hierarchy: Inheritance & Aggregation 4 major/essential elements3 minor/helpful elements Typing Concurrency.
Cmpe 589 Spring 2006 Lecture 2. Software Engineering Definition –A strategy for producing high quality software.
Software Design Patterns Curtsy: Fahad Hassan (TxLabs)
HNDIT23082 Lecture 06:Software Maintenance. Reasons for changes Errors in the existing system Changes in requirements Technological advances Legislation.
CS 1120: Computer Science II Software Life Cycle Slides courtesy of: Prof. Ajay Gupta and Prof. James Yang (format and other minor modifications by by.
Click to add text Systems Analysis, Prototyping and Iteration.
Chapter 9 – Software Evolution 1Chapter 9 Software evolution.
A Future Career. What a computer engineer does. He maintains and updates software, while keeping it user friendly.
Design & Build Agile Development Project. Lecture Roadmap In this session we will cover,  Design – Concepts, Views and notes  Incremental development.
Copyright © , Dennis J. Frailey, All Rights Reserved Day 2, Part 1, Page 1 1/11/2004 Day 2, Part 1 Estimating Software Size Section 2 Calculating.
1 COS 260 DAY 12 Tony Gauvin. 2 Agenda Questions? 5 th Mini quiz –Chapter 5 40 min Assignment 3 Due Assignment 4 will be posted later (next week) –If.
Software Design Derived from Dr. Fawcett’s slides CSE784 – Software Studio Fall 2009.
1 OO Class Design PrinciplesStefan Kluth 3OO Class Design Principles 3.1Dependency Management 3.2The Copy Program 3.3Class Design Principles.
Chapter 10 Software quality. This chapter discusses n Some important properties we want our system to have, specifically correctness and maintainability.
Introduction to Computer Programming Concepts M. Uyguroğlu R. Uyguroğlu.
Designing classes How to write classes in a way that they are easily understandable, maintainable and reusable 6.0.
Portal Software Unit Testing Supporting agile development of Sakai VRE enhancements Graham Klyne Oxford University Computing Service.
Multiplication Find the missing value x __ = 32.
1 Advanced Object- oriented Design – Principles CS320 Fall 2005.
CompSci 280 S Introduction to Software Development
Software Architecture & Difference from Design
Copyright © by Curt Hill
Anne Pratoomtong ECE734, Spring2002
Need for the subject.
Design Tips.
CS240: Advanced Programming Concepts
Unit 6 Assignment 2 Chris Boardley.
Developing Tools for Game Development:
CMSC 345 Programming.
Better Architecture Management Made Easy
Principles of Object-Oriented Design
CS 2704 Object Oriented Software Design and Construction
Top-Down Design & JSP Skill Area Part D
(Software) reuse, is the use of (Software) knowledge, to build new (something) software.
Software Development Overview
Presentation transcript:

Agile Design

Problems with software designs Rigidity Fragility Immobility Viscosity Needless Complexity Needless Repetition Opacity

Rigidity Rigid software is difficult change One change requires mods in multiple modules Changes are more difficult than estimated

Fragility The degree to which it is easy to break the program Small changes generate unexpected side-effects

Immobility The code is not modular enough for reuse

Viscosity Software Viscosity Environment Viscosity When design-preserving methods of extending the software are less easily achieved than changes that are not in concert with the overall design (i.e., hacks are easier than following design) the design has “high viscosity.” Environment Viscosity The process of making changes (e.g., compiling, getting approval, configuration management) can also encourage a “quick-and-dirty” fix, rather than a fix better suited to the long-term maintainability of the system.

Needless Complexity Preparing for unknown extensions Bad Algorithms Overly flexible Bad Algorithms Bad/Out-dated assumptions about system priorities

Needless Repetition Cut and paste is evil in software engineering. How many places does the same processing occur? That is the number of places that changes/fixes must be made Do people understand what the cut and paste? This is how software the literally no one understands enters the system. The same code, with minor changes, makes the minor changes easy to miss.

Opacity How clear is the code Code tends to get less clear as it is modified Code tends to get less clear when you think about something else for a while Code that is clear to you, might not be clear to others