Workshop: Testes automatizados, Refactoring e Design Patterns
Refactoring to Design Patterns
-
Upload
eric-de-carufel -
Category
Software
-
view
114 -
download
0
Transcript of Refactoring to Design Patterns
Architecture
• Wikipedia– The software architecture of a program or
computing system is the structure or structures of the system, which comprise software components, the externally visible properties of those components, and the relationships between them.
Architecture defined - Decision
• Software architecture encompasses the set of significant decisions about the organization of a software system– Selection of the structural elements and their interfaces by which a
system is composed– Behavior as specified in collaborations among those elements– Composition of these structural and behavioral elements into larger
subsystems– Architectural style that guides this organization
Booch, Kruchten, Reitman,
Bittner, and Shaw
Architecture defined - Irreversibility
• Architecture establishes the irreversible context for design and implementation
architecture
CODEimplementation
design
Architectural decisions are the most fundamental decisions; changing them will have significant ripple effects because they
are hard to reverse
Architect defined - Irreversibility
• Architect’s most important tasks is to remove architecture by finding ways to eliminate irreversibility in software designs
Martin Fowler
Design challenges
• Design is non-deterministic– Not a repeatable processes that are guaranteed to produce predictable results
• Design techniques tend to be “heuristics”– “rules of thumb”– “things to try that sometimes work”
• Design is an iterative process– Sloppy process– About trade-offs and priorities– Involves trial and error
Fundamentals heuristics
• Crisp abstractions– Keep Your Design Modular– Aim for Strong Cohesion
• Clear Separation of Concerns – Stratification
• Accommodate human cognitive limitations
• Balanced distribution of responsibilities– Find Behavior and Real-World Objects
• Keep Coupling Loose– Hold connections among different parts to a minimum – Formalize Class Contracts– Encapsulate Implementation Details
Fundamentals heuristics
• Choose simple solution– No extra parts (TDD enforce this)– Avoid Failure– Consider Using Brute Force
• Design for Test• Identify Areas Likely to Change
– Extensibility, Plugins, IOC, DI• Look for proven solution
– Patterns
Patterns defined
• A pattern is a proven solution to a common and recurring problem
• A pattern codifies specific knowledge collected from experience in a domain
• A pattern resolves forces in context• All well-structured systems are full of patterns
• http://www.hillside.net
Patterns raise the level of abstraction
• For a developer the standard design elements are objects – Everything is an object
• For an architect the standard design elements are patterns
Patterns creates a vocabulary
• “Everything is an object” is like an architect summing up a house by saying “Everything is a room”– Big room with high voltage outlets and a sink to cook– Small room upstairs to sleep
• Room follow patterns and special names are created to describe it– Kitchen– Bedroom
Patterns simplifies communication
• It enables packing a huge amount of information into a short sentence– Three-bedroom, two-bath house with an open-plan
kitchen
Patterns are proven solutions
• Not all combinations of design elements are practical
• Bedroom and bathroom are separated– Bathrooms have specialized and expensive
infrastructure requirements– Bathroom require maximum privacy while
bedroom can be share• Bathtub and toilet end up in the same room
– Both require the same infrastructure
Patterns avoid silly mistake
• Putting a toilet next to a refrigerator• Putting dishwasher next to a bathtubs
Patterns and software design
• Starting in the 1990s software patterns were applied in many ways with success– Design Patterrns (Gang of four 1994)– Enterprise architecture (Fowler 2002)
Layered Architecture
• Common technique to break apart complicated software system into partition in which each partition is at a particular level of abstraction
• A layer is a cohesive and tightly coupled partition that depends only on the layers below
• The most simple but also the most important enterprise application patterns
• The hardest part of a layered architecture is deciding what layers to have and what the responsibilities of each layer should be
PresentationPresentation
InfrastructureInfrastructure
Layers
Domain LogicDomain Logic
Patterns
• Use Factories to delegate the production of objects.
• Use Decorators to avoid hierarchy explosion.• Use Proxies to control access to objects.• Use Strategies to pass algorithms to objects.• Use Commands to pass requests to objects.• Use Template Method to delegate parts of an
algorithm• Use the Composite Pattern to treat objects and
collections uniformly.
28
The end
• Remember– Pattern for common naming– Pattern to solve well known problem– Watch out for complexity
• Eric De Carufel– [email protected]– http://blog.decarufel.net– http://pyxis-tech.com
• Questions?