Main Navigation Code Engineering Management UX

Appearance

Sidebar Navigation

Algorithms

Search

Beam search

Binary search

Breadth-first search

Depth-first search

Tabu search

Two-pointers

Sorting

Counting sort

Heapsort

Quicksort

Time complexity

Genetic algorithms

Simulated annealing

Graph algorithms

Bellman-Ford algorithm

Dijkstra's algorithm

Floyd-Warshall algorithm

Ford-Fulkerson algorithm

Hungarian algorithm

Kruskal's algorithm

Nearest neighbour

Prim's algorithm

Linear-programming

Newton's method

Simplex

Problems

Boolean Satisfiability Problem

Constraint Satisfaction Problem

Flow cost problem

Graph coloring problem

Halting problem

Knapsack problem

P vs. NP problem

Quadratic Assignment Problem

Scheduling problems

Shortest path problem

Steiner tree problem

Traveling Salesman Problen

Architecture

Representation model

Other

4+1

C4

DFD

Sysml

Requirement diagram

UML

Behaviour-diagrams

Activity diagram

Communication diagram

Interaction overview diagram

Sequence diagram

State machine diagram

Timing diagram

Use Case diagram

Structural-diagrams

Class diagram

Component diagram

Composite structure diagram

Deployment diagram

Object diagram

Package diagram

Paradigms

Declarative Imperative

Design by contract

Object-oriented

Patterns

Blackboard

Microservices

MVC

Observer

Pipe and filter

Principles

ACID

Assets

Readme

Conway's law

DRY

Gall's law

KISS

Lehman's laws

Separation of concerns

SOLID

Twelve-Factor App

Quality Attributes

Availability

Interoperability

Maintainability

Performance

Scalability

Security

Testability

Styles

API

Client-server

Component-based

Finite-state machine

Layered

Publish-subscribe

Service-oriented

Artificial Intelligence

Neural Network

Natural Language Processing

Large-Language Models

Robotic Process Automation

Supervised Learning

Classification

Decision Tree

Regression

Creative coding

Music processing

Cyber security

CIA

Cryptography

Steganography

CWE

IAM

NIST

OWASP

PDCA

STRIDE

Data

Binary

Gray code

Hamming distance

Data structure

Graph

Hash

Heap

Fibonacci Heap

Tree

Database

NoSQL

Column

Document

Graph

Key-Value

RDBMS

Sharding

Glossary

Garbage In, Garbage Out

Data types

Date types

Numeric types

DevOps

CI/CD

Glossary

Pet vs. Cattle

Monorepo

Unit testing

Virtualization

Infrastructure

Cloud

As a Service

Edge Computing

Glossary

Pets vs Cattle

Serverless

Infrastructure as Code

IoT

Load balancing

Virtualization

Network

Glossary

Broad Network Access

Readme

Protocols

Os

Kernel

Telecommunication

Web

Mathematics

Linear algebra

Derivative

Function

Integral

Sets

Vectors

Physics

Energy

Motion

On this page

Separation of concerns

The separation of concern focus on splitting the code into distinct sections.

Suggest a change

Last update:

Pager

Previous pageLehman's laws

Next pageSOLID

Released under the MIT License.

Sorting

Genetic algorithms

Graph algorithms

Problems

Representation model

Other

Sysml

UML

Behaviour-diagrams

Structural-diagrams

Paradigms

Assets

Quality Attributes

Natural Language Processing

Supervised Learning

Binary

Data structure

Heap

NoSQL

Data types

Cloud

Glossary

Glossary

Linear algebra

Physics

Separation of concerns ​

Separation of concerns