01-PowerPoint Partitioning and Layering Fundamentals

8/6/2019 01-PowerPoint Partitioning and Layering Fundamentals

1/23

Partitioning and LayeringPartitioning and LayeringFundamentalsFundamentals


2/23

The Basic ProblemThe Basic Problem

Change is a factChange is a fact of lifeof life

RequirementsRequirements

TechnologiesTechnologiesBug FixesBug Fixes

Software Must AdaptSoftware Must Adapt


3/23

Solution: SoftwareSolution: Software LayersLayers

Reduce software couplingReduce software coupling

Minimize the consequences of changeMinimize the consequences of change

Focused Unit Tests to verify changeFocused Unit Tests to verify changeExample of Code RefactoringExample of Code Refactoring


4/23

Fundamental ConceptsFundamental Concepts

DDifference between a type and an objectifference between a type and an object

CComplex typeomplex type

CompositionCompositionInterfaceInterface


5/23

TypeType

class Employeeclass Employee

{{

string name;string name;

void Pay()void Pay()

..

}}

Data

Behavior

Simple Type

Complex

Type


6/23

ObjectObject

Employee emp = new Employee();Employee emp = new Employee();


7/23

Object CompositionObject Composition

class Auto

{

Engine engine;Wheel[4] wheels;

void Drive() {};

}


8/23

class Engine

{

string manufacturer;

int horsepower;

void Start(){};

void Stop(){};

}

class Wheel

{


float tirePressure;

void Turn(){};

}

Object composition introduces dependencies


9/23

Write yourWrite your applications so thatso that

the dependencies of one type onthe dependencies of one type onanother are eliminated oranother are eliminated orminimized.minimized.


10/23

MMake types dependent on type'sake types dependent on type'sbehavior, not its implementation.behavior, not its implementation.


11/23

Unit tests verify that a type'sbehavior is correct.


12/23

InterfacesInterfaces

interface IEngine

{

void Start();

void Stop();

}

interface IWheel

{

void Turn();

}

Interfaces describe behavior, not implementation


13/23

Rewritten Engine, WheelRewritten Engine, WheelClassesClasses

class Engine : IEngine

{


int horsepower;

void Start () {}

void Stop() {}

}

class Wheel : IWheel

{

string manufacturer

float tirePressure;

void Turn();

}


14/23

Interface CompositionInterface Composition

class Auto

{

IEngine engine;

IWheel[4] wheels;

void Drive() {}

}


15/23

Interfaces Hide ImplementationInterfaces Hide Implementation

class Diesel: IEngine

{


int horsepower;

void Start () {}

void Stop() {}

}

class WankelEngine : IEngine

{


int rotationSpeed;

void Start () {}

void Stop() {}

}


16/23

CouplingCoupling

Preserve Essential CouplingPreserve Essential Coupling

Essential SemanticsEssential Semantics

Remove Inessential CouplingRemove Inessential CouplingProgramming ArtifactsProgramming Artifacts


17/23

Electrical AnalogyElectrical Analogy

Wall socketWall socket interfaceinterface removes the inessentialremoves the inessentialcoupling due to the physical shape of plugscoupling due to the physical shape of plugsand appliancesand appliances

An interface cannot remove the essentialAn interface cannot remove the essentialbehavioral coupling of voltage and amperagebehavioral coupling of voltage and amperage

of standard currentof standard current


18/23

Complexity vs. FlexibilityComplexity vs. Flexibility

Interfaces add a level of indirectionInterfaces add a level of indirection

Put interfaces along application fault linesPut interfaces along application fault lines

Hard to refactor out of a bad designHard to refactor out of a bad design


19/23

Interfaces vs. InheritanceInterfaces vs. Inheritance

Favor interface over object compositionFavor interface over object composition

Interface Composition vs. Inheritance?Interface Composition vs. Inheritance?

class RacingCar : HighPerformanceCar : Autoclass RacingCar : HighPerformanceCar : Auto

Static DefinitionStatic Definition

Need to Understand Base Class BehaviorNeed to Understand Base Class Behavior


20/23

"Inheritance Breaks Encapsulation""Inheritance Breaks Encapsulation"

class HighPerformanceCarclass HighPerformanceCar

{{

virtual void Start()virtual void Start()

{{TurnIgnition();TurnIgnition();

Press GasPedal();Press GasPedal();

}}

}}

class RacingCar :class RacingCar :HighPerformanceCarHighPerformanceCar

{{

}}


21/23

InterfacesInterfaces

Avoid Inheriting ImplementationAvoid Inheriting Implementation

Restrict Inessential CouplingRestrict Inessential Coupling

Make Interfaces Easy to ModifyMake Interfaces Easy to Modify


22/23

Design PatternsDesign Patterns

Minimize Dependencies in ImplementationMinimize Dependencies in Implementation

Use Design PatternsUse Design Patterns

Electrical AnalogyElectrical AnalogyDesign to work with 110 or 220 volts?Design to work with 110 or 220 volts?

Use TransformerPatternUse TransformerPattern

Flexibility even with Essential CouplingFlexibility even with Essential Coupling


23/23

SummarySummary

Reduce coupling and dependencies of complexReduce coupling and dependencies of complextypestypes

Use Interface Based DesignUse Interface Based Design

Use Composition rather than ImplementationUse Composition rather than ImplementationInheritanceInheritance

Write unit tests to validate behaviorWrite unit tests to validate behavior

Documents

01-PowerPoint Partitioning and Layering Fundamentals