Topological Consensus System (TCS)
Topological consensus system (TCS)
Author: Alexander Korobkin and the development team
Introduction of new innovative distributed systems technology: STC
Today we are pleased to introduce our new innovative technology based on the Chord protocol (https://en.wikipedia.org/wiki/Chord_(peer-to-peer)), but with a number of unique features that increase its functionality and performance. We called our technology “STC” (System of Topological Consensus).
Purpose of the STC
STC is a distributed hash table (DHT) that allows for efficient organization and management of data in a distributed system. It is suitable for use in a variety of applications, such as:
Distributed file systems: Providing scalable and reliable data storage.
Cloud solutions: Organizing data and resources in large cloud infrastructures.
Network Naming Services: Providing efficient and fast access to distributed data.
Internet of Things (IoT): Managing huge amounts of data from various devices on the network.
Content Distribution Networks (CDN): Optimizing storage and access to content for users around the world.
Blockchain applications: Distribution and storage of transactions and data in the blockchain network.
Features of STC
1. Automatic node recovery:
Nodes in the STC system are capable of automatically recovering from failures, maintaining the integrity and availability of data.
2. Nested rings of nodes (subnets):
STC supports the creation of subnets within the main network, which allows for a more complex data hierarchy and load distribution.
3. Expandable Finger Table:
Our solution includes dynamically updated Finger Tables, which provide faster and more efficient node search.
4. Load Balancing:
The STC automatically distributes loads across nodes, which prevents overloads and increases overall system performance.
Examples of using STC
To demonstrate the capabilities of the STC, let's assume that we have a cloud platform for storing and processing large amounts of data. Using the STC to organize this platform provides the following advantages:
Distributed files: Each file is hashed and distributed across the network nodes. If any node fails, the file is automatically replicated to other nodes.
Scalability: Adding new nodes to the network occurs without interruptions in the system's operation. STC automatically updates routing tables.
High availability: Data is available 99.999% of the time thanks to automatic recovery and load balancing mechanism.
Example of use in cloud solutions
STC can become the basis for the development of the following cloud services:
Cloud storage: Support for file systems such as Amazon S3 or Google Cloud Storage, with the ability to distribute and manage data.
Cloud computing: Organization of resources for performing parallel tasks and distributed computing.
Network firewalls: Providing security and access control in distributed network environments.
Virtual Private Networks (VPN): Building scalable and secure virtual private networks with distributed management.
Example code in GoLang
To illustrate the basic mechanism of the STC operation, we present a small fragment of code in Go:
package main
import (
"fmt"
"log"
"math/big"
"sync"
"time"
)
// Node структура, представляющая узел в СТК
type Node struct {
ID uint64
Address string
Successors []Node
Predecessor *Node
FingerTable []Node
mu sync.Mutex
}
// Создание нового узла и запуск в сети СТК
func (n *Node) Create() {
n.Predecessor = nil
n.Successors = append(n.Successors, *n)
}
// Присоединение к сети СТК через другой известный узел
func (n *Node) Join(knownNode *Node) {
n.Predecessor = nil
n.Successors = append(n.Successors, knownNode.FindSuccessor(n.ID))
}
// FindSuccessor внедрение для СТК
func (n *Node) FindSuccessor(id uint64) *Node {
// Логика поиска ближайшего узла-преемника
// Это псевдокод, фактическая логика должна быть заполнена
return nil
}
func (n *Node) Stabilize() {
// Логика для стабилизации узла: проверка предшественника, поиск новых преемников и т.д.
}
func (n *Node) FixFingers() {
// Логика обновления пальцевых таблиц
}
// Периодические вызовы для стабилизации и фиксации пальцев
func (n *Node) Run() {
for {
time.Sleep(15 * time.Second)
n.Stabilize()
n.FixFingers()
}
}
// Пример создания ноды и ее запуска в фоновом режиме
func main() {
bootstrapNode := Node{ID: 1, Address: "localhost:8000"}
go bootstrapNode.Run()
bootstrapNode.Create()
fmt.Println("STK Ring created")
node2 := Node{ID: 2, Address: "localhost:8001"}
node2.Join(&bootstrapNode)
go node2.Run()
select {}
}
(ps: The logic of FindSuccessor, Stabilize, FixFingers will be discussed in more detail in subsequent series of articles, for the outline of the concept of the idea it is not important for now.)
System without a center: Decentralization and scalability of the STC
One of the key benefits of TCS (Topological Consensus System) is its ability to provide decentralized management of data and resources, creating a “system without a center”. This means that in a TCS network, there is no central source of control or node that bears the majority of the load and responsibility. Instead, all nodes in the network are equal and work together to ensure the reliability and performance of the system. Let's take a closer look at how this works and what benefits it provides.
Principles of decentralized architecture of STC
Distributed Hash Table (DHT)
STC uses a distributed hash table (DHT) that distributes data and tasks among all nodes in the network. Each node is responsible for a specific range of keys, making it possible to manage huge amounts of data without centralized control.
Self-organization mechanisms
Nodes in the STC have the ability to self-organize and maintain their structure without centralized control. This includes automatic recovery from failures, updating routing tables (Finger Tables), and load balancing between nodes.
Peer-to-peer (P2P) communication
The STC nodes communicate directly with each other, without the need to contact any central server. This ensures uniform load distribution and reduces the risks associated with the failure of one node.
Consensus algorithms
To ensure consistency and integrity of data, nodes use consensus algorithms such as PBFT or Raft. These algorithms allow nodes to agree on the state of the system and the changes to be accepted without relying on a central node.
Examples of application of decentralized STC system
Blockchain technologies
In blockchain networks such as Bitcoin or Ethereum, it is important to maintain a decentralized structure to ensure security and censorship resistance. STC can be used to create and manage distributed transaction ledgers without centralized control.
Decentralized social networks
Modern social platforms face problems of censorship and data privacy. Using STC, it is possible to create systems where users control their data and interact directly with each other.
Peer-to-Peer file sharing
STK can serve as a basis for P2P file sharing services such as BitTorrent. This will allow for fast and reliable file sharing between users without the need for a central server.
Decentralized Cloud Computing
In traditional cloud platforms, centralized servers are a single point of failure and a performance bottleneck. STC allows computing tasks to be distributed across a network of nodes, which increases reliability and scalability.
Advantages of a system without a STC center
Fault tolerance
In a decentralized system, the absence of a central node makes it more resistant to various failures and attacks. The failure of one of the nodes will not lead to the collapse of the entire system.
Scalability
Adding new nodes to the decentralized STC network increases its power and capabilities without the need for radical changes in the architecture. This allows the system to easily scale depending on needs.
Privacy and Security
In a decentralized system, data is distributed across multiple nodes, making unauthorized access more difficult and increasing the overall level of security and privacy.
Cost reduction
The use of decentralized architectures allows for the even distribution of the load and costs of maintaining the system among all network participants, which reduces overall costs.
How does the STC network work and its working unit – the node
In the context of a Topological Consensus System (TCS), a node is the basic building block of the network. Understanding how nodes work in this system helps to better appreciate the capabilities and benefits of TCS. In this article, we will look at the basic principles of a TCS network and the specific functions of nodes in it.
Basic principles of operation of the STC network
1. Decentralized structure
The STC network is built on a decentralized architecture, where there is no central control node. Each node has equal responsibility for performing tasks and maintaining the integrity of the network.
2. Distributed data storage
Data in the STC network is stored in a distributed manner using structures such as distributed hash tables (DHT). This allows for reliable storage and fast retrieval of data, making the system resistant to failures and attacks.
3. Consensus algorithms
Consensus algorithms such as PBFT (Practical Byzantine Fault Tolerance) or Raft ensure data consistency and correct execution of operations in a decentralized network. Nodes agree on actions and changes based on a majority vote.
How does a node work in the STC network?
1. Registration and connection of the node
When a new node is added to the network, it goes through a registration process where other nodes check it and include it in distributed hash tables. Nodes exchange information about their neighbors and form routing tables (Finger Tables).
2. Data storage
Each node is responsible for a certain range of keys. When data is added to the network, it is hashed, and the node that matches the hash value becomes responsible for storing it. For example, in DHT systems, data with hash keys from 100 to 199 will be stored on the node that is responsible for those keys.
3. Search and transfer of data
When a network user requests data, its node hashes the request and consults its routing table to find the nearest node that holds the requested data. The nodes pass the request along the chain until the desired data is found and passed back.
4. Ensure consistency and security
Nodes participate in consensus algorithms to ensure data consistency. For example, in PBFT, nodes exchange messages and confirm the correctness of operations before changes are considered valid.
Example of node operation:
File sharing:
In a network like BitTorrent, files are broken into pieces and distributed among nodes. When node A wants to download a file, it looks for nodes B, C, and D that hold different parts of the file. Node A downloads the pieces in parallel from different nodes, merges them, and makes the file available to other nodes as needed.Blockchain Transactions:
In a decentralized blockchain system, each node stores a copy of the entire chain of blocks. When a new transaction is created by node A, it is broadcast to the entire network. Nodes B, C, and D check the transaction, use a consensus algorithm to validate it, and add it to a new block.
Advantages of nodes in STC
Stability and resilience
The interchangeability of nodes and decentralization make the STC network resilient to individual failures.
Flexibility and scalability
New nodes can easily connect to the network, expanding its capabilities and power.
Transparency and security
Consensus algorithms and distributed data storage prevent unauthorized access and manipulation of data.
Interaction of nodes in the context of a ring network (RNN)
In a ring network, each node is logically connected to two other nodes – its successor and predecessor – thus forming a ring. Data and messages are transmitted along this ring, and each node acts as a relay for messages that are not directly intended for it.
Interaction algorithm
Network initialization:
One node starts up first and starts listening for incoming connections.
The following nodes connect to the network through existing nodes.
Joining a new node:
The new node communicates with one of the current nodes in the network.
The current node analyzes the ID of the new node and its position in the ring to insert it in the correct place.
The successor and predecessor link settings are updated for both the new node and the nodes that now come before and after it.
Search and Routing:
To find information or a resource, a node initiates a request that is passed around the ring.
Each node examines the request and either answers it or forwards it to its next node. This continues until the goal is reached.
Failure handling:
The STC must monitor the status of the nodes.
If a node fails to respond, its neighboring nodes update their links to the new successor or predecessor, thereby providing fault tolerance.
Detailed interaction between nodes
Let's look at examples of interaction in a ring when adding a new node and transmitting messages:
Example of adding a new node:
Let's imagine that in an existing ring with nodes A (ID=1), B (ID=2), and C (ID=3), a new node D with ID=4 is added.
Node D connects to node A.
Node A analyzes D's position and passes it on to B or C, depending on their ID.
As a result, D is defined as the predecessor of node A and the successor of node C.
Nodes C and A update their references to the new node, integrating it into the ring.
Example of message transmission and routing:
Node A wants to transmit a message to node C.
A checks whether C is its successor. If not, it passes the message to its successor, node B.
Node B performs a similar check and passes the message on until it reaches node C.
Node C receives the message and replies back around the ring, passing through B to A.
func (n *Node) SendMessage(targetID int, message string) {
if n.id == targetID {
fmt.Println("Message received:", message)
return
}
n.mu.Lock()
defer n.mu.Unlock()
// Forward the message to successor
if n.successor != nil {
// Assuming we have a way to send a message to a successor node here
n.successor.SendMessage(targetID, message)
}
}
Thus, the ring network structure ensures reliable routing and data transmission, minimizing delays and increasing system reliability.
This example shows how the simplicity of the ring network design allows for the implementation of a foundation for scalable and fault-tolerant distributed systems.
Examples of launching and operating STK nodes on Go
In the context of ring topology systems (RTS), the tasks of starting nodes, adding new nodes to an existing ring network, and interacting with these nodes play a key role. In this section, we will look at how these mechanisms can be implemented in the Go programming language (Golang). We will build a simple version of a distributed hash table (DHT) using a ring topology, showing how to start nodes and add new nodes to the network, as well as how to send values to a node with updates to other nodes.
Step 1: Create a Node
Let's create a basic structure Nodewhich will represent a node in our network:
package main
import (
"fmt"
"hash/fnv"
"sync"
)
type Node struct {
id int
data map[string]string
successor *Node
predecessor *Node
mu sync.Mutex
}
func NewNode(id int) *Node {
return &Node{
id: id,
data: make(map[string]string),
}
}
Step 2: Launch the node
Let's implement a function to start a new node and add it to the ring topology:
func (n *Node) Join(existingNode *Node) {
if existingNode == nil {
n.successor = n
n.predecessor = n
} else {
// Найти правильное место для нового узла
n.findSuccessor(existingNode)
}
}
func (n *Node) findSuccessor(existingNode *Node) {
if n.id > existingNode.id && n.id <= existingNode.successor.id {
// Вставить узел между existingNode и его преемником
n.successor = existingNode.successor
n.predecessor = existingNode
existingNode.successor.predecessor = n
existingNode.successor = n
} else if existingNode.id > existingNode.successor.id && (n.id > existingNode.id || n.id < existingNode.successor.id) {
// Специальный случай для замыкания кольца
n.successor = existingNode.successor
n.predecessor = existingNode
existingNode.successor.predecessor = n
existingNode.successor = n
} else {
n.findSuccessor(existingNode.successor)
}
}
Step 3: Adding New Nodes
Now let's add a function so that new nodes can be added to an existing network:
func addNode(existingNode *Node, newNodeID int) *Node {
newNode := NewNode(newNodeID)
newNode.Join(existingNode)
return newNode
}
Step 4: Sending values and updating them on the network
We implement functions for storing and receiving values. When sending a value, the corresponding node will be updated:
func (n *Node) Store(key, value string) {
hashedKey := hashString(key)
targetNode := n.findNodeForKey(hashedKey)
targetNode.mu.Lock()
targetNode.data[key] = value
targetNode.mu.Unlock()
}
func (n *Node) Retrieve(key string) (string, bool) {
hashedKey := hashString(key)
targetNode := n.findNodeForKey(hashedKey)
targetNode.mu.Lock()
defer targetNode.mu.Unlock()
value, ok := targetNode.data[key]
return value, ok
}
func (n *Node) findNodeForKey(hashKey int) *Node {
if hashKey > n.id && hashKey <= n.successor.id {
return n.successor
} else if n.id > n.successor.id && (hashKey > n.id || hashKey < n.successor.id) {
return n.successor
} else {
return n.successor.findNodeForKey(hashKey)
}
}
func hashString(s string) int {
h := fnv.New32a()
h.Write([]byte(s))
return int(h.Sum32())
}
Example of usage and launch commands
Now let's look at how to launch one node and add others to it to create a ring network structure:
func main() {
// Создание и запуск первого узла
node1 := NewNode(1)
node1.Join(nil)
// Добавление новых узлов к уже существующему узлу
node2 := addNode(node1, 2)
node3 := addNode(node1, 3)
node4 := addNode(node1, 4)
// Пример хранения значений в узлах
node1.Store("key1", "value1")
node2.Store("key2", "value2")
// Пример получения значений из узлов
val, ok := node3.Retrieve("key1")
if ok {
fmt.Printf("Node3 retrieved key1: %s\n", val)
} else {
fmt.Println("Key not found")
}
val, ok = node4.Retrieve("key2")
if ok {
fmt.Printf("Node4 retrieved key2: %s\n", val)
} else {
fmt.Println("Key not found")
}
}
Commands to run:
Create a file
main.goand place the above code in it.Open a terminal and go to the directory containing the file
main.go.Compile and run the program:
go run main.go
This example demonstrates the basic model of a ring network: create nodes, connect them into a network, send and receive data. This approach can be extended and modified for more complex and scalable systems.
Examples of running nodes in STK on Go: Organization of a ring network with independent processes
Step 1: Create the node structure
The first step is to create a basic structure. Nodewhich will represent a node in our network:
package main
import (
"fmt"
"net"
"sync"
)
type Node struct {
id int
address string
successor *Node
predecessor *Node
mu sync.Mutex
}
func NewNode(id int, address string) *Node {
return &Node{
id: id,
address: address,
}
}
func (n *Node) String() string {
return fmt.Sprintf("Node{id: %d, address: %s}", n.id, n.address)
}
Step 2: Starting a node and waiting for a connection
Let's create a function to start a node that will listen on the specified address and port for other nodes to connect:
func (n *Node) StartListening() {
ln, err := net.Listen("tcp", n.address)
if err != nil {
fmt.Println("Error starting node:", err)
return
}
defer ln.Close()
fmt.Println(n, "is listening")
for {
conn, err := ln.Accept()
if err != nil {
fmt.Println("Error accepting connection:", err)
continue
}
go n.handleConnection(conn)
}
}
func (n *Node) handleConnection(conn net.Conn) {
defer conn.Close()
var remoteID int
fmt.Fprintln(conn, "Enter node ID:")
fmt.Fscanln(conn, &remoteID)
newNode := NewNode(remoteID, conn.RemoteAddr().String())
n.Join(newNode)
fmt.Println(newNode, "joined the ring")
}
Step 3: Joining a new node to an existing one
Let's implement a mechanism for adding a new node to an existing ring:
func (n *Node) Join(newNode *Node) {
n.mu.Lock()
defer n.mu.Unlock()
if n.successor == nil || n == n.successor {
// Первый узел в сети
n.successor = newNode
n.predecessor = newNode
newNode.successor = n
newNode.predecessor = n
} else {
// Найти подходящее место для нового узла
n.findPositionForNewNode(newNode)
}
}
func (n *Node) findPositionForNewNode(newNode *Node) {
if newNode.id > n.id && newNode.id < n.successor.id {
// Вставить новый узел между текущим узлом и его последователем
newNode.successor = n.successor
newNode.predecessor = n
n.successor.predecessor = newNode
n.successor = newNode
} else if n.id > n.successor.id && (newNode.id > n.id || newNode.id < n.successor.id) {
// Специальный случай для замыкания кольца
newNode.successor = n.successor
newNode.predecessor = n
n.successor.predecessor = newNode
n.successor = newNode
} else {
// Пройти дальше по кольцу
n.successor.findPositionForNewNode(newNode)
}
}
The node.go file with all the helper functions
// node.go
package main
import (
"fmt"
"net"
"sync"
)
type Node struct {
id int
address string
successor *Node
predecessor *Node
mu sync.Mutex
}
func NewNode(id int, address string) *Node {
return &Node{
id: id,
address: address,
}
}
func (n *Node) String() string {
return fmt.Sprintf("Node{id: %d, address: %s}", n.id, n.address)
}
func (n *Node) StartListening() {
ln, err := net.Listen("tcp", n.address)
if err != nil {
fmt.Println("Error starting node:", err)
return
}
defer ln.Close()
fmt.Println(n, "is listening")
for {
conn, err := ln.Accept()
if err != nil {
fmt.Println("Error accepting connection:", err)
continue
}
go n.handleConnection(conn)
}
}
func (n *Node) handleConnection(conn net.Conn) {
defer conn.Close()
var remoteID int
fmt.Fprintln(conn, "Enter node ID:")
fmt.Fscanln(conn, &remoteID)
newNode := NewNode(remoteID, conn.RemoteAddr().String())
n.Join(newNode)
fmt.Println(newNode, "joined the ring")
}
func (n *Node) Join(newNode *Node) {
n.mu.Lock()
defer n.mu.Unlock()
if n.successor == nil || n == n.successor {
// Первый узел в сети
n.successor = newNode
n.predecessor = newNode
newNode.successor = n
newNode.predecessor = n
} else {
// Найти подходящее место для нового узла
n.findPositionForNewNode(newNode)
}
}
func (n *Node) findPositionForNewNode(newNode *Node) {
if newNode.id > n.id && newNode.id < n.successor.id {
// Вставить новый узел между текущим узлом и его последователем
newNode.successor = n.successor
newNode.predecessor = n
n.successor.predecessor = newNode
n.successor = newNode
} else if n.id > n.successor.id && (newNode.id > n.id || newNode.id < n.successor.id) {
// Специальный случай для замыкания кольца
newNode.successor = n.successor
newNode.predecessor = n
n.successor.predecessor = newNode
n.successor = newNode
} else {
// Пройти дальше по кольцу
n.successor.findPositionForNewNode(newNode)
}
}
Step 4: Examples of starting nodes and creating a ring
Now let's look at how to run nodes as separate processes and how they will connect to each other to create a ring network:
Create separate files for each node: node1.go, node2.go, and node3.go, which will import and use definitions from node.go.
node1.go:
package main
import (
"fmt"
"net"
"time"
)
func main() {
node1 := NewNode(1, "localhost:8000")
go node1.StartListening()
// Ждем присоединения других узлов
time.Sleep(60 * time.Second)
fmt.Println("Node 1 done")
}
node2.go:
package main
import (
"fmt"
"net"
"time"
)
func main() {
node2 := NewNode(2, "localhost:8001")
go node2.StartListening()
time.Sleep(1 * time.Second) // Ждем, пока второй узел начнет слушать
conn, err := net.Dial("tcp", "localhost:8000")
if err != nil {
fmt.Println("Error connecting to node1:", err)
return
}
defer conn.Close()
fmt.Fprintln(conn, node2.id)
time.Sleep(60 * time.Second)
fmt.Println("Node 2 done")
}
node3.go:
package main
import (
"fmt"
"net"
"time"
)
func main() {
node3 := NewNode(3, "localhost:8002")
go node3.StartListening()
time.Sleep(1 * time.Second) // Ждем, пока третий узел начнет слушать
conn, err := net.Dial("tcp", "localhost:8000")
if err != nil {
fmt.Println("Error connecting to node1:", err)
return
}
defer conn.Close()
fmt.Fprintln(conn, node3.id)
time.Sleep(60 * time.Second)
fmt.Println("Node 3 done")
}
Step 5: Launch nodes as separate processes
Now you need to compile and run all three nodes as separate processes:
Open three different terminals or console windows and run the following commands:
In the first terminal, run:
go run node1.goIn the second terminal, run:
go run node2.goIn the third terminal, run:
go run node3.go
In this example:
Each node starts as a separate process and begins listening on a specified address and port.
Subsequent nodes are connected to the first node and added to the ring.
All nodes operate autonomously and manage connections independently, exchanging data via TCP.
In this way, we can organize a ring network where each node is an independent working unit and operates in a separate process, ensuring reliable interaction and flexibility of the system.
Propagation of values across nodes in the context of STC
In a ring network, value propagation algorithms, such as resource retrieval or message passing, rely on messages passing from node to node around the ring. Some examples of algorithms are given below.
1. Example of a resource search algorithm
Consider a situation where node A is looking for a resource that is located at node C.
A -> B -> C -> D
| | | |
v v v v
Node Node Node Node
1 2 3 4
Algorithm:
Node A sends a resource search request to its successor B.
Node B checks for the presence of the resource. If not, it forwards the request further to C.
Node C finds the resource and responds to A.
(A)---->(B)---->(C)---->(D)
| | | |
v v v v
Req Req Res Wait
| / ^
v / |
Req /___________|
2. Example of algorithm for adding a new node
Let's consider adding a new node E with ID 5 to an existing network.
A -> B -> C -> D
| | | |
v v v v
Node Node Node Node
1 2 3 4
Algorithm:
Node E connects to A and sends a request to join the ring.
Node A determines a suitable position for E. The request is forwarded to D.
Node D updates its links to the new node E.
(A)---->(B)---->(C)---->(D)
| | | |
v v v v
New -> -> ->
(E)---->(A)---->(B)---->(C)---->(D)
3. Example of node failure handling
Let's consider a situation where node B fails.
A -> B (fail) -> C -> D
| | | |
v v v v
Node (Fail) Node Node
1 2 3 4
Algorithm:
Node A detects the failure of B when it cannot reach it.
Node A forwards its links to successor C.
(A)---->(B)---->(C)---->(D)
| | ^ |
v x / v
(Fail) / |
/_________|
In the updated network:
(A)---->(C)---->(D)
| | |
v v v
Node Node Node
1 3 4
Each of these examples can be used to visualize how nodes interact in various operations in a ring network. These diagrams can help visualize the internal processes and make it easier to understand how distributed systems work.
Conclusion
Topological Consensus Systems (TCS) are a powerful tool for creating decentralized distributed systems. Using such systems without a center opens up new possibilities for building reliable, scalable, and secure applications in various fields, from blockchain to social networks and cloud computing. TCS provides a high degree of self-organization, scalability, and resilience, which makes it an attractive solution for the modern world of distributed technologies.
We are confident that STC will be a major step forward in the world of distributed systems due to its uniqueness, reliability and scalability. In our team, we actively use STC to design and implement cloud solutions, which allows us to create highly reliable and productive systems for our clients.
If this article generates interest and positive feedback from our readers, we will be happy to continue developing this area and present more in-depth and detailed materials. In the future, we plan to consider such topics as:
Optimization of distributed algorithms.
Use of various network topologies (not only ring ones).
Support for fault tolerance and load balancing in distributed systems.
Tools and frameworks for building distributed systems.
We are happy to share our knowledge and experience so that you can create even more efficient distributed systems and improve your computing processes. Your comments and feedback will be an important source of inspiration for future articles.
Sincerely,
Alexander Korobkin and the team of developers
