Forem: Barrios Freddy

Domain Driven Design.

Barrios Freddy — Wed, 24 May 2023 14:23:50 +0000

Domain-Driven Design(DDD) is a collection of principles and patterns that help developers craft elegant object systems. Properly applied it can lead to software abstractions called domain models. These models encapsulate complex business logic, closing the gap between business reality and code.

These domain experts use company- or industry-standard terminology. In DDD, this vocabulary is called the Ubiquitous Language

I would expect to find corresponding class names in the code.

Bounded Contexts guide you toward thinking of software as a portfolio of models.
Modules help you organize a larger single model into smaller chunks.
Aggregate roots as a technique for organizing small collaborations between a few highly related classes.

In most enterprise systems there are course-grained areas of responsibility. DDD calls this top level of organization a Bounded Context.

Bounded Context to Context Map

A context map encapsulates multiples bounded context

One very important thought about Bounded Contexts: each context owns its own Ubiquitous Language.

Anti-Corruption Layers

An Anti-Corruption Layer (ACL) is another DDD pattern that encourages you to create gatekeepers that work to prevent non-domain concepts from leaking into your model. They keep the model clean.

"At their heart, repositories are actually a type of ACL. They keep SQL or object-relational mapping (ORM) constructs outside of your model."

A System of Single Responsibilities

I've mentioned that DDD provides a pattern language for structuring rich domain models. By implementing these patterns, you get a certain level of adherence to the SRP for free, and that's certainly valuable.

Entities Have an Identity and a Life

An entity is a "thing" in your system. It's often helpful to think about these in terms of nouns: people, places, and, well, things.

"Think of entities as units of behavior rather than as units of data. Try to put your logic in the entities that own them."

Value Objects Describe Things

Value objects are descriptors or properties important in the domain you are modeling.

Value objects are immutable. They are incapable of change once they are created.

"Part of the beauty of value objects is that they describe the properties of entities in a much more elegant and intention-revealing way"

Aggregate Roots Combine Entities

An aggregate root is a special kind of entity that consumers refer to directly. Identifying aggregate roots allows you to avoid over-coupling the objects that comprise your model by imposing a few simple rules. You should note that aggregate roots guard their sub-entities zealously.

The biggest rule to keep in mind is that aggregate roots are the only kind of entity to which your software may hold a reference.

Domain Services Model Primary Operations

Sometimes you have operations or processes that do not have an identity or lifecycle in your domain. Domain services give you a tool for modeling these concepts. They're typically stateless and highly cohesive, often providing a single public method and sometimes an overload for acting on sets.

"When there are a number of dependencies involved in a behavior and I can't find a natural place on an entity to place that behavior, I'll use a service."

Repositories Save and Dispense Aggregate Roots

Repositories represent an in-memory collection, and the conventional wisdom is that you end up with one repository per aggregate root.

Repositories are a good candidate for a super class or what Martin Fowler refers to as the Layer Supertype pattern.

Strategic Design
Describe objects

Core domain

Entities

Tactical Design
"Entities are mutable"
Values objects = unmutables

Aggregate

Repositories(DB) and services(Logic)

https://learn.microsoft.com/en-us/archive/msdn-magazine/2009/february/best-practice-an-introduction-to-domain-driven-design

MongoDB replication: What you need to know

Barrios Freddy — Wed, 12 May 2021 14:34:20 +0000

Database replication is the process of copying data from a database in one server to a database in another one. This protects your information in case of a disaster or hardware failure and improves the reliability and accessibility of the information. Replication provides high availability and redundancy, crucial topics when you manage a huge amount of data.

In MongoDB, this process is done through a replica set which in simple words, it's a group of mongod processes to keep the same data across different servers. A replica set must have three nodes at least. One of them must be the primary and the rest secondary ones. A replication structure can have up to 50 nodes and 7 voting members maximum, more nodes might decrease the performance. But, I think you would not need this quantity of nodes unless you have a global requirement. That is another story.

There are three kinds of MongoDB nodes

Primary

The primary is the member in the replica set that receives write and read operations. But, read operations can be pointed out to secondary nodes changing the configuration at the moment to perform the query. Besides the replica set can have only one primary node at most.
Secondary

The secondary is the node where the data is replicated to maintain a copy. A replica set can have one or more secondary nodes. The clients can not write data to secondary ones, only they can read from them. In certain cases, a secondary node might become a primary node. I’ll talk a little more below. The secondary nodes replicate the primary's oplog(operations log) and apply the operations to their data sets asynchronously. Since the replication is asynchronous, the function of the database can continue if one or more of the members fail.
Arbiter

The arbiter node does not have a copy of the data set and can not become a primary. However, an arbiter participates in elections for primary.

Image 1. Replica set

If the primary node goes down, one of the secondary nodes will become the primary, this through an election, until the original primary node goes online back again. Also, if both secondary nodes are unavailable, the primary node would become secondary and the database will be unreachable. To keep in mind, the primary node receives all write operations and the majority of the read operations. Therefore, the replica set must have a primary node active.

Member election

An election is used to determine which member will become primary. An election is triggered to respond to a variety of events, such as:

Initiating a replicate set
Adding a new node to the replica set
Performing maintenance tasks

The average time before a cluster elects a new primary should not typically exceed 12 seconds. The election algorithm will attempt to have the secondary with the highest priority available. On the other hand, members with a priority value of 0 can not become primary and do not seek election.

Image 2. A secondary node becomes primary

For durability, the write operations have a mechanism to replicate the data in a certain number of nodes and give feedback to the client. This mechanism is called, "Write concern" which consists of a number of data-bearing members that must acknowledge a Write concern before the operation returns as successful. By default, the replica sets have a value of 1 as write concern, therefore only the primary must acknowledge the write before returning write concern acknowledgment. Also, you can increase the number of members required to acknowledge the write operation, as many you want but if the number is high, it increases the latency as the client must wait until it receives the acknowledgment from the number of members specified. On the other hand, you can set a write concern of "majority" which calculates more than half of members to receive its acknowledgment.

What is write concern?

Write concern describes the level of acknowledgment requested from MongoDB for write operations to a replica set. The specified number must be lesser than the number of member nodes. Also, you can set the write concern as “majority” what does it’s to request acknowledgment that the write operations have propagated to the calculated majority of the members. It means, in a cluster of three data-bearing nodes the acknowledgment will be sent to the client after two of them receive the data. By default the primary and one of the secondaries.

What is read preference?

For the read operations, you can specify a read preference that describes how the database routes the query to members of the replica set. By default, the primary node receives the read operation but the clients can specify a read preference to send the read operations to secondary nodes. The following are the options for the read preference.

primary

All read operations come from the primary node
primaryPreferred

Most read operations come from the primary node but if this is unavailable the data would come from the secondary nodes
secondary

All read operations come from the secondary nodes
secondaryPreferred

Most read operations come from the secondary nodes but if none of these are available the data comes from the primary node
nearest

The result of reading operations may come from any of the members of the replica set, it doesn't matter if this is primary or secondary.

To sum up, the process of replicating data across different servers is a good option for high availability and durability. In simple words, replication is the process of creating redundant data to safeguard it. In addition, MongoDB brings this concept to its core, therefore it already has the tools to use it easily.

Thanks for reading!

How to empty an array in JavaScript

Barrios Freddy — Fri, 11 Dec 2020 03:17:55 +0000

The simple way to empty an array in JavaScript is through assigning 0 to the property length of the array affected. For Example

let numbers = [1,3,5,7,9];

numbers.length = 0;

console.log(numbers);
// []

This is possible because the length property is read/write property in an array. Therefore, you can assign zero and the array will be clear.

Array methods: findIndex

Barrios Freddy — Thu, 10 Dec 2020 02:40:07 +0000

The findIndex receives a function (predicate) that accepts three arguments and returns a value that is coercible to the Boolean value true or false.

The predicate returns true. If such an element is found, findIndex immediately returns the index of the first element value. Otherwise, findIndex returns -1, indicating that no element passed the test.

const array = [
    {name: 'Freddy', age: 10}, 
    {name: 'Francisco', age: 3}, 
    {name: 'Emilia', age: 4}
];

const preschoolerIndex = array.findIndex(kid => kid.age < 5);

console.log(preschoolerIndex);
// 1

Parameters

callback
Testing function to execute on each value in the array, taking 3 arguments:

element
The current element in the array.
index (Optional)
The index (position) of the current element in the array.
array (Optional)
The array that find was called on.
thisArg (Optional)
Object to use as this inside callback.

The findIndex function is intentionally generic; it does not require that its this value be an Array object. Therefore it can be transferred to other kinds of objects for use as a method.

Array methods: find

Barrios Freddy — Fri, 04 Dec 2020 04:35:03 +0000

The find method receives a callback function that is used as a testing function and, optionally, an object to use as this inside. This returns the value of the first element in the provided array that satisfies the testing. Otherwise, the find method returns undefined.

const array = [
 {name: 'Emilia', age: 4},
 {name: 'Freddy', age: 10}
];

const preschooler = array.find(kid => kid.age < 5);

console.log(preschooler);
// { name: 'Emilia', age: 4 }

Parameters

callback
Testing function to execute on each value in the array, taking 3 arguments:

element
The current element in the array.
index (Optional)
The index (position) of the current element in the array.
array (Optional)
The array that find was called on.
thisArg (Optional)
Object to use as this inside callback.

find is a method very useful in order to encounter a specific element into an array, providing a function that will be invoked on each element until finding the value that satisfies the testing. Therefore, be careful, the usage of this method in some cases can be inefficient.

Asynchronous code: Promises

Barrios Freddy — Wed, 02 Dec 2020 04:22:34 +0000

A promise is an object representing the eventual completion or failure of an asynchronous operation.

Basically, a promise is an object where you can attach a numberless callback function which can be pass as arguments to the chainable methods then, catch and finally.

The Promise constructor receives the executor function which waits for two functions, in the first position the resolve function which will be executed if everything is done, and in the second position the reject function that will be executed in case of an error, for example.

new Promise(function(resolve, reject) {
    const name = "Freddy"
    resolve(name)
}).then(name => {
    console.log("It's a pleasure, Mr. " + name);
    throw new Error("Something wrong happened!")
    console.log("This will not be displayed");
}).catch(error => {
    console.error("What happened? " + error.message)
}).finally(() => {
    console.log("There is no coffee to drink");
})

// It's a pleasure, Mr. Freddy
// What happened? Something wrong happened!
// There is no coffee to drink

Definitely, Promises give our code more readability, consistency and come to resolve some problems suffered from the callback functions such as the famous "Callback hell". Thus, if you are not using promises in your normal day, this is the moment.

Asynchronous code: callback functions

Barrios Freddy — Tue, 01 Dec 2020 02:42:07 +0000

Functions in JavaScript are not as in other languages are. In JavaScript, functions are first-class citizens. Therefore, a function can be passed as an argument, can be used as a variable value, and so on.

A callback function is a subroutine, It's a piece of code which can be executed immediately or later in run-time. As asynchronous callbacks, these functions are used to notify or alert when an event happens. Normally, these functions are specified as arguments to another one that start executing some code in the background, when the background code finishes running, it calls the callback function to let know the work is done or to tell you that something has happened.

function callback() {
    console.log("Process finished!");   
}

function run(callback) {
    for (let index = 0; index < 10000; index++) {
        console.log("Processing...");
    }
    callback();
}


run(callback);

In simple words, an asynchronous callback is a function that can be invoked when you need to notify something happened or the work is done. Even the callbacks are old-fashioned, it's very important to know about them since a high number of APIs still use them.

Three ways to create an object in JavaScript

Barrios Freddy — Wed, 11 Nov 2020 01:38:06 +0000

In JavaScript, there are three ways to create your own objects. Taking into account that almost everything in JS It’s an object.

Object literals

The simplest way to create an object in JS it’s through curly brackets { }.

Define and create a single object in one statement

const person = {
    name : 'Freddy',
    sayHello() {
        return `Hi ${this.name}`
    }
};

console.log(person.sayHello()) // Hi Freddy

New operator

Using the new operator is the same thing as creating objects literally. It’s recommended to use object literals, instead of this, for simplicity and execution speed.

const person = new Object()
person.name = 'Freddy'
person.sayHello = ()  => {
   return `Hi ${this.name}`
}

console.log(person.sayHello()) // Hi Freddy

Also, you can create an object through a constructor function. In this case, the new operator returns an instance of the function, if the function has not an explicit return statement it’ll “this “

function Person (name) {
    this.name = name
    this.sayHello = function() {
        return `Hi ${this.name}`
    }
}
const person = new Person('Freddy')
console.log(person.sayHello()) // Hi Freddy

Object.create() method

In order to define and create a new object through the create
method, we have to use the prototype from another one.

const person = Object.create(Object.prototype)
person.name = 'Freddy'
person.sayHello = function sayHello() {
     return `Hi ${this.name}`
}


console.log(person.sayHello()) // Hi Freddy

Object destructuring assignment

Barrios Freddy — Thu, 22 Oct 2020 16:34:43 +0000

The destructuring assignment syntax is a JavaScript expression that makes it possible to unpack values from arrays, or properties from objects. In this case, we are going to see how destructuring works for objects.

const user = {
  userName: 'fbarrios',
  firstName: 'Freddy',
  lastName: 'Barrios',
  address: {
    street: '52',
    zipcode: '110007',
}

const { firstName } = user
console.log(firstName); // Freddy

This is the same as…

const firstName = user.firstName

It is possible to set default values, in case the property doesn’t exist or is undefined.

const { phone = '0000000' } = user
console.log(phone) // 0000000

A property can be renamed when it’s destructured.

const { username: displayName } = user
console.log(displayName); // Freddy

You can rename and set a default value for a property

const { phone: phoneNumber = '0000000' } = user
console.log(phoneNumber) // 0000000

When the object has another one nested it’s destructured in the following way

let { address: { street } } = user
console.log(street) // 52

Destructuring can be used with the arguments of a function

function fullname({firstName, lastName}) {
  return `${firstName} ${lastName}`;
}

console.log(fullName(user)); // Freddy Barrios

Computed property names can be used with the destructuring assignment.

const key = 'username'
const { [key] } = user

Rest operator in object destructuring

This operator (...) collects all properties that weren’t picked off during object destructuring

const { address, …restProperties } = user
console.log(address);
/*
{
  street: '52',
  zipcode: '110007',
}
*/ 
console.log(restProperties); /
{
  userName: 'fbarrios',
  firstName: 'Freddy',
  lastName: 'Barrios',
}
*/

As you can see, object destructuring is very useful and gives us another way to write better code.