SYSTEM ARCHITECTURAL

PRINCIPLES
PADERES, BRYAN
LUPERA, BILLY JOE
PORLAS, JADE
SEPARATION OF CONCERNS
A guiding principle when developing
is Separation of Concerns. This principle
asserts that software should be separated based
on the kinds of work it performs.
MVVM SOFTWARE DESIGN PATTERN
- This separation helps ensure that the business
model is easy to test and can evolve without
being tightly coupled to low-level
implementation details.
MVC SOFTWARE DESIGN PATTERN
- Separation of concerns is a key consideration
behind the use of layers in application
architectures.
ENCAPSULATION
Encapsulation is a
way to restrict the
direct access to
some components
of an object, so
users cannot access
state values for all of
the variables of a
particular object.
 - Different parts of an application should
use encapsulation to insulate them from other
parts of the application.
Application components and layers should be
able to adjust their internal implementation
without breaking their collaborators as long as
external contracts are not violated.
SINGLE RESPONSIBILITY
The single responsibility principle applies to
object-oriented design but can also be
considered as an architectural principle similar
to separation of concerns.

It states that objects should have only one

responsibility and that they should have only
one reason to change.
BENEFITS OF SINGLE RESPONSIBILITY
PRINCIPLE
•When an application has multiple classes, each of them
following this principle, then the applicable becomes more
maintainable, easier to understand.

•The code quality of the application is better, thereby

having fewer defects.

•Onboarding new members are easy, and they can start

contributing much faster.
•Testing and writing test cases is much simpler
DRY (DON’T REPEAT YOURSELF)
The application should avoid specifying behavior
related to a particular concept in multiple places as
this practice is a frequent source of errors. 

Rather than duplicating logic, encapsulate it in a

programming construct. Make this construct the
single authority over this behavior and have any other
part of the application that requires this behavior use
the new construct.
 " Don't repeat yourself " (DRY) is a principle of
software development aimed at reducing repetition of
software patterns, replacing it with abstractions or
using data normalization to avoid redundancy.

 The DRY principle is stated as "Every piece of

knowledge must have a single, unambiguous,
authoritative representation within a system". 
 “Every piece of knowledge must have a single,
unambiguous, authoritative representation within a system.

The alternative is to have the same thing expressed in two

or more places. If you change one, you have to remember
to change the others”
The aim is to avoid duplication to save yourself time when
you first write the code as well as yourself, or other
people’s time in the future when changes need to be made.
Thank you!