SlideShare a Scribd company logo

Advanced oop laws, principles, idioms

•Download as PPTX, PDF•
•
Clint Edmonson
Clint Edmonson

Ever heard of the Law of Demeter? How about the Liskov Substitution Principle? This talk introduces key object-oriented laws and principles currently used in our field and provides guidance for their use when building applications on the .NET platform.

1 of 40
Advanced OOP Laws  Principles  Idioms Clint Edmonson Senior Consultant Polaris Solutions clinted@polarissoutions.com
Platinum Sponsors Gold Sponsors Silver Sponsors
what is oop?
Advanced oop laws, principles, idioms
abstraction encapsulation inheritance polymorphism
structural
domain driven design All software can be composed of only four elements: - Value objects - Entities - Services - Modules
separation of concerns Every class and method should have a single responsibility. All its functionality should be narrowly aligned with that responsibility.
the DRY principle Don’t repeat yourself. Don’t repeat yourself. Don’t repeat yourself.
theory of one right place There should be only one right place for a piece of nontrivial of code, and one right place to make a likely maintenance change.
unit of work Define entity families around transactional boundaries and aggregate root entities.
the open-closed principle Software entities (classes, methods, and modules) should be open for extension but closed for modification.
design by contract Fortify your methods through preconditions, post-conditions, and invariant assertions.
Advanced oop laws, principles, idioms
creational
declarative programming Use attributes to describe what you want to happen and leverage a framework will take care of the how.
Advanced oop laws, principles, idioms
the provider model Define a public service façade that uses an private implementation to perform all of it’s work.
the provider model code example
inversion of control Hide implementation details by letting subsystems automatically create their objects as they are needed.
inversion of control code example
dependency injection Declaratively describe dependencies between classes and an IOC framework can automatically instantiate all of them.
dependency injection code example
object:relational mapping Leverage IOC and dependency injection to automatically load entities from your database.
behavioral
principle of scenario driven design All functionality should be driven by usage scenarios.
occam’s razor The simplest solution is usually the best.
the pareto principle For many phenomena, 80% of the consequences stem from 20% of the causes
the law of demeter “Don’t talk to your neighbor’s neighbor!” An object should only call methods and properties belonging to: - Itself - Any parameters passed in - Objects it creates - Child components
principle of least resource usage The minimal amount of computational resources should be used to solve a particular need.
principle of least privilege Provide the minimal level of access necessary for consumers to do their job. Combined with the previous principle… Classes and methods should be as stateless and private as possible.
the liskov substitution principle A derived class should be completely and transparently substitutable for it’s base class.
idempotents Transactional systems should allow the same information to be received multiple times without being reprocessed.
cyclomatic complexity The depth of nested logic should be kept to a minimum.
What are your principles?
Advanced oop laws, principles, idioms
Advanced oop laws, principles, idioms
References Books – – – – – Code Complete - McConnell Domain Driven Design – Evans Effective C# - Wagner Framework Design Guidelines – Cwalina & Abrams Writing Solid Code – Maguire Links – – – – Application Architecture for .NET OO Design Principles Principles of Object Oriented Design SOLID Principles (Wikipedia)
Clint Edmonson Email: clinted@polarissolutions.com Blog: http://www.notsotrivial.net Twitter: @clinted
Advanced oop laws, principles, idioms

More Related Content

Advanced oop laws, principles, idioms

Editor's Notes

  1. Photo credits: http://www.flickr.com/photos/booleansplit
  2. Photo credits: http://www.flickr.com/photos/booleansplit
  3. Comments
  4. CommentsAlso know as “Single Responsibility Principle”Cohesion comes from building systems from simple parts that each perform a single duty with no overlap in responsibilitiesAvoid designing classes with more than one responsibility – this leads to the famous “Blob” and “Swiss Army Knife” anti-patternsBusiness Entities should NOT know how to persist themselves
  5. Comments
  6. CommentsSpend the extra 2 minutes to think about the best place for a class or method, it will pay huge dividends later on (see also “Single Responsibility Principle”)Misplaced code leads to the “Lava Flow” and “Cut & Paste” anti-patternsAn elegant design will “feel” rightAlso known as the DRY principle, or Single Point of Truth
  7. Comments
  8. CommentsAllow for hooks into your code, but don’t allow an opening where a derived or external class can alter the fundamental behaviors or algorithms encapsulated by your codeDon’t provide virtual methods for the core behaviors in your classes, only the places where you want to allow extension or changeEvents are (currently) the safest way to adhere to this principle
  9. CommentsIn the words of Steve McConnell, “Assert thyself!”
  10. Comments
  11. CommentsMakes for swappable implementations – analogous to the windows driver model.
  12. CommentsMakes for swappable implementations – analogous to the windows driver model.
  13. CommentsTypical outside sources are xml configuration files.
  14. CommentsTypical outside sources are xml configuration files.
  15. Comments
  16. Comments
  17. Comments
  18. CommentsDon’t write code unless a use case requires itDon’t write code until you need itDon’t build out excess and unnecessary architecture – let it evolve through iterationsChoose the technology to solve the need – not the other way around (avoid the “Golden Hammer” anti-pattern)
  19. CommentsIn software development terms, the simplest solution is usually the best.Strive for simplicity in architecture and design to minimize system entropy and brittlenessWrite the least amount of code necessary to fix a bug or solve the problem
  20. CommentsYour users will only use a small portion of your application most of the time 80% of the execution time in an application is spent executing only 20% of the code Therefore, 80% of your reported bugs will come from the same 20% of codeFocus on simplifying, optimizing, and fortifying that 20%
  21. “Don’t talk to your neighbor’s neighbor” Encapsulation works best when it’s not circumvented
  22. CommentsAvoid allocating more memory or consuming more CPU than necessary to do the job (see also “Occam’s Razor”) Classes and methods should be as static as possible. If a class or method does not need to maintain state (have any member variables), it should be staticBeware of premature optimization
  23. CommentsClasses and members should be as private as possible - “Hide the plumbing”Exposing the internal mechanisms in your library - (accidentally or on purpose) can provide an opening for incorrect usage, breakage or security breachFailure to do so leads to the “Leaky Abstraction” anti-pattern
  24. CommentsDerived classes should never alter the fundamental behavior described by the contract of the base classShould not behave differently (no extra public properties or methods)Should not throw different exceptionsIf this principle is violated, a unit test should uncover it immediatelyPolymorphism works best when not circumventedAlgorithms should not check the type of an object at runtime to determine appropriate behavior
  25. Comments
  26. Comments
  27. Photo credits: http://www.flickr.com/photos/yozza
  28. Photo credit: http://www.professionalequipment.com/product_images/full/143650big.jpg
  29. Photo credits: http://www.flickr.com/photos/dbking
  30. Comments