Eliminate Circular Dependencies With Layered Modular Architecture

Amohammadi2 — Mon, 15 Aug 2022 06:09:51 +0000

Modular Design is very important in any large scale application. It helps with decoupling application domains, enables developers to focus only on their specific domains and makes the on-boarding process a lot easier. Also, if you decide to split your monolith into microservices, it will be less painful.

The basic idea behind modular design is to organize your project files based on their purpose instead of their type.

One of the most common problems you'll encounter during the process of modularizing your app, is the trap of circular-dependency between your modules. Circular dependencies are often an indicator of the need to extract a third module or merge the two.

But how to organize them?

Layered Modules

I've personally encountered the problem of circular dependencies in EVERY project that I have worked on.

One time, as I was diagnosing the structure of one of my apps to find the origin of circular dependencies between its modules, I realized that the modules can function independently only up to a certain layer.

In this concrete example, the problem was the API layer (the app was a back-end service). I needed to aggregate information from multiple modules to finally accomplish the task and output the results to the front-end developers.

So I decided to change the project structure from this:

To this:

And after the refactoring process was done, there was no circular dependencies between my modules anymore. Also, the module hierarchy was much more easier to understand.

As you can see, This structure is a combination of layered architecture and modular design. You can personalize this to fit your own needs.

How do I organize my modules now?

Currently, I categorize my modules into 3 main categories:

/src
  /db-modules
  /feature-modules
  /api-modules

DB Modules

They can manage and validate the database models related to their domains independently

feature Modules

They can manage and validate the database models related to their domains independently
They implement logic and perform business tasks independently
They can import from DB Modules

API Modules

They can manage and validate the database models related to their domains independently
They implement logic and perform business tasks independently
They implement the API interface and handle API requests independently (without relying on other API modules)
They can import from DB Modules
They can import from Feature Modules

Basically, the extent to which a module can handle its own concerns, determines the type of the module. Also you can introduce more groups as the complexity grows (e.g: you can add an aggregator module group to integrate multiple API modules which is useful for dealing with microservices and external APIs).

What do you think about this architecture? leave a comment down below

Casino_plus, an easy way to create uniform and non-uniform random distributions

Amohammadi2 — Thu, 03 Jun 2021 19:19:26 +0000

Casino_plus is a C++ library for creating both uniform and non-uniform random distributions. The good thing about this library is, it has python language bindings as well, so you can use it in your python projects as well.

This library has a very easy to use interface for python programmers, also it is really fast.

In this article, I want to show you how to use python bindings of this library. So let's begin

Installation

the installation process is fairly simple. here is the requirements:

Visual C++ build tools 2017 or higher
CMake version 3.8 or higher

here is the github repo:

Amohammadi2 / Casino_plus

create uniform and non-uniform distribution

first go ahead and clone the repository:

$ git clone https://github.com/Amohammadi2/Casino_plus.git

Then, cd into the project root directory, there you can find a setup.py file. (installation verified on python version 3.8)

$ python setup.py install

If you have the required tools installed, the installation will finish successfully.

How to use it

you have to import the module before you can use it, write the following code in a python file:

import CasinoPlus

the module contains a class called CasinoRandomGenerator but due to constraints of C++ type system, there are some prefixes that you should use based on the data type you want to pass to the generator.

s_ : for generators containing strings
cs_ : for generators containing chars
i_ : for generators containing ints
f_ : for generators containing floats
d_ : for generators containing doubles

for example you could use: s_CasinoRandomGenerator to create a generator that accepts string items

at the time being, only the types mentioned above are supported. We'll try to improve it and make it more general.

adding items to the generator

to add items to the generator, you should use one of the methods add_item or add_sequence.

add_item(item: Item_Type, probability: int) -> None : adds one item to generator with specified probability. for uniform distributions probability could be set to 1 for all the items but if you want to create non-uniform random distributions, you can change this value. For example if you want the item to appear more frequently, you can increase the probability. probability cannot be a negative value.
add_sequence(items: List[Tuple[Item_Type, int]]) -> None : can add multiple items at once. it is more optimal to use this function when you want to add multiple items to the generator.

notice that Item_Type is actually the data type that the generator is using for example if you're using s_CasinoRandomGenerator then Item_Type would be str.

getting a random item out of generator

in order to get a random item, you should use get_random_item method. It has the following signature:

get_random_item() -> Item_Type

example

here is a example program that uses all the functionalities of CasinoPlus.

>>> from CasinoPlus import s_CasinoRandomGenerator as strgen
>>>
>>> rand = strgen()
>>> rand.add_item("Ashkan Mohammadi", 1)
>>> my_brothers = [["Arshia Mohammadi", 1], ["Ilia Mohammadi", 1]]
>>>
>>> rand.add_sequence(my_brothers)
>>> rand.get_random_item()
'Ilia Mohammadi'
>>> rand.get_random_item()
'Ashkan Mohammadi'
>>> rand.get_random_item()
'Arshia Mohammadi'

DEV Community: Amohammadi2