3/28/24, 3:57 PM
`
`Separation of Concerns | Effective Software Design
`
`(cid:44)(cid:584)(cid:76)(cid:74)(cid:91)(cid:80)(cid:93)(cid:76)(cid:3)(cid:58)(cid:86)(cid:77)(cid:91)(cid:94)(cid:72)(cid:89)(cid:76)(cid:3)(cid:43)(cid:76)(cid:90)(cid:80)(cid:78)(cid:85)
`
`Doing the right thing.
`
`(cid:58)(cid:76)(cid:87)(cid:72)(cid:89)(cid:72)(cid:91)(cid:80)(cid:86)(cid:85)(cid:3)(cid:86)(cid:77)(cid:3)(cid:42)(cid:86)(cid:85)(cid:74)(cid:76)(cid:89)(cid:85)(cid:90)
`(cid:55)(cid:86)(cid:90)(cid:91)(cid:76)(cid:75)(cid:3)(cid:86)(cid:85)(cid:3)(cid:45)(cid:76)(cid:73)(cid:89)(cid:92)(cid:72)(cid:89)(cid:96)(cid:3)(cid:28)(cid:19)(cid:3)(cid:25)(cid:23)(cid:24)(cid:25)(cid:3)(cid:73)(cid:96)(cid:3)(cid:47)(cid:72)(cid:96)(cid:80)(cid:84)(cid:3)(cid:52)(cid:72)(cid:82)(cid:72)(cid:73)(cid:76)(cid:76)
`
`The most important principle in Software Engineering is the Separation of
`
`Concerns (SoC): The idea that a software system must be decomposed into
`
`parts that overlap in functionality as little as possible. It is so central that it
`
`appears in many different forms in the evolution of all methodologies,
`
`programming languages and best practices.
`
`Dijkstra mentions it in 1974: “separation of concerns … even if not
`
`perfectly possible is yet the only available technique for effective ordering of
`
`one’s thoughts”. Information Hiding, defined by Parnas in 1972, focuses on
`
`reducing the dependency between modules through the definition of clear
`
`interfaces. A further improvement was Abstract Data Types(cid:160)(ADT), by Liskov in
`
`1974, which integrated data and functions in a single definition.
`
`In the case of Object Oriented Programming (OOP), encapsulation and inheritance proved to be essential
`
`mechanisms to support new levels of modularity. Design-by-Contract, proposed by Meyer in 1986, provides
`
`guidelines of how to improve interfaces using pre-conditions and post-conditions. Finally, the separation of cross-
`
`cutting concerns is the most important motivation for the proponents of Aspect Oriented Programming (AOP).
`
`https://effectivesoftwaredesign.com/2012/02/05/separation-of-concerns/
`
`1/9
`
`APPLE 1045
`
`1
`
`

`

`3/28/24, 3:57 PM
`
`Separation of Concerns | Effective Software Design
`
`Since the first(cid:160)software systems were implemented, it was understood that it was important for them to be
`
`modular. It is necessary to follow a methodology when decomposing a system into modules and this is generally
`
`done by focusing on the software quality metrics of(cid:160)coupling and cohesion, originally defined by Constantine:
`
`Coupling: The degree of dependency between two modules. We always want low coupling.
`
`Cohesion: The measure of how strongly-related is the set of functions performed by a module. We always want
`
`high cohesion.
`
`All methodologies try to reduce coupling and increase cohesion. Information Hiding reduces coupling by isolating
`
`the details of the implementation of state. ADTs reduce coupling by defining clear and abstract interfaces. An ADT
`
`that specifies in a single definition the set of functions that can be executed on a type is certainly more cohesive
`
`than a global data structure that is modified by external functions.
`
`OOP adds another step in the reduction of coupling with the enforcement of encapsulation and the introduction of
`
`dynamic binding and polymorphism. Inheritance allows us to increase cohesion by defining hierarchies based on
`
`generalization and specialization, in which we can separate the functionality that belongs to the superclass from
`
`its subclasses. AOP provides a solution for the problem of cross-cutting concerns, so that both the aspects and the
`
`affected methods may become more cohesive.
`
`There are many benefits that software developers expect to obtain when making a system more modular, reducing
`
`coupling and increasing cohesion:
`
`Maintainability: A measure of how easy it is to maintain the system. As a consequence of low coupling, there is
`
`a reduced probability that a change in one module will be propagated to other modules. As a consequence of high
`
`https://effectivesoftwaredesign.com/2012/02/05/separation-of-concerns/
`
`2/9
`
`2
`
`

`

`3/28/24, 3:57 PM
`
`Separation of Concerns | Effective Software Design
`
`cohesion, there is an increased probability that a change in the system requirements will affect only a small
`
`number of modules.
`
`Extensibility: A measure of how easily the system can be extended with new functionality. As a consequence of
`
`low coupling, it should be easier to introduce new modules, for example a new implementation for an existing
`
`interface. As a consequence of high cohesion, it should be easier to implement new modules without being
`
`concerned with aspects that are not directly related to(cid:160)their functionality.
`
`Reusability: A measure of how easy it is to reuse a module in a different system. As a consequence of low
`
`coupling, it should be easier to reuse a module that was implemented in the past for a previous system, because
`
`that module should be less dependent on the rest of the system. Accordingly, it should be easier to reuse the
`
`modules of the current system in new future systems. As a consequence of high cohesion, the functionality
`
`provided by a module should be well-defined and complete, making it more useful as a reusable component.
`
`As software developers, after we recognize the importance of SoC, we need to apply this principle in at least two
`
`ways: Understanding the power of our programming language tools and patterns, and learning how to evaluate
`
`and compare different designs in terms of coupling and cohesion.
`
`Tools: For each mechanism in the programming languages we use, we should understand how it can be applied
`
`to reduce coupling and increase cohesion. For example: How encapsulation, dynamic binding, polymorphism and
`
`generic types can be used to separate concerns? Similarly, for each Design Pattern, we can analyze how it helps to
`
`make a system more modular.
`
`Designs: When evaluating and comparing our own design alternatives, it is always useful to think in terms of
`
`coupling and cohesion. Sometimes a design seems to be more complex than others, but this may be a consequence
`
`https://effectivesoftwaredesign.com/2012/02/05/separation-of-concerns/
`
`3/9
`
`3
`
`

`

`3/28/24, 3:57 PM
`
`Separation of Concerns | Effective Software Design
`
`of a better separation of concerns, with fewer dependencies between modules through the definition of additional
`
`layers. Another design may at first appear to have too many classes, but this may be an advantage if each class
`
`becomes more cohesive.
`
`Producing effective software designs requires lots of experience, but principles such as the Separation of Concerns
`
`are essential to perform a great work. So reduce coupling, increase cohesion and good luck!
`
`About Hayim Makabee
`
`Veteran software developer, enthusiastic programmer, author of a book on Object-Oriented Programming, co-founder and CEO
`at KashKlik, an innovative Influencer Marketing platform.
`View all posts by Hayim Makabee →
`
`(cid:59)(cid:79)(cid:80)(cid:90)(cid:3)(cid:76)(cid:85)(cid:91)(cid:89)(cid:96)(cid:3)(cid:94)(cid:72)(cid:90)(cid:3)(cid:87)(cid:86)(cid:90)(cid:91)(cid:76)(cid:75)(cid:3)(cid:80)(cid:85)(cid:3)(cid:40)(cid:54)(cid:55)(cid:19)(cid:3)(cid:43)(cid:76)(cid:90)(cid:80)(cid:78)(cid:85)(cid:3)(cid:55)(cid:72)(cid:91)(cid:91)(cid:76)(cid:89)(cid:85)(cid:90)(cid:19)(cid:3)(cid:54)(cid:54)(cid:43)(cid:19)(cid:3)(cid:54)(cid:54)(cid:55)(cid:19)(cid:3)(cid:58)(cid:86)(cid:77)(cid:91)(cid:94)(cid:72)(cid:89)(cid:76)(cid:3)(cid:57)(cid:76)(cid:92)(cid:90)(cid:76)(cid:3)(cid:72)(cid:85)(cid:75)(cid:3)(cid:91)(cid:72)(cid:78)(cid:78)(cid:76)(cid:75)(cid:3)(cid:40)(cid:54)(cid:55)(cid:19)(cid:3)(cid:43)(cid:76)(cid:90)(cid:80)(cid:78)(cid:85)(cid:3)(cid:55)(cid:72)(cid:91)(cid:91)(cid:76)(cid:89)(cid:85)(cid:90)(cid:19)(cid:3)(cid:54)(cid:54)(cid:43)(cid:19)(cid:3)(cid:54)(cid:54)(cid:55)(cid:19)(cid:3)(cid:58)(cid:86)(cid:77)(cid:91)(cid:94)(cid:72)(cid:89)(cid:76)(cid:3)(cid:57)(cid:76)(cid:92)(cid:90)(cid:76)(cid:21)(cid:3)(cid:41)(cid:86)(cid:86)(cid:82)(cid:84)(cid:72)(cid:89)(cid:82)(cid:3)(cid:91)(cid:79)(cid:76)(cid:3)(cid:87)(cid:76)(cid:89)(cid:84)(cid:72)(cid:83)(cid:80)(cid:85)(cid:82)(cid:21)
`
`(cid:28)(cid:25)(cid:3)(cid:57)(cid:76)(cid:90)(cid:87)(cid:86)(cid:85)(cid:90)(cid:76)(cid:90)(cid:3)(cid:91)(cid:86)(cid:3)(cid:58)(cid:76)(cid:87)(cid:72)(cid:89)(cid:72)(cid:91)(cid:80)(cid:86)(cid:85)(cid:3)(cid:86)(cid:77)(cid:3)(cid:42)(cid:86)(cid:85)(cid:74)(cid:76)(cid:89)(cid:85)(cid:90)
`
`Putcha V. Narasimham says:
`(cid:45)(cid:76)(cid:73)(cid:89)(cid:92)(cid:72)(cid:89)(cid:96)(cid:3)(cid:28)(cid:19)(cid:3)(cid:25)(cid:23)(cid:24)(cid:25)(cid:3)(cid:72)(cid:91)(cid:3)(cid:27)(cid:33)(cid:28)(cid:31)(cid:3)(cid:87)(cid:84)
`
`Very good and comprehensive introduction to Effective Software Design. I too have come to know this set of concepts /
`
`principles in different forms.
`
`While studying General Systems Theory and Systems Thinking (particularly of Ackoff Russell), I felt that the holistic
`
`approach is either missing or not well utilized in SSAD / OOAD. There is too much of emphasis on partitioning, division,
`
`analysis which cannot be applied to the NEW SYSTEM to be created… there is NO READYMADE SYSTEM to be partitioned.
`
`It has to be conceived as a whole…more as a black-box with some capabilities. One can then think of possible composition
`
`(there can be many) of such a system…which is more of HYPOTHESIS than analysis.
`
`https://effectivesoftwaredesign.com/2012/02/05/separation-of-concerns/
`
`4/9
`
`4
`
`

`

`3/28/24, 3:57 PM
`
`Separation of Concerns | Effective Software Design
`
`I refer to Ackoff’s video in which he said this http://www.youtube.com/watch?v=IJxWoZJAD8k. See all the 3 parts. This is
`
`very profound and it operates whether one knows it or not. I am interested in applying it to software design more rigorously.
`
`Feel free to reach me at putchavn@yahoo.com
`
`Best wishes,
`(cid:57)(cid:76)(cid:87)(cid:83)(cid:96)
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Four Myths of Software Evolution | Effective Software Design
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Separation of Concerns « Youry's Blog
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Layers – Separating Software Concerns | Software Patterns Demystified
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)When Silos Make Sense | Form Follows Function
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Separation of concerns | Wordpress XML
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Attention Agile Programmers: Project Management is not Software Engineering | Effective Software Design
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Separation of Concerns | Richards Innovation Blog
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Patterns for the separation of concerns | Project Ramon
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Coping with Change in Agile Software Development | Effective Software Design
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)The End of Agile: Death by Over-Simplification | Effective Software Design
`
`https://effectivesoftwaredesign.com/2012/02/05/separation-of-concerns/
`
`5/9
`
`5
`
`

`

`3/28/24, 3:57 PM
`Separation of Concerns | Effective Software Design
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Why language choice doesn’t matter for your development project : EURA NOVA Blog
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)When Silos Make Sense | Iasa Global
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)“When Silos Make Sense” on Iasa Global Blog | Form Follows Function
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Antifragility and Component-Based Software Development | Effective Software Design
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Re-Post: The End of Agile: Death by Over-Simplification | Youry's Blog
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Quora
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Do SOLID design principles make code slow? | Effective Software Design
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)The SOLID Principles Illustrated by Design Patterns | Effective Software Design
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Unit testing part 2: Getting started with TDD | Ken Bonny's Blog
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Step into OO paradigm | ISA
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Building Better Entity Framework Applications | OnCall DBA
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Six ways to build better Entity Framework (Core and EF6) applications – The Reformed Programmer
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Six things I learnt about using ASP.NET Core’s Razor Pages – The Reformed Programmer
`
`https://effectivesoftwaredesign.com/2012/02/05/separation-of-concerns/
`
`6/9
`
`6
`
`

`

`3/28/24, 3:57 PM
`Separation of Concerns | Effective Software Design
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Agila utvecklare måste även skriva sin kod på ett agilt sätt för att vara helt agila – Robert Forsström's Blogg
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Round and Round - John Scott Yoga Apps
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)About About Pages - John Scott Yoga Apps
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)A robust event-driven architecture for using with Entity Framework Core – The Reformed Programmer
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Refactor The Database Access Code From Being Embedded Within The Backend Website Logic To A Separate Top-level Site Accessed At The Endpoint
`“/API”. Follow The Instructions In The RESTful API Architecture Section Of The CS 465 Full Stack Guide and P
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Separation of Concerns - Dolphintutors
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)COMPUTER SCIENCE | Homework Zones
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Need help with this assignment. - Assignment Online
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Wiring Up The Database | Essay Doyen
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Wiring Up The Database | Grade Villa
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Wiring Up The Database | Study Dale
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Wiring Up The Database | Students Coursework
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Wiring Up The Database | Grade Guruh
`
`https://effectivesoftwaredesign.com/2012/02/05/separation-of-concerns/
`
`7/9
`
`7
`
`

`

`3/28/24, 3:57 PM
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Wiring Up The Database | Homework Doyen
`
`Separation of Concerns | Effective Software Design
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Wiring Up The Database | Assignments Valley
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Wiring Up The Database | Grade Tank
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Wiring Up The Database | Grade Corps
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Wiring Up The Database | Assignments Villa
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Wiring Up The Database | Homework Villa
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Wiring Up The Database | Study Hosts
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Wiring Up The Database | Homework Crafts
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Wiring Up The Database | Essay Corps
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Introduction to MVVM: Refactoring a MVC App Using the MVVM Design Pattern – Develop-tool.com
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)is nested alt a good practice in sequence diagrams? - Get Code Solution
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)Need help with this assisgnment. | GrandHomework
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)HTTP Status Codes Essay | Gotmyhomework
`
`https://effectivesoftwaredesign.com/2012/02/05/separation-of-concerns/
`
`8/9
`
`8
`
`

`

`3/28/24, 3:57 PM
`Separation of Concerns | Effective Software Design
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)SOLVED BY A TUTOR- CS 465 Southern New Hampshire University Module 4 HTTP Status Codes Essay - makeassignmentonline
`
`(cid:55)(cid:80)(cid:85)(cid:78)(cid:73)(cid:72)(cid:74)(cid:82)(cid:33)(cid:3)CS 465 Travlr Getaways JSON Data & Mongoose Functionality FIND Method Project - Writing Geeks
`
`(cid:44)(cid:584)(cid:76)(cid:74)(cid:91)(cid:80)(cid:93)(cid:76)(cid:3)(cid:58)(cid:86)(cid:77)(cid:91)(cid:94)(cid:72)(cid:89)(cid:76)(cid:3)(cid:43)(cid:76)(cid:90)(cid:80)(cid:78)(cid:85)
`
`Blog at WordPress.com.
`
`https://effectivesoftwaredesign.com/2012/02/05/separation-of-concerns/
`
`9/9
`
`9
`
`