DEV Community: Tahsin

Easy Explanation of Coding Principles: Understand Key Concepts in Simple Terms

Tahsin — Thu, 20 Apr 2023 12:08:01 +0000

As a software developer, writing clean, maintainable, and efficient code is crucial for building robust and scalable applications. To achieve this, it’s essential to follow established software principles that provide guidelines for structuring and organizing code. In this article, we will explore a collection of widely used software principles that every developer should be familiar with. Whether you are a beginner or an experienced programmer, these principles can help you write high-quality code that is easier to understand, maintain, and extend.

I created this GitHub repository with some examples of each principle in Python code. At the same time here are some easy explanations for each of those below:

Single Responsibility Principle (SRP): Each part of the code should have only one job to do, just like you have one toy to play with at a time.

Open/Closed Principle (OCP): We can add new features to our code without changing the old parts, just like we can add toppings to our pizza without changing the crust.

Liskov Substitution Principle (LSP): We can use a new toy that looks like the old one, and it will work the same way, just like using a toy car or a toy truck on the same track.

Interface Segregation Principle (ISP): Each toy should have only the buttons and parts that we need, and not extra ones, just like a toy phone should have buttons to call and hang up, but not unnecessary buttons for other functions.

Dependency Inversion Principle (DIP): We should talk to our friends through a walkie-talkie, so we can use different walkie-talkies or even phones, as long as they work with the same frequency, just like our code should communicate with other parts through interfaces, so we can easily replace or upgrade those parts.

Don’t Repeat Yourself (DRY): We should not say the same things over and over again, but just once, just like we should not write the same code in different places, but reuse it in one place.

Keep It Simple, Stupid (KISS): We should not make things more complicated than they need to be, just like we should not use big words or difficult instructions when explaining something.

You Ain’t Gonna Need It (YAGNI): We should not worry about things that we don’t really need right now, just like we should not pack extra toys for a short trip, but only take what we really want to play with.

In summary, understanding and applying the fundamentals of software can improve code quality and make your software more manageable, scalable, and efficient. You can improve your software development and design better by following these widely used principles.

Whether you’re a newbie to software development or an experienced programmer looking to improve your skills, a simple understanding of this software principles is valuable.

Happy coding!

Tired of circular dependency in Typescript/Node.js?

Tahsin — Mon, 07 Mar 2022 14:22:41 +0000

First of all, let’s see what is a circular dependency. According to this Wikipedia:

In software engineering, a circular dependency is a relation between two or more modules which either directly or indirectly depend on each other to function properly. Such modules are also known as mutually recursive.

Alright, what does it mean? Well, to understand it properly let’s clone this repository and cd into src/good dir & inspect the files.

What we can see there is, a.ts is importing a variable from b.ts & in the main.ts we are importing & printing the variable from a.ts. So the flow looks like this:

When we execute main.ts by npx ts-node main.ts here is the output:

So far so good. Now let’s cd into src/problem dir & inspect what's going on. Here we can see a.ts importing a variable from b.ts and so does b.ts the opposite. And in main.ts it’s importing a variable from a.ts & b.ts and printing them. In this case, the flow looks like this:

When we execute main.ts by npx ts-node main.ts here is the output:

What is going on? In the last line instead of John, we are seeing undefined. Didn’t we import the variable correctly? Yes, we did. But it is happening because of the circular dependency problem. Look at the problem dir flow above. File a.ts is dependent on b.ts & b.ts dependent on a.ts.

How it’s happening let’s talk about it another time, but before that let’s see how we can detect it.

In a small program like this, it’s not a big problem to detect circular dependency. But in a large codebase, once we depend on a wrong module accidentally, then it’s tough to detect this later on. So today we are gonna use a tool call madge. Let’s see how we are gonna use it.

cd into src/good dir & execute npx madge --extensions js,ts --circular .

What do you see? No problems found. Right? Yeah. Because there is no circular dependency problem.

Now cd into src/problem dir & execute npx madge --extensions js,ts --circular .

What do you see? It’s awesome, right? The way it shows which files are circularly depending on what files, in a large codebase, it saves a lot of time.

Oiya, before we forget, of course in a large codebase we use tsconfig.json. If we have module aliases or something like that, we have to point to that tsconfig.json. So in that case we can add another flag like this:

If we do not use typescript, we don’t have to use --ts-config flag as well as ts in the --extensions flag.

Alright, enough for today. Next, hopefully, we will talk about how circular-dependency gets created underneath. Thank You.

Happy Coding 💻

The impact of sharing sessions in an engineering team

Tahsin — Mon, 07 Mar 2022 13:37:14 +0000

Did you know? Throughout the course of one year, an average person receives an impressive amount of data. According to David Derbyshire, scientists have even figured out the exact amount we’re talking about: the equivalent of every person in the world reading 174 newspapers every single day. This overload of data people are dealing with, increases the importance of knowledge sharing within a team.

In my opinion, the impact of having sharing sessions regularly as a part of the team culture is massive. Let me explain how. Have you heard of this following term?

The best way to learn something is: teaching that.

Whether or not you’re a developer, you’re most likely learning something new every single day. It can be a productivity tool, a concept, a hack, a new technology. No matter what is it, as long as your team can relate to the knowledge, just arrange a session and share it. So the question is: why? What’s the outcome?

Creates an ideal environment for syncing up ideas

Very often we come up with new ideas. Sometimes good, sometimes maybe not so good. Or, maybe a solution to a critical problem. So if we have an easy-going sharing session, it enables the possibility to sync up that idea within the team very easily. If the team gets used to it, they will feel it easier to do thing and tend to share more often. It enables an educative environment that makes you/me feel like: “I am having growth here with my team.”

Motivates others

Sometimes you see, your colleague (A) is facing an issue of which you or other teammates have easy & quick solutions. But your colleague (A) will not ask about it. Rather he/she will try to figure it out alone. I noticed this type of thing happens when we do not have an open culture.

Or maybe the other way around. Your colleague (B) has very good knowledge about a problem that your team facing. But due to the fact that your colleague (B) is very shy/afraid about sharing that knowledge in front of a group of people, we all are about to be deprived of gaining that good knowledge.

But things wouldn’t be the case if we could make the environment like: it’s very easy to share things/knowledge/idea, no matter how good or bad it is. We should welcome it.

Increases team chemistry/bonding

Sharing is caring. We all know the fact. When we have a weekly or, bi-weekly sharing session, it allows us to have a group discussion together. And as we know, any group project/discussion increases the chemistry which helps every individual to be more productive. In other words, it also enables more interaction among the team altogether.

And don’t forget about your remote workers! It’s often challenging for them to learn from their colleagues outside of the face-to-face environment, and perhaps more difficult to ask the right questions. When you’re remote, there’s the worry that you’re pestering people. Well, when people can search for shared knowledge, that really kills those two birds with one stone.

The feel-good factor

Let’s end on the most positive note of all! Sometimes, sharing knowledge isn’t even about the knowledge, the biggest benefit can come from everybody feeling like their voice is being heard. That’s a real shot of motivation for most people because they feel like a valued part of the team, and their experience is genuinely helping others to grow. At the same time, they’re giving somebody else that same feeling and that can go a long way to helping your business progress.

Let’s Wrap Up

It was tough to cover everything here. But this was a brief overview from my little experience of how a Regular Sharing Session in a team makes a significant impact. If you have any other thoughts, please do let me know.

Happy Knowledge Sharing!
Thank you, and take care!

Concurrency is not Parallelism - A deeper look at their key difference

Tahsin — Mon, 07 Mar 2022 03:02:27 +0000

Today, in this article, we'll analyze two common processing techniques used by the operating system (OS). Concurrency & Parallelism. When we have more than one process waiting to be executed, these 2 concepts come into the picture. Before we jump into the brief explanation about each, let's have a quick look at how CPU works underneath the hood.

Generally, the processor cores are meant to process 1 instruction at a time. So let’s say, you’re playing a video somewhere on a single-core machine. Does it mean you will not get any notification from your mail app that is running in the background? No, your background processes are doing their job nicely. But why is that? Didn’t I tell you that a single core can run one instruction at a time? How is it possible? Ah well, that’s the main job of an Operating System (OS). This job is known as Context Switching. All these processes happening not necessarily at the same time but in a scheduled manner. Operating system schedules processes for execution. Let’s say for simplicity's sake, we have 3 processes happening.

If the Scheduler schedules the processes like the figure above, the CPU will execute Process 1. Then after a certain amount of time, move to Process 2, then 3, then again 1. You get the idea. So when OS moves from one process to another, that act of switching is called Context Switching.

In the figure above, we see Process A and B, two processes are scheduled. CPU processing Process A. While it’s not finished, OS stopped that task and make the CPU process: Process B. Whether or not Process B is finished, it moved back to Process A again. That’s the operating system, doing its main job. But all these activities happening so fast, from the user's perspective, it feels at the same time. The user has the impression of parallelism. It gives the illusion of parallel execution even though it’s not.

Concurrent

So first thing first, when we talk about concurrency, concurrent execution is not necessarily executing tasks at the same time. Like the discussion above with a single-core CPU. When we have 2 tasks scheduled, at a given point in time we can say that, either task 1, or task 2 getting executed. Not both. OS scheduler & context-switcher decides how the CPU will finish both tasks.

From the figure above, we can see that, while Task 1 is not finished, Task 2 is getting processed. That's the key difference with Parallel execution which we will talk about in a sec. Yes, Task 2 is running while Task 1 is not finished yet, but at that time, Task 1 stopped. The state (code, memory, registry, unique values, etc) of Task 1 is frozen and saved somewhere by Context Switcher for later use when it will go back to Task 1.

Concurrency means executing multiple tasks at the same time but not necessarily simultaneously.

Parallel

The key point of how parallel is different from concurrent is: for Parallel, we need different hardware. It can be a different core or an entirely different machine. From above, if we bring the same example for parallel we can see the execution like the figure below:

While Task 1 is getting processed, at a certain point Task 2 started without Task 1 getting stopped. They both running at the same time. Even, parallelism does not require two tasks to exist. It literally physically run parts of tasks or, multiple tasks, at the same time using the multi-core infrastructure of CPU, by assigning one core to each task or sub-task.

Parallelism is a specific kind of concurrency where tasks are really executed simultaneously.

Summary

Even though concurrent & parallel both will finish the tasks significantly faster, when it goes to parallel, it will finish a bit faster than concurrent (depending on amount & types of tasks).

But now you might think, why concurrent then? While it's not running multiple tasks at the same time. Isn't it better if we run tasks just sequentially and forget about concurrency? Well, there are some benefits to concurrency. I will talk about those some other time.

So for today, that's all about Concurrency & Parallelism, a very important concept. Hope you will get it simpler now when either of these is in the conversation.

Happy Learning !!!

Get productive with docker using: lazydocker

Tahsin — Sun, 20 Feb 2022 05:38:52 +0000

When you manage docker containers on a server, you typically have two choices:

Install & deploy a web-based GUI
Manage your containers from command line

Wouldn't it be nice if there was something in between? If we could manage the containers & images right from the terminal in a better and faster way? That's when lazydocker comes into the rescue.

lazydocker is a simple, open-source, terminal based UI for both docker and docker-compose written in Go. It makes managing your containers & images from your command line really simple.

To install lazydocker, just follow the instruction from official repository. Right after that optionally, you can create an alias to start lazydocker easily. In my case it's like this:

The highlighting features from lazydocker are:

viewing the state of your docker or docker-compose container environment at a glance
viewing logs for a container/service
viewing ascii graphs of your containers' metrics so that you can not only feel but also look like a developer
customizing those graphs to measure nearly any metric you want
attaching to a container/service
restarting/removing/rebuilding containers/services
viewing the ancestor layers of a given image
pruning containers, images, or volumes that are hogging up disk space

And the fact that, all of these you can do with some fantastic keyboard shortcuts in a matter of seconds, is just awesome.

So, if you don't want to deal with the complications of the standard CLI commands of docker, lazydocker is a great handy little tool for you.

And finally, don't think: you're being lazy by using this tool. You're being productive and efficient. So what are you waiting for more? Go, give it a shot.

Happy productive hours!
Thanks & take care!

Secure your traefik dashboard with HTTPS and Basic Auth

Tahsin — Fri, 10 Dec 2021 01:25:57 +0000

Intro

When I created my first droplet at DigitalOcean, I needed a service discovery. At that time I had no idea how to deal with it. Eventually I went for nginx. But not knowing the concept, syntax, workaround I was having difficult time. Then I discovered nginx-proxy which made the process a bit easier as there was few app/services on my droplet running in docker. nginx-proxy adjusts the configuration automatically based on environment variable.

But, when I discovered traefik, everything changed. As it has yaml supported configuration, easy to start-with behavior and fully docker support: it became my favorite service discovery tool.

Dashboard

Traefik provides a nice looking dashboard to manage and observe configuration to routers and services. It's relatively easy to setup TLS with Let's Encrypt to a router by configuring traefik. However, it was a bit tricky for me to setup TLS for the dashboard itself.

Add TLS

Here is the configuration for docker-compose labels:

labels:
  traefik.enable: true
  traefik.http.routers.traefik_https.rule: Host(`traefik.example.com`)
  traefik.http.routers.traefik_https.entrypoints: websecure
  traefik.http.routers.traefik_https.tls: true
  traefik.http.routers.traefik_https.tls.certResolver: myresolver
  traefik.http.routers.traefik_https.service: api@internal

After putting the above labels in your docker-compose for traefik container, just execute docker-compose up. As there are changes in the compose file, it will restart the container. As soon as you do this, you will see a new route protected with TLS in your dashboard like below:

For me the tricky part was naming the service: api@internal

Add basic auth

Of course you don't want to keep this dashboard open. In my case I just added basic auth to keep it protected. So add these labels additionally to your docker-compose file for traefik container.

traefik.http.routers.traefik_https.middlewares: basic-auth-global
traefik.http.middlewares.basic-auth-global.basicauth.users: <username>:<encoded-password>

I thought it would read the middleware from traefik configuration which is: traefik.yml. But that was not the case. I had to create the middleware on docker-compose file with label.

Disable insecure mode

Finally, you want to disable insecure mode to prevent access with http. To do so make your trafik api configuration in traefik.yml like below:

api:
  insecure: false
  dashboard: true

Conclusion

After doing these works, you will see that your traefik dashboard can't be accessed through http anymore, rather https. And you need to enter username and password for the first time in a browser.

Get lazy with lazygit

Tahsin — Tue, 23 Nov 2021 14:32:04 +0000

As a developer, my assumption is:

You are working with Git literally every hour.

But I wonder, how many times you felt the necessity of a tool that makes the repetitive commands/steps a bit more convenient for the things like:

Seeing the diff
Quickly stage/unstage files
Seeing the logs
A tool to quickly open PR regardless of your SCM

Well, that's when lazygit comes to the rescue. It's a terminal UI for git commands written in Go.

Just install it following the instruction from the official repository. Then optionally you can set an alias in your shell configuration to quickly open lazygit. In my case, it's lg.

Here are the features I use most of the time from this tool.

Stage/unstage like bullet

Open a PR with a single keypress

Search through commits

Stage/unstage like bullet

Every time performing these type of commands is really a bit painful when a tool like lazygit exists:

git add foo.go
git add bar.js
git logs
git diff foo.go

With lazygit you can quickly see through the changed files and stage/unstage them accordingly. As well as, you can see the changes on each file very easily.

Open a PR with a single keypress

This is my favorite feature of this tool. Because every time I commit something and want to create PR/MR, I have to do a bunch of repetitive clicks here and there. On top of that, sometimes I have to work with GitHub, sometimes GitLab. So even if I wanna use the GitHub CLI tool hub or GitLab CLI tool glab, I am ending up using two different tools. So it's nice when I can open PR/MR just by a shortcut within a second or two regardless of what SCM I am on.

Search through commits

When I have to search through a bunch of commits, lazygit comes very handy. Altho there are other tools that exist as well. But I end up utilizing this tool a lot in this case it's I don't have to open another tool or even VS Code for this.

lazygit is open-source. And easy to download and install, so definitely give it a go!