Home on nyadgar.com

Making a JSON Parser in Haskell

Mon, 06 Apr 2026 00:00:00 +0000

Info

If you are here to explore the source code click here.

This article is different from my usual. I’m inviting you to join me in writing a JSON parser in Haskell. We’ll review the JSON RFC standards and create a Haskell data model for valid JSON. For parsing, I challenged myself to avoid consulting other implementations, believing such challenges enhance problem-solving skills.

The Problem With Feature Flags

Wed, 07 Jan 2026 00:00:00 +0000

What is a Feature-Flag?

A feature-flag service is essentially a configuration server that allows your applications to read real-time configurations (i.e., feature-flags or togglers). For instance, if you’ve deployed a new feature integrated across your stack, you’ll want to ensure that all microservices involved can be toggled to support it using a single flag. This approach enables your teams to deploy changes at their own pace while ensuring the new feature is available only when all relevant services are ready to support it.

Monads (finally)

Sun, 08 Jun 2025 00:00:00 +0000

If you have searched for monads and reached this article, you probably have some degree of knowledge about monads. You may have already put a fair amount of effort into learning monads. In any way, whenever you’ve tried to learn monads, you have likely encountered two main approaches:

The: Monads are simple, here’s a simple example of a monad.
Or the famous: A monad is a monoid in the category of endofunctors.

In both approaches, the layout is similar. We start with a strong statement like: A monad is a powerful concept when applied to programming, and later apologize for being one of the most difficult programming concepts to grasp. The reality is that all of these statements about monads are valid, and the truth lies somewhere in the middle.

Happy Birthday Paradox

Mon, 28 Apr 2025 00:00:00 +0000

The Birthday paradox only seems like a paradox because it unexpectedly challenges our perception of probability. It states that in a group of only 23 individuals, there is more than a 50% chance that at least two are sharing a birthday. Although it may seem counterintuitive, we have the math that proves and supports this statement.

In this article, we will gradually reprogram our intuition and build the knowledge required to derive the expression that proves the paradox. This blog focuses on software engineering and system design so we will follow a real-world example of this problem found in software. But first, let’s start with basic counting.

Scaling gRPC With Kubernetes (Using Go)

Mon, 20 Jan 2025 15:50:12 +0200

The Tech

gRPC is a strong player in microservices-based systems. Leveraging Protocol Buffers for well-defined API contracts, fast serialization (about X5 faster than JSON), smaller payloads, and the use of streams (thanks to HTTP/2). It’s easy to see why this technology for real-time microservice communication is a good choice.

HTTP/2

Unlike a typical REST API that’s built on top of HTTP/1.1, gRPC is built on top of HTTP/2. The most noticeable feature of HTTP/2 is the ability to perform server push. This feature allows servers to asynchronously push data to the client before the client asks for it. gRPC leverages server push to support streams, a key feature that separates gRPC from any other HTTP/1.1-based API. Because of that, HTTP/2 requires a long-lasting TCP connection between the client and the server.

Go Interfaces: Why, How and When

Sun, 12 Jan 2025 00:00:00 +0000

In programming, interfaces are a powerful concept that lets us express our code more abstractly. Interfaces allow us to reason about the higher-level logic of our processes without getting down to the small details. Go has arguably one of the best interface implementations. With great features like implicit implementations, assertion, and more.

Interfaces must be used cautiously since they introduce more abstraction to our code, making it susceptible to unnecessary wrappers, misuse of definitions, and sometimes, even memory issues. In this article, I will discuss cases where interfaces can positively impact your code. But first, let’s talk about what an interface is not.

The Beautiful Math of Bloom Filters

Wed, 13 Nov 2024 15:50:12 +0200

Probabilistic functions can model many algorithms and procedures. They can help us optimize procedures to produce the best results. Experienced software engineers know that at some point, almost any software will reach some level of non-determinism, where a solution is not absolute but approaches the best results if using the optimal configuration. Mathematically, such a solution usually boils down to finding minima, maxima or limits of some probabilistic functions.

In this article, we will explore the beautiful math behind Bloom filters. We will explore the accuracy and trade-offs of Bloom filters and see why a Bloom filter can be an excellent choice for some cases, especially in Big Data, OLAP systems, dealing with huge and fairly static datasets.

Vim is Better - Here's Why

Mon, 26 Aug 2024 15:50:12 +0200

For non-users, Vim is often perceived as an outdated and cryptic text editor. Its steep learning curve allegedly makes it not worth the time investment, especially when other text editors are much more straightforward. A common claim among programmers is that Vim cannot compete with modern IDEs. In this article, we’ll see if this claim hold truth. We will also challenge the claim that Vim is better than any other text editor and IDE out there.

What Would it Be Like to Do Functional Programming in Go?

Wed, 24 Jul 2024 15:50:12 +0200

Warning

Disclaimer: Go is not a pure functional programming language. This article does not try to teach you functional programming in Go since imposing functional programming concepts, may result in unnecessarily awkward code. Go has its style, and it’s proven to be highly successful. Therefore, there’s no point in forcing a foreign dialect on Go code. Haskell would be a great choice if you want to express yourself functionally.

This article aims to provide imperative programmers a bridge to the functional world. Crossing that bridge and seeing the other side can help us reimagine problem-solving and add new skills to our set. We will encounter Go translations to some original Haskell code, hoping this will allow us to understand the original dialect.

A Server Error Got Me a Free Meal

Tue, 02 Jul 2024 15:50:12 +0200

I was at the office, about to go out and grab lunch from a nearby restaurant. Like many companies, I work in one that uses a service to manage our budget for paid meals. Using a mobile app, I can generate a 5-digit code, which I give to the restaurant, and it automatically charges my account. Beautiful, simple, and effective.

I was standing in line, tapping my fancy code-generation button, and after a few seconds, I witnessed a (probably) rare event. The food app suddenly showed me that my order had been accepted and confirmed. Did someone hijack my code? At this point, I thought this was just a client bug. I regenerated a new code and went on with my order.

Profiling in Go: A Practical Guide

Tue, 09 Apr 2024 15:50:12 +0200

Profiling is an underrated skill among software-engineers and it’s often overlooked by even very skilled developers. Profiling a program, is essentially measuring CPU and memory usage to spot bottlenecks, memory leaks, and other performance issues. Knowing how profile a program and interpret the result can direct us to where exactly our program is suffering from poor performance, and focus our efforts on optimizing those specific parts. In this article, we’ll be profiling a real-world Go program. We’ll learn how to interpret the results, draw conclusions, and optimize the program accordingly.

Synchronization Patterns in Go

Sun, 01 Oct 2023 09:15:20 +0200

Info

This article is a followup for a more basic guide. If you would like to read the previous article, click here

The Go programming language is all about concurrency. Spawning multiple goroutines truly reveals the power of Go programs. As it lets us divide our program into concurrent processes. But you may have guessed, opening this door comes with a whole set of new issues we software engineers, have to consider. Most of them are related to shared memory and synchronization. From identifying the issue and applying the pattern, here are some things we can do in Go, to write better programs.

Asynchronous Go for Beginners

Tue, 26 Sep 2023 16:59:52 +0200

Info

If you would like to skip to a more advanced article, check out Synchronization Patterns in Go

When it comes to asynchronous programming, Go is one of the best languages in the market. The design of the language is so multi-thread oriented, that the go keyword in the language is used to start a new goroutine.

Best Network Technologies

Thu, 13 Jul 2023 17:06:58 +0200

Network communication in general is a very wide topic. It can probably fit in a large section of the New York Public Library (if not already). Fitting even a brief overview of this subject from bottom to top in a single article, might be a bit pretentious. So I won’t do it. Instead, I’ll be focusing mainly on software design patterns and technologies for communicating over a network.

Let’s unravel the mystery

We will start our journey with TCP/IP. Unless your program directly communicates using electromagnetic waves, there’s a good chance that your program will communicate with the world, using TCP/IP. I know you’ve heard this term before, but what is it?

How to Cache

Mon, 15 Aug 2022 15:50:12 +0200

Caching is one of those things that almost every digital service uses in some way or another, it can improve user experience, and reduce costs by preventing redundant computation. When incorrectly applied, it can be the root cause of many nasty issues such as serving stale data, creating security breaches, and eating up the memory. In this article, we will see what cache exactly is, what types of cache we can implement, and how to implement them correctly.

Privacy Policy

Mon, 01 Jan 0001 00:00:00 +0000

Last updated June 09, 2023

This privacy notice for Noam Yadgar (“Company,” “we,” “us,” or “our”), describes how and why we might collect, store, use, and/or share (“process”) your information when you use our services (“Services”).

Questions or concerns? Reading this privacy notice will help you understand your privacy rights and choices. If you do not agree with our policies and practices, please do not use our Services. If you still have any questions or concerns, please contact us at noam.g4@gmail.com.