Lecture 18: More Design Work

Lecture 18: More Design Work
CSE 542 – Software Engineering Concepts

What Have We Done? Figured out what clients wants project to do
Elicited client’s needs & wrote into documents Collect important terms & definitions in dictionary Wrote requirements recording work that could occur Be careful with user stories; many never implemented Use cases more reliable, only used when cost justified These requirement documents will drive rest of project

First Design Step

Second Design Step

Classes (usually) are nouns (things); Methods are verbs (actions)
OO Key Concept #1 Classes (usually) are nouns (things); Methods are verbs (actions)

Third Design Step Designing classes next step in process
For each class, start by determining fields from above Link classes that work together so easy to code When done well, coding becomes relatively simple What should be fields & how can we know? Since they are abstract, boundary classes often fields Control classes often fields; something must use it Read text again: look where noun possesses another

Liskov Substitution Principle
Named after inventor – Barbara Liskov Determines if generalization is appropriate Subtypes must be usable anywhere supertype used

LSP In Practice Square is regular geometric shape with 4 sides
Also have rectangles which need length & width Which is subclass and which should be superclass? Rectangle As Superclass Square As Superclass Square Is-A Rectangle Just force equal length & width Reverse untrue: Rectangle Is-A Square Rectangle Is-A Square Easy to use Rectangle as Square Reverse untrue: Square not always usable as Rectangle

Single Responsibility Principle
Goal of every class & method written Make sure that class represents single concept Methods perform single action & not “bucket of mud” Many benefits accrue when code follows SRP Easier to write code, since design becomes simpler More focused results make debugging a snap Modifying design quicker when changes needed

No Free Cheeseburgers Achieving SRP means 1 last step in design
More classes & methods often created by this process But also create smaller, simpler classes & methods Less total time required even with this "extra" step To get SRP, people found CRC cards are easiest 3x5 cards & a brain are all this process takes

CRC Cards Explained Divide 3x5 Card into 3 parts
Class name from UML design document Responsibilities are the methods class will need Collaborations are classes it will interact with

Responsibilities Initially you should start with actions you found
Add facts class knows, since these are getter methods If class should not be responsible, move action Instead, the action placed in class where makes sense Make classes collaborators after action moved Pays off in long run, but may make new classes now

How to know if responsibility logical?
Responsibilities Initially you should start with actions you found Add facts class knows, since these are getter methods If class should not be responsible, move action Instead, the action placed in class where makes sense Make classes collaborators after action moved Pays off in long run, but may make new classes now How to know if responsibility logical?

Seriously! Go Yourself

If the Responsibility Fits
Try each responsibility into following statement Find that statements valid only if responsibility fits The (class name) (responsibility) itself Move actions to class that works in statement The (new class) (responsibility) (old class)

Let’s Try It For Car Which of these responsibilities belong to car
Starts engine Kills engine Changes tires Gets driven Gets washed Changes oil Warns oil is low Reports on fuel level

Reality Is Important… Team rarely keeps project from start to end
Only in smaller groups lacking engineering teams Developers specialize skills & become more efficient Documents transmitting knowledge very important People quit & new people added into on-going projects Course needs to provide real-world experiences Documents must be usable when teammates move on Pickup material using information in Git Handle real changes more than on-boarding grade

Time To Change Partners
Distribute new team lists

How Will You Handle This?

Why do I have to work with [other team]?
What's Next? Why do I have to work with [other team]? What did I do wrong?

Where Does This Apply? Cricket/Baseball Buffalo Weather
Passion Threshold Buffalo Weather Suck Threshold Baseball/Cricket

Where Does This Apply? App’s UI Cricket/Baseball Buffalo Weather

Where Does This Apply? App’s UI Libraries Cricket/Baseball

Where Does This Apply? App’s UI Libraries Use Cases Design
Cricket/Baseball Passion Threshold Buffalo Weather Suck Threshold Baseball/Cricket

Where Does This Apply? App’s UI Libraries Use Cases Design
Anytime you have users Cricket/Baseball Passion Threshold Buffalo Weather Suck Threshold Baseball/Cricket

Win Users & Influence People
Only a few minutes to make first impression Do not lose time by making user read manuals Entice user with an clear, obvious utility Get users to payoff as quickly as possible Make their journey’s first steps obvious Common metaphors make it easy to start Look familiar? This slide is paraphrased from the UI lecture!

Avoid Fear & Loathing Artifacts nearly always written exactly once
Ignore writers viewpoint – they will never use work Focus on the many others reading & using artifacts Save time in long run by using common metaphors The quicker they understand the more they like you Focus on user & avoid annoying questions Remind them that their work will be handed to people less talented than them. If they need to convince the code monkeys of the workability of their design, they lose time

Keep It Simple, Idiot

Keep It Simple

Intuitive Is Key Making users think is preying on their weakness
Time spent thinking == time cursing you out Users assume that everything has a purpose Scroll lock & human appendix still get discussed Users assume a purpose, why else would it exist? Unused methods & parameters create guessing game What is the meaning of method’s return value?

Make It Intuitive Remain consistent when using metaphor: Customer.placesOrder(Order toGo) Customer.knowsAddress() Customer.addToDatabase() Customer.initialize() Slide could just as easily be for classes, UI, use cases, more…

Delegation Delegation improves composition of classes
Goal creating classes & code easier to write, read, & use Not universal solution, but useful additional tool Important for writing code that works as people expect Replace getters & add methods for needed actions Methods can act, but mostly delegate to field's methods Adds (slightly) to code size, but performance unchanged Trade-off worth it, since we write once but use frequently

Delegation Key Concept
Image of Homer Simpson used under Parody & Fair Use exceptions. Original from:

Delegation Example public class FullName { private String firstName; private String lastName; // Constructor, getters & setters also here } public class Student { private FullName name; // Brevity is the soul of wit- Shakespeare public FullName getName() { return name; } // In some other code that exists to demonstrate this point Student student = /* Code to create and initialize a Student instance*/ FullName fName = student.getName(); fName.setLastName("Jingleheimerschmidt");

Replace yuck-inducing getter method…
Delegation Example public class FullName { private String firstName; private String lastName; // Constructor, getters & setters also here } public class Student { private FullName name; // Brevity is the soul of wit- Shakespeare public FullName getName() { return name; } // In some other code that exists to demonstrate this point Student student = /* Code to create and initialize a Student instance*/ FullName fName = student.getName(); fName.setLastName("Jingleheimerschmidt"); Replace yuck-inducing getter method…

Delegation Example public class FullName { private String firstName; private String lastName; // Constructor, getters & setters also here } public class Student { private FullName name; // Brevity is the soul of wit- Shakespeare public void setFirstName(String newName) { name.setFirstName(newName); } // In some other code that exists to demonstrate this point Student student = /* Code to create and initialize a Student instance*/ FullName fName = student.getName(); fName.setLastName("Jingleheimerschmidt"); Replace yuck-inducing getter method… … with method calling field's method

Reducing how much you must understand…
Delegation Example public class FullName { private String firstName; private String lastName; // Constructor, getters & setters also here } public class Student { private FullName name; // Brevity is the soul of wit- Shakespeare public void setFirstName(String newName) { name.setFirstName(newName); } // In some other code that exists to demonstrate this point Student student = /* Code to create and initialize a Student instance*/ FullName fName = student.getName(); fName.setLastName("Jingleheimerschmidt"); Reducing how much you must understand…

Delegation Example public class FullName { private String firstName; private String lastName; // Constructor, getters & setters also here } public class Student { private FullName name; // Brevity is the soul of wit- Shakespeare public void setFirstName(String newName) { name.setFirstName(newName); } // In some other code that exists to demonstrate this point Student student = /* Code to create and initialize a Student instance*/ student.setLastName("Jingleheimerschmidt"); Reducing how much you must understand… …so writing & updating code becomes easier!

Composition + Delegation =
public class FullName { private String firstName; private String lastName; // Constructor, getters & setters also here } public class Student { private FullName name; // Brevity is the soul of wit- Shakespeare public void setFirstName(String newName) { name.setFirstName(newName); } // In some other code that exists to demonstrate this point Student student = /* Code to create and initialize a Student instance*/ student.setLastName("Jingleheimerschmidt");

Composition Key Concept #1
When relationship between classes is Has a(n): Add fields & Delegate actions

Make It Intuitive Easiest to follow when names & usage are parallel String.compareTo(String str) String.compareToIgnoreCase(String str) Slide could just as easily be for classes, UI, use cases, more…

Make It Intuitive Easiest to follow when names & usage are parallel String.compareTo(String str) String.compareToIgnoreCase(String str) String.equals(String str) String.equalsIgnoreCase(String str) Slide could just as easily be for classes, UI, use cases, more…

Make It Intuitive Easiest to follow when names & usage are parallel String.compareTo(String str) String.compareToIgnoreCase(String str) String.equals(String str) String.equalsIgnoreCase(String str) String.regionMatches(boolean iC,String str) String.regionMatchesIgnoreCase(String str) Slide could just as easily be for classes, UI, use cases, more…

Make It Intuitive Easiest to follow when names & usage are parallel String.compareTo(String str) String.compareToIgnoreCase(String str) String.equals(String str) String.equalsIgnoreCase(String str) String.regionMatches(boolean ignoreCase, …) String.regionMatchesIgnoreCase(String str) Slide could just as easily be for classes, UI, use cases, more…

Make Their Lives Easier
[P]erfection is attained not when there is nothing left to add, but when there is nothing left to remove Move to the next slide to better make M. de Sant-Exusperry’s point

Make Their Lives Easier
[P]erfection … is nothing left to remove Discuss concerns over complexity of GUI designs in quizzes; remind students of the quote from the little prince Discuss quizzes (to be handed back at end) and my reasoning for the results

Project teams are unchanged
I Lied… Project teams are unchanged

Lecture 18: More Design Work

Similar presentations

Presentation on theme: "Lecture 18: More Design Work"— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Lecture 18: More Design Work

Similar presentations

Presentation on theme: "Lecture 18: More Design Work"— Presentation transcript:

Similar presentations

About project

Feedback