N-tier and oop - moving across technologies
Download as PPTX, PDF3 likes2,607 views
The document discusses n-tier architecture and object-oriented programming (OOP) using a housing analogy, contrasting 'shanty' software with 'mansion' software to emphasize the importance of good software design. It outlines characteristics of well-designed software and the principles of OOP, such as encapsulation, inheritance, and polymorphism, as well as the SOLID principles for maintaining clean code architecture. Ultimately, the author advocates for adopting OOP and n-tier architecture to facilitate the integration of new technologies and improve software development processes.
N-tier and oop - moving across technologies
- 1. N-Tier Architecture & Object-Oriented Programming: Moving Across TechnologiesJon LimjapMVP for C#Senior Developer for ITRS
- 2. AgendaShanties vs. Mansions : Housing as an analogy to software developmentN-Tier Software Application DevelopmentObject Oriented ProgrammingSOLID PrinciplesMigrating and integrating apps to new technology
- 3. Shanties vs. MansionsHousing as an analogy to Software Development
- 4. What do you need to make a shanty?Light materials (e.g., lumber, plywood, GI sheets)Little or no construction skillLittle or no electrical skillDo whatever it takes to make things workCreates a shelter you can live in......but not comfortably so
- 5. What do you need tomake a mansion?Heavy-duty materials (e.g., steel, concrete, high quality wood)Architecture: structural plan, electrical plan, plumbing, sewageCarefully chosen materials and furnitureHighly skilled carpenters, welders, electricians, plumbersCreates the house of your dreams......and provides provisions for future development
- 6. Put them together, what have you got?Where do you find shanties, where do you find mansions?
- 7. SlumsVillage of shanties built on unutilized and undeveloped landNo water lines; deep wells are constructed or water is carried from outside the slumNo sewage; waste is either buried, moved to garbage dumps or thrown into rivers or estuariesNo proper electrical wiring; electrical cables are strewn across a slum
- 8. SlumsLack of infrastructure means health problems, heightened risk of fire and difficulty in moving things and peopleAlso known as “Big Ball of Mud”
- 9. SubdivisionsBuilt on prime real estateWell developed infrastructure means easy access to water, electricity, and sewagePlanning includes provisions for recreational facilities such as parks, playgrounds, etc.
- 10. SubdivisionsEfficient structures and services mean happier residents
- 11. Are your software applications shanties?Is it composed of a single void Main() with 10,000 lines of code?Does it have one function that does 100 unrelated things? For example: it accesses the database, then manipulates a string, then asks a question from the user?
- 12. Are your software applications shanties?When you change one line, do other parts of the program break unpredictably?Do you use copy-paste to add functionality to your code?
- 13. Characteristics of good software designHow should nicely written software look like?
- 14. Characteristics of good software designMinimal complexity designs should be as simple as possibleEase of maintenance code should be easy to read and understandLoose coupling code should have as few dependencies as possible
- 15. Characteristics of good software designExtensibility it should be very easy to add new functionality to your designReusability pieces of code could be reused across one application and even in other applicationsHigh fan-in system is designed to have good use of utility code at lower levels
- 16. Characteristics of good software designLow fan-out code requires as few external code as possible, as a high number of such indicates complexityLeanness the application should only contain functionalities that it needs to run properly, no more and no less
- 17. Characteristics of good software designStratification design systems which you can view at one level without looking too deep into other levelsStandardized code and design should be consistent to increase ease of maintenance
- 18. N-Tier ArchitectureStandard architecture in the software development industry
- 19. N-Tier / N-Layer / MultitierBroad term to describe software infrastructure in the software development industryDescribes dividing an application solution into "layers"Has a physical and logical components
- 20. Physical LayersDescribes arrangement of a broad set of tangible and intangible systemsMay contain one of many components:Application serversDatabasesNetworks (Local/Wide Area/Internet)Services (Web Services, Web APIs)
- 21. Logical LayersDescribes arrangement of code in a particular software applicationTypical components:Domain ObjectsBusiness RulesGraphical User Interface (GUI)Data Access
- 22. How does N-Tier fit into the housing analogy?Physical Layers describe the subdivision – each component describes amenities and facilities in your subdivisionLogical Layers describe your mansion – lower layers represent your plumbing and electrical design, while upper layers represent your appliances and furniture and how they all come together to make a great house
- 23. Object-Oriented ProgrammingLetting your code describe the real thing
- 24. Object-Oriented ProgrammingSoftware development paradigm wherein the problem is modelled into "objects" -- pieces of code containing data describing an object and the behaviour of such objectObjects are defined by "classes". A class contains the definition of the data that an object contains, and its corresponding behaviourSome examples of OO languages: Visual Basic .NET, C++, C#, Java, PHP (starting with version 5)
- 25. Key OOP ConceptsClassThe description of an object in terms of characteristics (attributes) and behaviors (methods)ObjectThe pattern or exemplar being definedInstanceAn actual object existing at runtimeMethodActions that can be performed by an object
- 26. Key OOP ConceptsMessage PassingObjects can invoke other objects’ methods and get their dataEncapsulationDetails of an object that aren’t needed by other objects are hiddenInheritanceSpecific objects can be derived from more general objects, retaining all attributes and/or methodsPolymorphismThe ability to represent an specific object to its more general object
- 27. SOLID Principles
- 28. Single Responsibility PrincipleA class should only have one, and only one reason to change
- 29. Open Closed PrincipleYou should be able to extend a class’s behaviour without modifying it
- 30. Liskov Substitution PrincipleDerived classes must be substitutable for their base classes
- 31. Interface Segregation PrincipleMake fine grained interfaces that are client specific
- 32. Dependency Inversion PrincipleDepend on abstractions, not on concretions
- 33. Migrating and integrating apps to new technologyOOP & N-Tier not only makes this easy, it makes it possible
- 34. Tons of new technologies came to play in the last 5 yearsJSON
- 35. OOP and N-Tier makes technology change possibleEach layer can easily be replacedIntegrity of other layers remainLess reworkEasier to test
- 36. ConclusionWe want mansions, not shanties! Subdivisions, not slums!OOP + N-Tier done properly makes it easier to move across platforms and technologiesOOP + N-Tier is just one of many approaches in developing softwareOOP takes years of practice to get right – start now!
- 37. References2004: McConnell, Steve: Code Complete 2: Microsoft Publishing1999: Foote Brian and Yoder, Joseph : Big Ball of Mud: http://www.laputan.org/mud/2009: Bailey, Derick: SOLID Development Principles in Motivational Posters: http://www.lostechies.com/blogs/derickbailey/archive/2009/02/11/solid-development-principles-in-motivational-pictures.aspx