Pinned

Bitesize software building blocks

Clean code/architecture shorts — In this articles series, I’ll attempt to share coding patterns & work habits that would help produce high-quality software for mid-size projects. Target audience A young startup's requirements change very rapidly. This has a direct impact on code stability. We are willing to risk quality issues in order to complete a feature…

Software Architecture

2 min read

Software Architecture

2 min read

Dec 16, 2022

Managing code complexity

Write simple boring code. — Part of the Bitesize software building blocks series. Rule of thumb Measure code complexity as code is written. Systems are complex, often we’ll need a system expert to understand a subpart behavior. Our role as software engineers is to express those systems' behavior with code. However, we can’t expect SE engineers to become…

Software Architecture

2 min read

Software Architecture

2 min read

May 11, 2022

Managing project structure

Enforce project structure by file naming conventions — Part of Bitesize software building blocks series. Rule of thumb Name files by thier module type, <subject>.<type>.ts It is well known that one of the most challenging tasks in software development is naming things. As the project matures, the codebase grows. Code changes are piling up, and it's not always clear where is…

Software Architecture

2 min read

Software Architecture

2 min read

May 9, 2022

Use-cases - Encapsulate subdomains behavior

Orchestrating commands and queries — Part of Bitesize software building blocks series. Rule of thumb Encapsulate comand and queries behavoirs in use-case modules. In previous posts, I mentioned different modules such as Services, Repositories, Helpers… Each one has a role to play, but we need them all to interact in order to achieve meaningful feature behavior — a command or a query. A Use-case is a module that orchestrates multiple modules into a single logical flow. In other words, use-cases implement the high-level behavior of a system subdomain.

Software Architecture

1 min read

Use-cases - Encapsulate subdomains behavior

Software Architecture

1 min read

Use-cases - Encapsulate subdomains behavior

Orchestrating commands and queries

Part of Bitesize software building blocks series.

Rule of thumb

Encapsulate comand and queries behavoirs in use-case modules.

In previous posts, I mentioned different modules such as Services, Repositories, Helpers… Each one has a role to play, but we need them all to interact in order to achieve meaningful feature behavior — a command or a query.

A Use-case is a module that orchestrates multiple modules into a single logical flow. In other words, use-cases implement the high-level behavior of a system subdomain.

For example, our Auth a subdomain is required to provide features such as:

Registering a user
Login
Reset password

Each of these flows is a use-case. It doesn’t matter how it is triggered, from an API, or a CLI, the behavior is the same.

Example

May 3, 2022

Managing DB interactions

Mange DB interactions with Repositories — Part of Bitesize software building blocks series. Rule of thumb 1. Abstract DB interactions from buisness logic via repositories Repositories are services that encapsulate the DB ORM library. The only way to interact with the DB is via a Repo. Repos roles are - Map Entities into DB persistent form, and vice versa. - Decouple…

Software Architecture

2 min read

Software Architecture

2 min read

Apr 22, 2022

Safely crossing modules boundaries

Improve integration quality by modules input/output strict typing — Part of Bitesize software building blocks series. Rule of thumb Validate data transfer between modules boundaries Different parts of the system communicate with each other in order to complete their tasks. This communication can be done in different patterns (publish/subscribe, HTTP API, direct call...). …

Typescript

2 min read

Typescript

2 min read

Apr 21, 2022

Code quality via static typing — Part 2

Improve code quality by methods input/output strict typing — Part of Bitesize software building blocks series. Rule of thumb Create domain spesific data structures with Value Object Factories Every system has its own domain-specific requirements. Those requirements can be enforced by static typing. However, basic types can go so far. For example, say we need to represent a User, and one of…

Typescript

2 min read

Typescript

2 min read

Apr 19, 2022

Code quality via static typing — Part 1

Improve code quality by methods input/output strict typing — Part of Bitesize software building blocks series. Rule of thumb Strictly type everything by default Javascript is a dynamically typed language. As such, JS code is very flexible & forgiving. This is one of the reasons it is a great choice for fast prototyping and POC projects. The downside, and the main reason…

Typescript

2 min read

Typescript

2 min read

Apr 18, 2022

Internal dependencies injection

Inject internal dependencies into higher-level modules — Part of Bitesize software building blocks series. Rule of thumb 1. Decouple internal depndicies with dependicy injections One of the Service's main roles is to expose behaviors and hide internal details. Such modules are responsible for one thing, i.e a service that wraps our Email provider package. A high-level module would expose behavior…

Software Architecture

2 min read

Software Architecture

2 min read

Apr 16, 2022

Encapsulate functionality in Services

Decouple business logic from dependencies — Part of Bitesize software building blocks series. Rule of thumb 1. Decouple external depndicies from buisness logic 2. Expose behaviors, hide internal details Often our system makes use of external functionality to achieve a feature. This may be a SAAS service, an API, or an open-source library. For example, our system features require…

Clean Code

2 min read