DEV Community: Tamerlan

Grunt Work in Software Engineering: The Silent Productivity Killer

Tamerlan — Fri, 21 Feb 2025 15:35:50 +0000

In 2022, I joined a Developer Experience (DX) team focused on building internal tools to improve developer productivity.

We had a well-funded team with big ambitions, and at first, things went smoothly. Our process was simple: listen to developers' pain points and solve them.

However, after about six months, we noticed a sharp decline in our internal productivity. I started investigating why—and the answer surprised me.

We were avoiding grunt work.

What is Grunt Work?

Grunt work in software engineering refers to necessary but tedious tasks that no one wants to do.

These tasks may seem small at first but can snowball into major obstacles. Here are six of the most commonly ignored types of grunt work in software engineering.

Grunt 1: Pull Request Reviews

The first and most obvious type of grunt work is pull request (PR) reviews, something I personally struggled with the most.

If your team values software quality, PR reviews are essential to the development cycle. They help maintain high standards and improve the overall product.

The problem? Delays.

When reviews take too long, they block progress. This often happens because developers prioritize their own tasks over the team's efficiency.

Shifting the mindset from "my productivity first" to "team productivity first" makes a huge difference. When engineers recognize that unreviewed PRs are blockers, they’ll take them more seriously.

Grunt 2: Dependency Management

PR reviews may be a major bottleneck, but another commonly neglected task is keeping dependencies up to date. I understand—it’s tedious and often deprioritized. But ignoring it comes with hidden costs.

Let's take either Dependabot or Renovate as an example. They automatically open PRs every week, but they often seem like minor changes—easy to postpone.

Before you know it, you’re stuck with 5+ open dependency update PRs, adding unnecessary clutter.

My problem with this isn't about the dependencies themselves. It's more about the unnecessary cognitive load. If you're working across multiple repositories and see 10 open PRs—8 of them for dependencies—it creates unnecessary cognitive load.

To fix this, consider:

Prioritizing dependency updates instead of postponing them.
Automating the update process to reduce manual effort.
Grouping multiple PRs into one , using custom configurations to streamline updates.

Grunt 3: Cognitive Load

As software evolves, so does its complexity. Over time, this complexity leads to increased cognitive load —the mental effort required to understand and work with the codebase.

This is often referred to as 'tech erosion' or 'code rot.

We need a better approach. Treating refactoring as a separate task—like “Refactor X or Y”—is counterproductive. Instead, make code improvement a habit within the development lifecycle.

Aim to leave the codebase better than you found it —a simple yet powerful principle.

I understand that large-scale refactoring is sometimes necessary, and in those cases, it deserves a dedicated task.

Grunt 4: Testing

Good tests make development safer and more efficient, yet writing them often feels like a chore. Many developers acknowledge the importance of testing but still put it off.

I'm not here to convince you why you should write tests. If you're a seasoned software developer then you know that any serious project would require tests.

Many developers find writing tests tedious and often skip them entirely. So, how do we fix this?

One approach is to enforce testing with automated code coverage tools, but that often leads to gaming the system rather than real quality improvements.

Instead, lead by example and make writing tests effortless. Integrate testing into the development lifecycle and make it a CI pipeline requirement.

Encourage developers to test major features, and when refactoring time comes, they’ll see firsthand how much safer and easier it is to work with well-tested code.

Grunt 5: Marketing

When developing internal tools in a large company, you likely won’t have a dedicated marketing team. But without visibility, even the best tools go unused.

An internal tool is useless if no one knows about it. In a collaborative environment, treat fellow engineers as customers—your tool needs visibility to gain adoption.

If people don’t know it exists, they won’t even give it a chance.

That’s why it’s worth investing some time in showcasing your work. One simple approach I use is a “Friday Showcase” on Slack, where I post a brief update in a channel our users follow. It highlights what we’ve built, what’s improved, and what’s coming next—helping drive engagement and adoption.

An added benefit of this approach is increased visibility for your work. When performance reviews come around, your contributions will be well-documented and easy to showcase.

Grunt 6: Documenting and Showcasing

The last, but arguably one of the most valuable, types of grunt work is documentation and visibility. Developers often dislike these tasks, yet they provide some of the highest career returns.

The average software engineer tends to be introverted, so I understand the reluctance to focus on documentation. However, it's essential. Imagine onboarding to a new project with no documentation—it’s frustrating and time-consuming.

If you've ever benefited from well-written docs, you know how valuable they are. Writing documentation is not just about helping others; it's also a way to make impactful, visible contributions that you can highlight to your manager.

Showcasing your work is crucial, especially in large organizations where it's easy to go unnoticed. If you want to advance in your career, consistently highlighting your impact is one of the best ways to stand out.

Conclusion

Ignoring grunt work doesn’t just slow you down—it affects the entire team. By actively addressing these small but crucial tasks, you’ll not only improve developer productivity but also set yourself up for long-term success.

Thanks for reading.

Setting Up a Testing Environment in Neovim

Tamerlan — Wed, 19 Feb 2025 09:53:11 +0000

One of my favourite features of VSCode is the ability to view and run my tests directly from the UI.

It's not just about the UI; it's about having the flexibility to choose and run specific tests using shortcuts—without relying on the terminal.

I liked that flow and wanted something similar in Neovim.

Hail the Community 🚀

After some heavy research—just kidding! If you Google 'Neovim testing,' the first link will take you to a plugin called Neotest.

Neotest is a plugin that helps you interact with your tests. It follows an adapter architecture, meaning you install the core plugin (neotest), and then add an adapter for your specific test framework.

For example, if you're in the JavaScript ecosystem and use Jest as your test framework, you would install neotest and neotest-jest.

To check if your test framework is supported, refer to the official Neotest documentation here.

Installing and Configuring Neotest

In this tutorial, we'll use lazy.nvim as our package manager. Here's how to install Neotest:

{
  "nvim-neotest/neotest",
  event = { "BufReadPost", "BufNewFile" },
  dependencies = {
      "nvim-neotest/nvim-nio",
      "nvim-lua/plenary.nvim",
      "antoinemadec/FixCursorHold.nvim",
      "nvim-treesitter/nvim-treesitter",
      "nvim-neotest/neotest-jest",
  },
},

As you can see, we have some dependencies. The only required ones are nvim-nio and plenary.nvim. Most adapters will also require treesitter, so we include that as well.

Neotest relies on the CursorHold event, which uses the updatetime setting. By default, this setting is quite high, and lowering it may lead to excessive writes to disk.

It's recommended to use the plugin FixCursorHold which allows detaching updatetime from the frequency of the CursorHold event.

Regarding FixCursorHold, the repo claims it is no longer needed but it is still recommended to use (See this issue)

Finally, we have our first adapter installed for the JavaScript testing framework Jest called neotest-jest

Quit and reopen Neovim to install your new plugins.

Configuring Neotest and Neotest-Jest

The next step is to configure Neotest. The default configurations work well, but you must do some extra work to set up your adapters. Here's my current setup:

local status_ok, neotest = pcall(require, "neotest")
if not status_ok then
  return
end

local jest = require("neotest-jest")

neotest.setup({
  summary = {
      open = "botright vsplit | vertical resize 80",
  },
  adapters = {
      jest({
          jestCommand = "npm test --",
          cwd = function(path)
              return vim.fn.getcwd()
          end,
      }),
  },
})

There isn't anything special here. I configured the test summary page to be a bit bigger and added some basic configuration for neotest-jest.

To learn more about the different configurations available for neotest-jest, check it out here.

Setting Up Keymaps

The final step is setting up keymaps. I'm on the Folke hype train, so I'm using which-key.nvim to create my keybindings.

You don't have to follow my exact setup, but I hope it inspires you to create your own:

{
  -- Neotest related mappings
  {
      "<leader>n",
      group = "🧪 Test",
      nowait = true,
      remap = false,
  },
  {
      "<leader>nr",
      "<cmd>lua require('neotest').run.run()<cr>",
      desc = "Run nearest test",
  },
  {
      "<leader>nf",
      "<cmd>lua require('neotest').run.run(vim.fn.expand('%'))<cr>",
      desc = "Run current file",
  },
  {
      "<leader>na",
      "<cmd>lua require('neotest').run.run({ suite = true })<cr>",
      desc = "Run all tests",
  },
  {
      "<leader>nd",
      "<cmd>lua require('neotest').run.run({strategy = 'dap'})<cr>",
      desc = "Debug nearest test",
  },
  {
      "<leader>ns",
      "<cmd>lua require('neotest').run.stop()<cr>",
      desc = "Stop test",
  },
  {
      "<leader>nn",
      "<cmd>lua require('neotest').run.attach()<cr>",
      desc = "Attach to nearest test",
  },
  {
      "<leader>no",
      "<cmd>lua require('neotest').output.open()<cr>",
      desc = "Show test output",
  },
  {
      "<leader>np",
      "<cmd>lua require('neotest').output_panel.toggle()<cr>",
      desc = "Toggle output panel",
  },
  {
      "<leader>nv",
      "<cmd>lua require('neotest').summary.toggle()<cr>",
      desc = "Toggle summary",
  },
  {
      "<leader>nc",
      "<cmd>lua require('neotest').run.run({ suite = true, env = { CI = true } })<cr>",
      desc = "Run all tests with CI",
  },
}

Running Tests in Neovim

Now that we have everything installed and configured, let's see it in action. The test I will use for this tutorial comes from the official Jest repo. Here's my current test:

// Copyright (c) Meta Platforms, Inc. and affiliates.

import {expect, it} from '@jest/globals';
import sub from '../sub';

it('subtracts 5 - 1 to equal 4 in TypeScript', () => {
  expect(sub(5, 1)).toBe(4);
});

If we want to run this test, we can use the keymap <leader>nr, which finds and runs the nearest test.

Seems like our test has failed and showed us something like this:

If I want to see what's wrong, I can check the output by using the command <leader>no. This is how it looks:

Okay, next I want to see the test summary page and see all my tests at once. We can do that with the keymap <leader>nv. Here's how it looks:

When I press ? it will show me all the available keymaps I have.

I want to run all my tests now, we can run them all using the keymap <leader>na. Let's run all the tests and see what happens to the summary page.

Seems like all my tests are failing and I have to go and fix some stuff. But that's not the point of the article.

Conclusion

I hope you have a working test set up within Neovim by now. Always remember to check out the docs for both Neotest and any adapters you have.

If you have any questions or concerns, leave them in the comments and I'll try my best to help you.

Thanks for reading.

How to overcome writer's block as a developer blogger?

Tamerlan — Mon, 04 Mar 2024 10:29:58 +0000

This year, I decided to solidify my writing habit by publishing an article every week.

It went well for the first couple of weeks, but as time went on, it began to feel like a drag. Ideas kept slipping away, and words seemed to escape me.

Writing became a chore.

I found myself scrambling every weekend, writing something every two hours so I could publish on Monday. This cycle repeated week after week. Despite my efforts, I couldn’t bring myself to write in advance.

However, last night, I took a step back to thoroughly consider and research why I was struggling with writing.

Initially, I attributed my difficulties to the so-called 'writer's block,' but I soon realized that wasn’t the actual issue.

I had a research block, not a writing block.

Yes, you read that correctly. As a non-fiction writer focused on technical articles, my process hinges significantly on research.

Without it, I'm essentially left without content.

Reflecting on my early blogging days, I recall writing about everything I learned, which was feasible because everything was new to me.

Fast forward four years, my learning curve has plateaued somewhat. While I still learn, my focus has shifted towards broader topics in DevOps, Release Engineering, and specific tools like Crossplane, Terraform, etc...

This shift has inadvertently led to a decrease in my research depth, directly impacting my ability to produce content.

It's a simple truth: I cannot write about what I do not know deeply.

So, for anyone finding themselves in a similar predicament, the solution is to amplify your research efforts. Once you have a solid foundation of knowledge, writing becomes the easier part of the equation.

How much should you research?

It's easy to fall into the endless loop of research, constantly seeking more information. However, knowing when to stop is key.

While it’s crucial to avoid getting bogged down, erring on the side of thoroughness is generally wise. I advocate for researching until you're able to explain the subject in terms so simple that even a 5-year-old could grasp it.

PS. I believe I got this method from renowned physicist Richard Feynman. If you're interested, here's a video explaining his studying technique.

Tips on how to research better

Now that we got to the root of the problem, my next objective was to enhance my research skills significantly.

Through meticulous investigation and self-reflection, I've discovered several strategies that have dramatically improved my research process.

Below, I share the key changes and techniques that have made the most difference.

Have a better note-taking system

Initially, my approach to note-taking was somewhat haphazard. I experimented with a basic setup in Notion and even dabbled with Obsidian, but none of these methods truly resonated with me at first.

I returned to Obsidian because I knew I liked the connections system it had. So as a restart, I use a single vault for everything and try to capture as many notes as possible.

This raw collection of thoughts and information serves as a fertile ground from which I can later distil more structured insights.

I later then review and organize these notes into their respective folders. While doing that, I sometimes pick up on connections among them.

This refined approach not only aids in retaining information but also in synthesizing new ideas from seemingly distinct pieces of information.

Use different search engines

This was something I read on Reddit. Google has its algorithms on page ranking and I always thought that other search engines would be quite similar.

But that's not what I discovered.

While researching "Release Engineering," DuckDuckGo revealed several invaluable articles and papers—resources I would have missed had I relied solely on Google.

This experience underscored the importance of diversifying search tools to uncover hidden gems.

PS. They might've been the second or third pages of Google but I usually never go that far, but probably should. Who knows?

Read academic papers

This is another tip I got from Reddit, where you can use Google Scholar to search for terms in academic papers.

This approach has been transformative because I get access to direct sources rather than relying on secondary interpretations found in YouTube videos or blog articles.

Reading material straight from the experts offers a deeper, undiluted understanding of topics.

Follow the Sources

Try to find the sources of the stuff you're reading.

If you're on Wikipedia, you can find it at the end of the page. It will sometimes lead you into rewarding research rabbit holes.

I also like to do this with books so I make sure to check out the references section for any useful recommendations. Finally, if there's any author I like, I try to find what they read and read that.

Learn About Different Topics

It's really helpful to know about things that aren't directly related to what you're focusing on. Sometimes, you can link ideas from completely different areas, and that's what I think true wisdom is all about.

Conclusion

This was such a joy to write because I'd already done all the research beforehand and wrote this in one sitting.

I know this isn't a technical article but the same could be said about that. Now that you've learned why you aren't writing as much, I would like to end it with the following quote:

While this isn't a technical article, the insights apply universally.

To end our discussion, I leave you with a guiding principle:

"It's always better to over-research than to under-research."

What are threads?

Tamerlan — Mon, 21 Feb 2022 16:00:00 +0000

Most, if not all modern operating systems support multiprocessing and at the same time processes can be run in multiple threads hence the word multithreading.

This will give you a significant increase in performance and scalability but it comes with a price. The overall complexity of the code increases and it becomes difficult to debug.

In this article, we will take a look at POSIX Threads and learn how they work under the hood on Linux.

What are threads?

Difference between single-threaded process and multithreaded process.

When you open up a program on your computer, a process (instance) of the program gets created.

A thread is simply a unit of execution within a process.

So if your program is single-threaded that means that the process has one thread (this is usually called the main thread).

On the other hand, if your program utilizes multiple threads this means that your program is multitasking, meaning that it's running computations concurrently hence speeding up the program.

This is the high-level definition of threads, let's take a slightly deeper look into how threads are stored in memory.

Thread Control Block

Information about threads must be saved in memory, but how would it be represented?

Good question.

Threads are represented by Thread Control Block (TCBs).

It contains information such as:

Thread ID – A unique identifier that gets generated by the operating system when a thread gets created.
Thread States – State of the thread that changes as the thread progresses throughout the system.
CPU information – This includes everything that the OS needs to know about the thread such as Program Count and Register Contents.
Thread Priority – It indicates the weight (or priority) of the thread over other threads which helps the thread scheduler to determine which thread should be selected next from the READY queue.
Process Pointer – A pointer to the process that started this thread.
Thread Pointer(s) – A pointer or list of pointers to other threads that were created by the current thread. Now that we know

Now that we know how threads are stored, let's look at how do they increase performance.

How do multiple threads speed up my code?

Let's take a web server as an example.

If the server created a separate process for every HTTP request, we would wait forever for our page to load. The reason is that creating a new process is an expensive procedure for the operating system.

Instead of creating a new process, it would be more efficient to create a new thread.

But sometimes this wouldn't speed up your application.

If your lacking program uses a lot of computing power, then utilizing multiple processes would be more beneficial.

On the other hand, if your facing an Input-Ouput (IO) problem, then multithreading will help you.

Next, let's look at different types of threads and their relationships to each other.

Thread Types

There are two types of threads:

User Threads
Kernel Threads

Supporting threads at the user level means that there is a user-level library that is linked with the process and this library provides all the management and runtime support for the thread.

Kernel threads are managed by the operating system (OS), meaning that the OS kernel itself is multithreaded.

The OS kernel maintains things such as:

Thread Abstraction – It abstracts the use of threads by having a thread data structure such as Thread Control Block.
Scheduling and Synchronization

Next, let's discuss several mechanisms how user-level threads can be mapped to the underlying kernel-level threads.

Thread Mapping

One to Many Model

In this model, several user threads are mapped to one OS kernel thread. All thread management is handled by a custom user library, and this is the advantage of this approach. The disadvantage is that if one single thread makes a blocking call, then the entire process is slowed down.

One to One Model

This is the simplest model, in which each thread created in some process is directly controlled by the OS kernel scheduler and mapped to a single thread in kernel mode. To prevent the application from creating threads uncontrollably hence overloading the OS, they introduce a limit on the maximum number of threads supported in the OS.

Many to Many Model

With this approach, many user threads are multiplexed into the same or fewer than N (number) of kernel threads. The negative effects of the other two models are overcome: the threads are truly executed in parallel and there is no need for the OS to impose restrictions on their total number. However, this model is quite difficult to implement from a programming point of view.

Conclusion

Multithreading can significantly speed up your code if used right.

But it's not all sunshine and rainbows, so it's up to you as the developer to figure out whether its worth implementing or not.

I hope you learned something today and in our next article, we will cover how to implement multithreading in C/C++.

Thanks for reading.

Best Resources to Teach Yourself Computer Science

Tamerlan — Mon, 14 Feb 2022 16:00:00 +0000

I've been programming professionally for almost 3 years.

But I'm gonna be honest with you.

My computer science (CS) skills are pretty lacking. That's why I've dedicated 2022 to finally learn some core computer science concepts.

But where do I start?

That's what I thought a couple of days ago.

Fortunately, I got S tier research skills and found the best resources on the internet for computer science and figured out why not share them with my dear readers.

PS. This is my initial list if you got any suggestions, feel free to message me on Twitter about them.

A quick disclaimer

I just want to say that all of these resources provide you with a comprehensive list of different courses to take to master different computer science subjects.

None of these resources create their own content, they simply pick the best ones found over the internet. This is why you might see some overlap with the courses chosen.

For example, a popular introduction to computer science course would be Harvard's CS50. You would find this course recommended in almost all the resources below.

Another disclaimer is that all of these resources are free. So please don't get scammed.

Open Source Society University (OSSU)

OSSU which stands for Open Source Society University is an organization that:

Empowers learners to master college curricula through free resources

Github Page

OSSU essentially provides you with all the courses required to get a bachelors degree in Computer Science.

So you would expect courses such as:

Data Structures and Algorithms
Math for Computer Scientists
Systems Programming

Their computer science path is by far the most popular one on the whole internet, with a whopping 106k stars on GitHub.

But that's not it.

They also provide other paths such as:

Mathematics
Data Science
Bioinformatics

Teach Yourself Computer Science

If you are more of a minimalistic person. You simply want a minimal list of recommended resources.

Then Teach Your Self CS is the path for you.

It gives you nine core computer science subjects with their recommended resources.

The resources are given based on the difficulty level.

For example for the programming section, they recommend:

Standard Recommendation: Structure and Interpretation of Computer Programs (SICP)
If SICP is too hard, then you can pick up Composing Programs or How to Design Programs.

I personally follow this path for my 2022 computer science plan and I've thoroughly enjoyed it even though I'm not following the recommended order of subjects.

Functional Computer Science

This is also another popular but more "underground" set of resources. I've seen it linked a bunch in Reddit posts and Discord servers.

Nevertheless, it's still a solid list of resources with a focus on functional programming.

So you would expect courses such as:

Principles of Functional Programming
CS 3110 Data Structures and Functional Programming

They not only do that but cover most core computer science subjects and a lot of "niche" subjects which you might find interesting.

Niche subjects include:

Web Programming
Data Science
Quantum Computing
Machine Learning
Mathematics for Finance
Finding Jobs
Software Testing

P1XT Guide

If you want a good balance of theoretical computer science and practical programming then P1XT might be for you.

The nice thing about P1XT is that it's separated into your typical software engineering levels such as Junior, Middle, Senior Engineers.

They have a nice balance of theory and real-world. So you can expect lots of practical projects such as clones of popular web apps.

To be fair, once you get to the intermediate-advanced stage, the content starts to focus a lot more on web development so lots of Javascript and HTML/CSS courses. But nonetheless, they also cover all the core CS subjects.

The Open Source Computer Science Degree

I was pretty sceptical about this one at first because it was made by a "YouTuber", but it's not a bad list whatsoever.

It's made by a popular programming YouTuber called ForrestKnight. He made a video explaining why he chose the specific course and subjects in his list.

You can check it out here.

https://www.youtube.com/watch?v=NyOvFSP_IpQ

As I understood this was inspired by the OSSU computer science resource but is more minimal. There aren't many courses but it still covers a good amount.

The list also contains a lot of Java, so if you ever plan to be a Java developer then this list might be for you.

You can check out the list on GitHub.

Conclusion

Now, you might be feeling a bit overwhelmed by the number of choices you have. But don't worry, just pick one and stick to it.

Most of these lists are pretty similar, they get different once you get to the advanced courses. At that point, it all depends on your interests.

I might have missed some other cool resources, so if you got any and want me to add them to the list, feel free to message me on Twitter and I will get back to you.

Thanks for reading

UDP in Depth

Tamerlan — Mon, 13 Sep 2021 16:32:48 +0000

Two weeks ago I published an article about TCP.

Having a single article, about TCP isn't nice.

So here's another one this time about UDP.

Today you will learn:

How does the UDP protocol work
The packet format that UDP protocol uses
Applications behind the UDP protocol

What is the UDP Protocol?

UDP which stands for User Datagram Protocol is one of the main protocols of the internet protocol suites.

But some of you may ask?

"What is a protocol?"

A protocol is essentially a set of rules that allows two computers to talk to each other.

There can be many different sets of rules, hence we have many different protocols.

UDP is one of them.

But what makes UDP different?

Short Answer: UDP is stateless, meaning it doesn't save any state between the client and server, it also is very light making it fast, but the downside is that it's not reliable, packets can go missing, corrupted, etc...

Long Answer: Read on...

UDP Packet Format

In our last article about TCP, we found out that TCP has a ton of headers.

Unlike TCP, UDP is light, hence having the minimal amount of headers.

Let's quickly go over each field:

Source Port — The sending device port.
Destination Port — The receiving device port.
Length — This field specifies the length in bytes of the UDP header and UDP data.
Checksum — Indicates whether the header was damaged in transit.
Data — The actual info that your sending

UDP Features

To be honest, there isn't much to say so let's condense the features of UDP in a list:

UDP does not acknowledge packets, so if data goes missing, it won't be retransmissioned.
UDP is a good protocol for data flowing in one direction
UDP is simple and suitable for query-based communications.
UDP is stateless, so it basically doesn't save any state between the client and server.
UDP does not provide congestion control, meaning that it doesn't regulate the amount of data is being sent over.
UDP does not guarantee the orderliness of data

It sounds like I'm talking about the cons of UDP, but there are in fact many use cases for it. For one it's simple and two it's fast.

UDP Applications

Streaming Media — Streaming sites are fine with loss packets, if one frame is lost in a video it won't affect the quality much, but what's important is speed. This is why UDP is a good protocol for streaming media.
Domain Name Servers — This is used to get the IP address from domains for example www.google.com leads to 142.251.1.102. This works well using UDP because queries must be fast and only consist of a single request followed by a single reply packet.
VPN - Some VPN systems such as OpenVPN may use UDP and perform error checking at the application level while implementing reliable connections.

Conclusion

Congratulations, you are one step closer in being a better developer!

This was a pretty short post, there isn't much to say (surface-level) about UDP, but either way I hope you enjoyed today's article.

If you enjoy my content, I have more in my personal blog, you can check it out here.

Also, I tweet snippets of useful stuff over twitter @tamerlan_dev

Thanks For Reading!!

Design Patterns: Composite

Tamerlan — Mon, 06 Sep 2021 02:06:33 +0000

Composite is one of the easier patterns in this series, but this does not mean it's not popular.

In fact, it's one of the most useful patterns because it can be expressed in many different business domains.

So without further ado, let's begin.

Today you will learn:

Structure and theory of the composite pattern
Problems that the composite pattern solves
Solution it provides
Implementation of the solution
Recognize opportunities to use the composite pattern
Benefits and downsides of the composite pattern

Definition

Formally speaking the composite pattern allows us to treat composites and individual objects equally.

But what does that mean?

Let's say you work for an e-commerce site, there are two kinds of products:

Product — Typical individual object (toothpaste, apple, etc...)
Box — Group of products or even other boxes

Visually speaking it would look more like this:

So in a nutshell, the composite pattern allows us to compose objects into hierarchical structures, and then work with these structures like individual objects.

Let's take a look at another example.

Problem

Let's imagine you are building the next Spotify.

What do you offer the user?

You would most obviously say music.

But the catch is that your app allows you to have playlists of songs or even other playlists.

The question is now how do we represent this in code?

One way would be to simply loop and check if the object is a song or a playlist.

It would look like this:

function play(object){
    if (object instanceOf Song){
        const song = object
        return song.play()
    }

    playlist = object

    // else it is a playlist
    for(stuff in objects){
        play(stuff)
    } 
}

This seems weird to write, why does my client have to know whether this is a song or a playlist?

Your client should not know, and this is the problem that the composite pattern solves.

Solution

Before we transform our code above, let us quickly go over the components of the composite pattern.

Component — The uniform interface that both the composite and the leaf will abide by.
Composite — Our "group" object that implements the component interface, and has a list of leaf objects.
Leaf — Our individual object, that directly implements the component interface.

Now that we know the core components of the composite pattern, let us transform our previous code into something abiding by the composite pattern:

Step 1: Define our component interface:

interface SongComponent {
    function play();
    // other uniform functions
}

Step 2: Define our leaf class:

class Song implements SongComponent {
    function play(){
        // play the damn song!!
    }
}

Step 3: Define our composite class:

class Playlist implements SongComponent {
    songs = []

    constructor(songs){
        this.songs = songs
    }

    function play(){
        for(song in this.objects){
            song.play(stuff)
        } 
    }

    function add(object){
        this.songs[] = object
    }

    function pop(object){
        this.songs.pop()
    }

}

Step 4: Test the code:

function main(){
  song_one = new Song()
    song_two = new Song()

    playlist_one = new Playlist([song_one, song_two])
    playlist_two = new Playlist([song_one, song_two, playlist_one])


    // we treat of all these equally
    song_one.play()
    song_two.play()
    playlist_one.play()
    playlist_two.play()
}

Congratulations, you have just implemented the composite pattern.

Rewards: Respect + 10

PS. You might be asking why didn't we add functions like add() or pop() to our component interface? This is a very popular debate, both are right. It's a question if you want your code to be uniform or type-safe. I chose type-safe for this example.

When to use this pattern?

This pattern is pretty simple, you would only use it when:

You want to express your data hierarchically.
You want to treat individual objects and composites equally.

Benefits and Downsides

It's not all sunshine and rainbows, but let's go over the rainbows first:

You work with tree-like structures more conveniently.
You can introduce new element types without breaking existing code.

Now comes the downside:

It's difficult to create a uniform interface to classes whose functionality differs greatly, this sometimes forces to over-generalize classes.

Conclusion

I'm glad you reached this far.

Now you can leverage the composite pattern in your next or existing projects.

If you did, leave a comment down below if you like the pattern or not.

Also, I also publish small snippets of these articles and other good stuff on Twitter @tamerlan_dev.

Thanks for reading!

TCP in Depth

Tamerlan — Mon, 30 Aug 2021 01:55:13 +0000

As backend engineers, we really like our black boxes.

We don't enjoy getting into the nitty-gritty details.

One of the topics that backend engineers avoid learning are communication protocols.

Sure you know what is HTTP, and how it works on the surface level.

But do you know how packets get transferred?

You don't?

Don't worry, it's not the end of the world.

In this article, I will go over one of the three main internet protocols, which powers the world wide web.

In this article you will learn:

What the TCP protocol is
TCP Packet Format
The different stages of the TCP protocol
Features of the TCP protocol

What is the TCP protocol?

TCP which stands for transmission control protocol is one of the main protocols in the internet suite. It is used on top of the IP (internet protocol) to ensure reliable transmission of packets.

TCP fixes many issues that arise when you use IP such as lost packets, out of order packets, duplicate packets, and corrupted packets.

Since TCP is most commonly used on top of IP, it is referred to as TCP/IP.

Now that we know the basics of TCP, let us go a bit deeper and discuss the packet format of TCP.

TCP Packet Format

The figure above shows the difference between the TCP and the IP packet. As you can see the TCP has a lot more fields in the header, this is made to ensure reliability.

Let us briefly go over each field in the TCP header:

Source Port Number — The sending device port.
Destination Port Number — The receiving device port.
Sequence Number — The initial client initiating the connection must choose a random sequence number, which is then incremented according to the number of bytes.
Acknowledgement Number — This field holds the sequence number of the next byte the receiver expects. The acknowledgement field is defined only if the ACK field is set.
Offset — Size of the TCP header.
Reserved — This field must always be zero, it is reserved for future use.
Flags fields — TCP uses nine control flags to manage data flow in specific situations:
- URG — Indicates that some urgent data has been placed.
- ACK — Indicates that acknowledgement number is valid.
- PSH — Indicates that data should be passed to the application as soon as possible.
- RST — Resets the connection.
- SYN — Synchronizes sequence numbers to initiate a connection.
- FIN — Means that the sender of the flag has finished sending data.
Window Size — This field is used by the receiver to indicate to the sender how much data it can accept.
Checksum — Indicates whether the header was damaged in transit.
Urgent Pointer — Returns the urgent pointer of a TCP segment. If the URG flag is set, this field is an offset from the sequence number indicating the last urgent data byte.
Options/Padding — Specifies various TCP options.
Data — Contains the information that your sending.

TCP Phases

Let's go through the process of transmitting a packet using TCP.

Connection Phase

Before we send data using TCP, we first have to establish a connection.

The client and server must know each other.

They go through a process known as the TCP three-way handshake.

Let's go through the process:

The client sends a packet with the SYN flag set to 1 along with it's random sequence number.
The server sends a packet with both the SYN and ACK flags set to 1.
Finally the client sends a packet with the ACK flag set to 1 indicating that it acknowledges the last request.

Data Transfer Phase

Now that the client and server are acquainted with each other, they are ready to send and receive data to each other.

This is essentially no man's land, but there are two very important rules that every request must follow:

Every request must be followed by an ACK request, acknowledging that the receiver received the previous request.
If the receiver doesn't send the ACK request, this indicates to the user that the receiver did not receive the request, and will re-transmit it again.

Connection Termination

Once the client and server are satisfied, the connection is finally ready to be closed.

Let's go through this process:

Either the client or the receiver can initiate the termination by sending a request with the FIN flag set to 1.
The receiver will respond back with the FIN and ACK flags set to 1.
One more ACK request is needed, and finally the connection is closed.

Features of TCP

Now that you know most of the nitty details of the TCP protocol.

Let's go over some of the features that TCP provides us.

Connection Based

Every TCP connection must be stateful, meaning the client and server must know each other. This is both good and bad, it honestly depends on your application use case. Some apps need a stateful connection while others don't.

Congestion Control

TCP has several different methods for controlling congestion or traffic. We do this because we don't want to overload our servers. Methods in controlling congestion include:

TCP Slow Start
Congestion Avoidance
Fast Retransmit
Fast Recovery

Acknowledgement

As we have seen in the previous section, every request must be acknowledged in TCP. We do this to make sure no packets are lost, and this helps us handle packets that are out of order.

Conclusion

TCP is pretty much used everywhere, but you would very rarely use it raw. Most of the time you would use another protocol that is built on top of TCP such as HTTP, Web Sockets, SMTP, FTP, etc...

Many developers feel overwhelmed by the sheer amount of protocols, but the secret is to study from first principles. Most of these protocols come up from either TCP or UDP, once you know these two, the others are simply variants that are easy to learn.

Before we end it off, I would like to say if you enjoy my content feel free to follow me on Twitter @tamerlan_dev.

Thanks for reading, if I missed anything feel free to leave them down in the comments and start a discussion.

Design Patterns: Bridge

Tamerlan — Mon, 23 Aug 2021 05:54:27 +0000

Liquid syntax error: 'raw' tag was never closed

Project Ideas to Make You a Better Developer

Tamerlan — Tue, 17 Aug 2021 07:00:26 +0000

There's no secret method in becoming a better developer.

There's no substitute for hard work.

You gotta study, and simply grind it out.

But sometimes you can speed up the process.

One way is to create "good" projects

But what are good projects?

Let's dive in.

What makes a good project?

All projects are good.

But, some are better than others.

How do we judge projects?

Before I begin listing out the criteria by which I judge projects, I just wanna say that this is very subjective and at the end of the day it totally depends on you, if you think a project is great, then it is great, no arguments needed.

Now with that done, let's go over what I find important in a project:

Tech Stack — We can judge a project by the tech stack it's using. That also depends on you, if you wanna learn Java, then simply create projects using Java. I'm not advocating using the latest and greatest tech, but it's good to experiment with different tech stacks and see which ones you enjoy programming in.
Size — The bigger the project, the better it is? In most cases it is, big projects force you to think about architecture, file structure, and lots of other things that you might ignore. On the other hand, small projects are good if your focused on learning one specific tech. For example, if you wanna learn web sockets, you would create a super simple chat app, with the basic needs just to learn web sockets.
Challenge — An easy project is no fun, you won't learn much. That's why it's important to have a project which is slightly outside of your comfort zone. Make sure it's not too outside of your comfort zone for you to be overwhelmed.
Fun — In my opinion, a fun project is always a good project. It just motivates you to write code, and simply have fun.

Now that we know how to judge projects, let us answer a very common question that most beginner programmers have.

Should my projects be recruiter oriented?

This is another common question that junior developers have.

The simple answer is no.

Most companies don't look at your personal projects UNLESS they are super outstanding such as a popular open-source project or equivalent.

What I'm trying to say is that you should create projects because you genuinely want to do them, you might want to learn some new technology, or simply have fun.

Projects

That the theory is over with, let's move over to more practical advice.

Here are the projects I recommend every programmer to at least try doing.

PS. I probably have missed some other great project ideas, if I did make sure to leave them down in the comments.

Clones (Netflix, Google, Amazon, etc...)

You got no project ideas?

Clone apps?

What apps?

Any app., it can be Netflix, Google, Amazon, etc...

Cloning apps is a great way to learn how these giant apps were made.

You essentially reverse engineer these apps and learn their trade secrets.

Visualizers

Visualizers have become super popular lately.

Mainly because it teaches you core CS fundamentals.

It's also a nice project to put on your resume.

You can visualize lot's of things, sorting algorithms, shortest path algorithms, etc...

Bonus points making this much more beautiful

Video/Text Chat App

I don't like putting specific projects, but I couldn't skip this one.

I like this project, it's fun and it teaches you trending topics such as web sockets and WebRTC

It's also a very cool project to put on your resume.

CMS System

This is a classic.

CMS systems can be very simple or complex.

If by any chance your CRM system is useful, you can turn it into a full-fledged SaaS (Software as a Service) making you some side income.

Cloud Computing Project

Lot's of companies are moving to cloud providers for their infrastructure needs.

What better way to learn the cloud, than creating a cloud-based project.

You can create a small project that uses some sort of cloud service:

Storage: AWS S3
Database: AWS RDS
Functions: AWS Lambda

PS. You don't have to use AWS, it's simply the most popular one currently. You can check other cloud providers such as Google Cloud and Microsoft Azure.

Games

If you enjoy playing games, why not make one?

It might be tough but make sure to pick something that isn't too hard, you won't be making the next witcher.

You can make a 3D game that will teach you lots about physics, or even a multiplayer game that will teach you about networking.

You can start off by learning Unity, or my personal favourite Godot.

Distributed Systems Project

This one might be a bit hard to do, but it will immensely help you because most companies are moving to a distributed architecture.

You can create simple microservices that communicate with each other using HTTP or gRPC.

You can add a reverse proxy, as an API gateway, maybe even a load balancer, and you can host this on the cloud using some cloud provider.

Online Code Editor

This is another fun and challenging project.

Personally, I've never done this but would assume that it's no easy feat.

Your gonna have to be able to work with files, and syntax highlighting.

Don't forget about running the code, probably gonna use some sort of compiler underneath.

Regex Query Tool

This will probably be a frustrating project due to how annoying regex is.

Nevertheless, it's a great project, your gonna learn how regex works (finally!!)

You can add features like having test cases for regex, and even a history

File Manager

This is another fun project to do, it teaches you how the file system works.

It will also teach you basic data structures because your gonna have to use them to implement some features.

Machine Learning Project

Machine learning is hot.

People think it's too hard, but in fact, there are many ready-made libraries that abstract all the hard stuff for us.

You can create a mask detector app or handwriting detector app.

Your Own Framework

This is a great project because it will make you appreciate the frameworks your already using.

To start you can choose a framework to clone.

You can start off by cloning basic functionality and slowly start implementing more features.

Conclusion

That was long?

I sure hope you got an idea for your next project.

If so, tell me which one your gonna make down in the comments below!

Thanks for reading!

The Plug

If you want more content like this, follow me on dev.to or even check out my personal blog.

I also publish small snippets of content on Twitter, follow me @tamerlan_dev

Design Patterns: Adapter

Tamerlan — Mon, 09 Aug 2021 03:34:08 +0000

In the last article, we have finished the first chapter in our design pattern series.

Today, we start a new chapter, where we will go over the structural design pattern.

"But, what's structural?" you may ask.

While creational patterns focus on how objects are created, structural patterns focus on how efficient do objects combine to create other complex objects.

A real-life analogy would be a fruit salad, you can make fruit salads in many different ways with all sorts of different fruits, but there are some combinations that are superior to others. Structural design patterns help use effectively and flexibly combine objects together to form complex structures.

To begin, the first of these patterns would be the Adapter pattern.

Today you will learn:

Core concepts behind the Adapter pattern
How to implement the adapter pattern
How to recognize opportunities the adapter pattern
The benefits and downsides of the adapter pattern

Definition

We have a ritual in this series, to start googling things.

So let's google: "what is the adapter pattern?"

You would get a Wikipedia answer that would look something like this:

In software engineering, the adapter pattern is a software design pattern that allows the interface of an existing class to be used as another interface. It is often used to make existing classes work with others without modifying their source code

Why does Wikipedia make everything sound so damn complicated?

In a nutshell, the adapter pattern allows classes with incompatible interfaces to work with each other.

But what do you mean by incompatible interfaces?

Good question, lemme give you an example

PS. I'm taking this example from refactoring.guru, they are a great resource, and most of my research comes from there. You can check them out here.

Imagine that you have a stock monitoring app.

The app currently has two components:

The third-party library you use to get stocks data.
A client that monitors, and visualizes the data.

One day you come across a new library, that provides analytics.

You get all excited and begin coding.

You eventually realize that your current code isn't compatible with the analytics library.

Your code, works on XML, while the analytics library works in JSON.

Your stock provider only works with XML, while the analytics only works with JSON.

This may be the end...

Source: https://refactoring.guru/design-patterns/adapter

At this point you have two options:

Get all grumpy and quit
Toughen up and find a solution

For the sake of this article, let's say you went with option number two.

After a while, you come across an article, about the adapter pattern, and soon realize it's a perfect opportunity to use it.

You just have to create an Adapter class, that transforms XML to JSON.

Source: https://refactoring.guru/design-patterns/adapter

The adapter has to wrap around the XML object and transform it into JSON.

The XML class doesn't even know it's being wrapped.

Seems simple enough, let's implement this!

Implementation

Currently, our client looks something like this:

import stock_data_providor from "third-party-stock-library"

class Client {

    public function main(){
        const xml_stocks = stock_data_provider.get_all_stocks()

        this.visualize(xml_stocks)
    }

    public function visualize(){
        // visualization code
    }

}

There are currently only two components, the stock data and client.

Let's try adding the analytics library:

import stock_data_providor from "third-party-stock-library"
import analytics from "third-party-analytics-library"

class Client {

    public function main(){
        const xml_stocks = stock_data_provider.get_all_stocks()

        this.visualize(xml_stocks)
        analytics.analyze(xml_stocks)
    }

    // rest of code

}

This will throw an error because the analyze function only accepts a JSON.

To fix that, we have to transform the XML into JSON.

Let's create an adapter class:

class XmlToJsonAdapter(){
    const xml_data

    constructor(xml_data){
            this.xml_data = xml_data
    }

    public function get_json() {
        // return json version of xml
        // out of the scope of this article 
    }

}

Our adapter class accepts xml_data and with the help of the get_json function, it returns a JSON version of the XML.

Let's update our client:

import stock_data_providor from "third-party-stock-library"
import analytics from "third-party-analytics-library"
import XmlToJsonAdapter from "./xml_adapter"

class Client {

    public function main(){
        const xml_stocks = stock_data_provider.get_all_stocks()
        const json_format = new XmlToJsonAdapter(xml_stocks)

        this.visualize(xml_stocks)
        analytics.analyze(json_format)
    }

    // rest of code

}

Our code is finally working, good job in implementing the adapter pattern.

A key to learning design patterns is to know when to use them.

Let's go over opportunities on when to use this pattern.

When to use this pattern?

Incompatible Interfaces — When you want to integrate two or more classes with incompatible interfaces, you can use the adapter pattern to make it work.
Code Reuse — Use the adapter pattern when you want to reuse legacy code without making any modifications to the original code.

Benefits

Throughout this article, we have covered the technical aspects of the adapter pattern.

Let's take a step back, and think about why is this pattern useful:

Single Responsibility Principle — You separate the data conversion code, from the underlying business logic.
Open Closed Principle — You can easily introduce new adapters, without breaking the existing client code, as long as they work with a common interface.

Downsides

Time to hit reality, it's not all sunshine and rainbows.

Let's go over the downsides in using the adapter pattern:

Complexity — The overall complexity of the code increases, due to the addition of extra classes and interfaces. Sometimes it's easier to change the code in the services. But keep in mind, the path of least resistance isn't always the best.
Adapter Chain — Sometimes many different adapters are required, causing an adapter chain. This kind of code simply gets very messy and hard to debug.

Conclusion

I would like to end it off with a question.

What do you think about this pattern?

Do you ever see yourself using it?

Can't wait to see your answers down in the comments.

This has been Tamerlan, I would appreciate it if you would follow me on Twitter @tamerlan_dev and check out my blog softwareadventuring.com for more content like this.

Today you learned:

Definition and implementation of the adapter pattern.
When to use the adapter pattern.
The benefits and downsides of using the adapter pattern.

Thanks for reading!

Serverless For Dummies

Tamerlan — Mon, 02 Aug 2021 03:49:52 +0000

A couple of days ago I started looking at job vacancies for backend developers.

I started to notice some sort of pattern.

They almost all required some sort of experience with cloud providers such as AWS.

I don't have any such experience, and this was the inspiration behind this article.

I've scoured the internet for all sorts of information on cloud providers, it turns out there is a common unifying architecture behind all of them.

It's called Serverless.

In this article, you will learn:

How companies manage their infrastructure before introducing serverless
The core concepts behind the serverless architecture
The benefits and drawbacks of using the serverless architecture
Common misconceptions about serverless

The History Behind Serverless

Serverless is the latest evolution of managing software infrastructure.

Every evolution eases the management of infrastructure, making it easier, faster, and cheaper.

Let's go over each of them.

Do it All Yourself (D.I.A.Y)

In the beginning, if you wanted to publish your software, you had to do all the "grunt" work yourself.

Meaning, you had:

Buy a server
Set it up (operating system, firewalls, etc...)
Copy your code over to the server
Maintain it

This is slow and pretty expensive.

You had to manually upgrade your servers and fix any hardware issues that come up.

Another big issue with this approach is scalability.

You have to get additional servers, and your gonna have to deal with load balancing, which may get very frustrating.

But on the bright side, you have full control of the server and the contents inside it.

Virtual Machines

CPU's nowadays are much faster than they were in the past.

This advancement has brought a new way to manage infrastructure.

Instead of configuring one workload/program with one physical server, we can have multiple workloads on a single physical server.

This is made possible by installing a hypervisor such as VMware vSphere or Microsoft Hyper-V. This allows us to support multiple guest operating systems by sharing the host's resources, such as memory and processing.

In comparison to physical servers, virtual machines are more:

Cheaper: You can have multiple workloads on a single physical machine.
Efficient: The hypervisor efficiently distributes resources to virtual machines.
Scalable: To scale, you can simply add more virtual machines on a single server.

But it's not all sunshine and rainbows, the downside is that it is much more complex to manage virtual machines than it is physical servers.

Containers

Containers are pretty popular nowadays.

They were mostly popularized due to Docker.

Containers are essentially an "upgrade" to virtual machines.

It jumbles your program, with the minimum dependencies needed to run it into a single unit.

Instead of booting up a whole operating system for your program, containers share the hosts operating system. This makes them very light and fast.

This is the basics of containers, but if you want a more thorough explanation, check out our post on Docker and Containerization.

Serverless

Source: https://www.gocd.org/2017/06/26/serverless-architecture-continuous-delivery/

Serverless is the latest addition to infrastructure management.

It essentially uses a cloud provider (AWS, Azure, or Google Cloud) to completely manage your infrastructure.

You don't have to worry about servers, scalability, fault tolerance, etc...

It's all managed by the cloud provider.

Initially serverless started out as:

Backend as a Service (BaaS)
Function as a Service (FaaS)

Let's delve a bit deeper into each

Backend as a Service

Serverless was first thought of applications that partially or fully use third party cloud provided services to manage server-side logic.

Examples include mobile apps or single pages applications (SPA) that use:

Cloud Accessible Database (ex. Firebase, Parse)
Authentication Services (ex. OAuth, AWS Cognito)

These types of services are known as Backend as a Service (BaaS).

Function as a Service

The most popular meaning of serverless is Function as a Service (FaaS).

This is where application code is still run by the developer but it’s run in stateless compute containers that are event-triggered, ephemeral (may only last for one invocation), and fully managed by a third party.

The most popular FaaS is AWS Lambda, others include Google Cloud Functions and Azure Functions.

We usually refer to FaaS when talking about Serverless.

Benefits

You might ask me:

"why would I use this?"

This is a very valid question, and to answer that we will go over the benefits that serverless provides us.

Cheap — In serverless, you only pay for what you use. For example, in a traditional server of 100GB, if you're only using 10GB of the 100GB, you would still pay for the full 100GB. While in serverless you would only pay for what you use. This can be extended to both BaaS and FaaS, it might be cheaper to not implement some features if you can directly use a backend service provided. While for FaaS, the cost benefits come in scaling. Meaning that you only pay when your functions are being run. When they aren't being run, you don't pay a single dime.
Fast — When you don't have to worry much about infrastructure, you have the ability to focus most of your energy on development. Essentially making time to market, much faster.

Drawbacks

It's time to face reality.

Nothing is perfect.

It's time to go over the drawbacks of using serverless:

Vendor control — Your cloud provider controls your whole infrastructure, which may cause issues if they have any problems on their end. Problems such as system downtime, unexpected limits, cost changes, loss of functionality, forced API upgrades, and more.
Vendor lock-in — Cloud providers aren't interchangeable, they may have the same services but most likely that they are implemented differently. If you want to move from one provider to another, you will be forced to do some code changes or even architectural changes.
Complexity — Things get complex when you have many functions. Complexity may arise in code, architecture, or even simply debugging.
Testing — Unit testing functions isn't that hard, because they are stateless and isolated. The difficulty comes when you have to do integration tests between two or more functions.

Common Misconceptions

Serverless started in 2015, it's still fairly new, with that comes a lot of misconceptions.

Let's break down the most common misconceptions that people have about serverless.

Serverless = No Servers

Serverless doesn't mean there aren't any servers involved.

Your code must be stored somewhere.

It just means that you don't have to deal with it anymore.

Serverless = Fewer Servers

Serverless Means Functions as a Service (FaaS)

Most people think that Serverless are essentially FaaS such as AWS Lambda, but there are many other services that can be considered to be serverless.

Here are the ones provided by AWS:

Serverless doesn’t perform as well

Many people say that serverless functions take way too long to start but this happens when you don't properly configure the right memory size for each function.

Some functions simply require more memory and some less. It's up to you to find the right balance.

Serverless is super cheap

There's this meme going on about huge bills coming from cloud providers.

Sadly it's true, this happens when you just use an absurd amount of services or not optimizing the use of your services.

Conclusion

Serverless is definitely the future.

There's no resisting it.

But you pushed through it, and have gotten the basics of serverless down.

Today you learned:

The history behind serverless
Core concepts of serverless architecture
Benefits and drawbacks of serverless

DEV Community: Tamerlan

Grunt Work in Software Engineering: The Silent Productivity Killer

What is Grunt Work?

Grunt 1: Pull Request Reviews

Grunt 2: Dependency Management

Grunt 3: Cognitive Load

Grunt 4: Testing

Grunt 5: Marketing

Grunt 6: Documenting and Showcasing

Conclusion

Setting Up a Testing Environment in Neovim

Hail the Community 🚀

Installing and Configuring Neotest

Configuring Neotest and Neotest-Jest

Setting Up Keymaps

Running Tests in Neovim

Conclusion

How to overcome writer's block as a developer blogger?

I had a research block, not a writing block.

How much should you research?

Tips on how to research better

Have a better note-taking system

Use different search engines

Read academic papers

Follow the Sources

Learn About Different Topics

Conclusion

What are threads?

What are threads?

Thread Control Block

How do multiple threads speed up my code?

Thread Types

Thread Mapping

One to Many Model

One to One Model

Many to Many Model

Conclusion

Best Resources to Teach Yourself Computer Science

A quick disclaimer

Open Source Society University (OSSU)

Teach Yourself Computer Science

Functional Computer Science

P1XT Guide

The Open Source Computer Science Degree

Conclusion

UDP in Depth

What is the UDP Protocol?

UDP Packet Format

UDP Features

UDP Applications

Conclusion

Design Patterns: Composite

Definition

Problem

Solution

When to use this pattern?

Benefits and Downsides

Conclusion

Further Readings

TCP in Depth

What is the TCP protocol?

TCP Packet Format

TCP Phases

Connection Phase

Data Transfer Phase

Connection Termination

Features of TCP

Connection Based

Congestion Control

Acknowledgement

Conclusion

Design Patterns: Bridge

Project Ideas to Make You a Better Developer

What makes a good project?

Should my projects be recruiter oriented?

Projects

Clones (Netflix, Google, Amazon, etc...)

Visualizers

Video/Text Chat App

CMS System