DEV Community: Divyanshu Shekhar

MCP Servers Rarely Crash. That’s the Problem.

Divyanshu Shekhar — Wed, 07 Jan 2026 06:44:33 +0000

If you are building MCP servers, chances are your system does not fail the way you expect.

It starts up.

Tools registered successfully.

The LLM connects.

Responses come back.

And yet, something feels off.

Certain tools are barely used.

Arguments look almost correct.

The agent retries, rephrases, or quietly works around missing behaviour.

Nothing crashes. Nothing alerts. Nothing obviously breaks.

That is exactly the problem.

MCP failures are logical, not technical

In most backend systems, failure is explicit.

You get an exception.

A timeout.

A non-200 response.

An alert at 3 a.m.

MCP systems fail differently.

A tool is callable but unusable.

A schema is technically valid but semantically wrong.

A required precondition is never satisfied.

A downstream tool never receives the data it assumes exists.

The system still produces output.

Those are the failures that cause the most damage, because they look like success.

Tool contracts exist, but they are not enforced

MCP tools are defined by contracts: schemas, descriptions, and behavioural assumptions.

In practice, those contracts drift constantly.

Fields that are required in reality are marked optional.

Descriptions encode behaviour that schemas never enforce.

Breaking changes slip in without versioning.

Assumptions live in comments instead of checks.

Most teams only discover these issues when an LLM tries to use the tool.

That is not validation. That is delegation.

An LLM is a probabilistic consumer, not a contract checker.

Hidden dependency chains shape execution

Very few MCP servers are flat.

One tool prepares input for another.

Another assumes a previous tool has already run.

A third only works if both succeed.

None of this is explicit.

There is no dependency graph.

No execution guarantees.

No visibility into which tools are structurally required for others to function.

The result:

Order-sensitive behaviour
Partial execution paths that look valid
Agents hallucinating glue logic to compensate

Your MCP server already has a dependency graph.

You just cannot see it.

Prompt-based testing does not surface these failures

The usual response is "we'll catch it in testing".

In practice, that means:

Trying a few prompts
Watching the agent’s behaviour
Tweaking descriptions
Retrying when something looks off

This is not testing. It is sampling.

Prompt-based testing is non-deterministic.

LLMs smooth over structural problems instead of exposing them.

Retries and self-corrections hide the real failure modes.

If your test strategy is “try a few prompts and see what happens”, you are observing behaviour, not validating the system.

By the time a failure is visible, it has already passed through an LLM filter.

Why this is specific to MCP-style systems

This is not a criticism of MCP.

MCP exposes capabilities, not workflows.

Execution is mediated by an LLM, not a deterministic controller.

Control is probabilistic.

Failures are negotiated, not thrown.

MCP did not introduce these problems.

It removed the illusion that software is always in control.

Once you accept that, traditional debugging and testing approaches start to look insufficient.

What this means if you are building an MCP server today

A few practical conclusions fall out of this:

Treat tool schemas as real contracts, not documentation
Assume prompt-based testing will miss structural failures
Make tool dependencies explicit, even if only conceptually
Aim to surface failures before an LLM is involved, not after

If you only discover problems through agent behaviour, you are debugging too late.

Finding failures earlier

After running into these issues repeatedly, one pattern became clear:

By the time an LLM interacts with your MCP server, structural problems are already baked in.

Contracts should fail before execution.

Dependencies should be visible before prompts are written.

Unsafe changes should surface before deployment.

That line of thinking led us to experiment with analysing MCP servers statically, instead of discovering issues indirectly through LLM behaviour.

That work is documented here: https://docs.syrin.dev/

How to Sort in Go?

Divyanshu Shekhar — Wed, 05 Jul 2023 04:27:38 +0000

Sorting is a concept that you encounter wherever you go, especially in the world of computer science. It holds immense importance, and it’s crucial to have a good understanding of it. In this blog, we will embark on a journey to learn how to sort in Go. But wait, it’s not just about sorting Golang integers, floats, or strings; we’ll also explore sorting custom data types and even dive into complex data structures. By the time you finish reading this blog, we assure you that you’ll have a strong grasp of the concept.

Now, you might be wondering if we’re going to build sorting algorithms from scratch. Well, fear not! We will be leveraging the power of Go’s built-in sort package. So, without further ado, let’s take a deep dive into the vast pool of knowledge that awaits us.

Golang Sort Package

The sort package in Go is a powerful built-in package that provides a collection of methods and interfaces for sorting different types of data. It was developed to simplify the process of sorting elements in a Go program and to offer efficient sorting algorithms out of the box.

The sort package was included in Go starting from version 1.0, making it readily available for developers to use in their projects. To begin using the sort package, you need to import it into your Go program. Here’s how you can do that:

import "sort"

By including this import statement at the beginning of your Go code, you gain access to the various sorting functions and methods provided by the sort package.

The sort package is designed to handle sorting operations on slices, which are dynamic arrays in Go. By leveraging the functions and methods from this package, you can easily sort slices of integers, floats, strings, or even custom data types according to your specific requirements.

Go Sort Ints

Go sort’s Ints function is designed to sort a slice of integers in increasing order. It takes a slice of int values as input and modifies the slice in place to reflect the sorted order.

Let’s take a look at the syntax and an example to understand it better.

Syntax:

func Ints(x []int)

Example:

func main() {
    // Unsorted Array
    s := []int{5, 8, 3, 2, 7, 1}
    sort.Ints(s)
    fmt.Println(s)
}

Output:

[1 2 3 5 7 8]

In the example above, we have an unsorted slice of integers s. We call the sort.Ints function, passing the slice s as an argument. After the function call, the s slice is sorted in increasing order.

Check if Int Slice/Array is Sorted

If you want to check whether a slice of int values is already sorted in increasing order, you can use the IntsAreSorted function. Let’s explore its syntax and an example.

Syntax:

func IntsAreSorted(x []int) bool

Example:

func main() {
    // Sorted in Ascending order
    s := []int{1, 2, 3, 4, 5}
    fmt.Println(sort.IntsAreSorted(s))

    // Sorted in Descending order
    s = []int{5, 4, 3, 2, 1}
    fmt.Println(sort.IntsAreSorted(s))

    // Unsorted order
    s = []int{4, 2, 3, 1, 5}
    fmt.Println(sort.IntsAreSorted(s))
}

Output:

true
false
false

In the example above, we have three different scenarios. The first slice s is already sorted in ascending order, so the output is true. The second slice s is sorted in descending order, resulting in an output of false. The third slice s is completely unsorted, leading to another output of false.

Search in Ints Array/Slice

Now let’s explore how to search for an integer value in a sorted slice using the SearchInts function. This function returns the index at which the value is found or the index where it should be inserted to maintain the sorted order.

Syntax:

func SearchInts(a []int, x int) int

Example:

func main() {
    a := []int{1, 2, 3, 4, 5}

    x := 3
    i := sort.SearchInts(a, x)
    fmt.Printf("%d found at index %d in %v\n", x, i, a)

    x = 6
    i = sort.SearchInts(a, x)
    fmt.Printf("%d not found, can be inserted at index %d in %v\n", x, i, a)
}

Output:

3 found at index 2 in [1 2 3 4 5]
6 not found, can be inserted at index 5 in [1 2 3 4 5]

In this example, we have a sorted slice a containing integers. We use sort.SearchInts to search for the value x within the slice. If the value is found, the function returns the index of its occurrence. If the value is not found, the function returns the index where it should be inserted to maintain the sorted order.

In the first scenario, we search for x = 3 in the a slice and the function returns the index 2 since 3 is found at that position. In the second scenario, we search for x = 6, which is not present in the slice. The function returns 5, indicating that 6 can be inserted at the index 5 while preserving the sorted order of the slice.

Read the original blog from Here: How to Sort in Go?

Golang Generics

Divyanshu Shekhar — Sun, 25 Jun 2023 11:22:51 +0000

The wait is finally over as Go has introduced its much-anticipated feature, Golang Generics, with the release of version 1.18. We’re thrilled to dive into this fascinating addition to the language and explore how Go has implemented generics. Join us on this journey as we unravel the inner workings of Golang Generics and witness the impact it can have on your code. So without further ado, let’s embark on this adventure together!

Understanding The Problem

To properly understand the concept of Golang Generics, it is essential to understand the problem they aim to solve. Let’s explore this by considering a simple example.

Imagine we have a simple Add() function that takes two integers and returns their sum:

func Add(a, b int) int {
    return a + b
}

func main() {
    fmt.Println(Add(1, 2))    // Output: 3
}

This function works perfectly fine for integers, but what if we want it to accept float values as well? If we try to use a float value with our Add() function, we encounter an error:

func main() {
    fmt.Println(Add(1.1, 2))    // Error: cannot use 1.1 (untyped float constant) as int value in argument to Add
}

Now, you might suggest using interfaces to solve this problem, but there’s a catch. We only want the Add() function to accept integer and float values, not any other types. Unfortunately, achieving this level of specificity is not possible with interfaces alone.

This is where Golang generics come into play.

What’s New in Go 1.18?

In the highly anticipated release of Go version 1.18, which followed seven months after the previous version 1.17, the language introduced a game-changing feature: generics. Fulfilling its compatibility promise, Go 1.18 ensures backward compatibility with Go 1, ensuring a smooth transition for developers.

So, what exactly do these generics bring to the table? Let’s delve into the three major advancements that accompany this release:

Defining Interface Types as Sets of Types
Type Parameters for Functions and Types
Type Inference
Exciting, isn’t it? So, fasten your seatbelts and get ready to witness the power of generics in Go 1.18!

What is a Generic Type?

In programming, a generic type is a type that can be used with multiple other types, allowing for code reusability and flexibility.

It serves as a template, enabling you to write functions and data structures that work seamlessly with various data types without duplicating code.

Generics Overview

In order to grasp the concept of generics in Go more effectively, let’s take a moment to gain an overview of how other programming languages, such as C++ and Java, implement generics. By comparing and contrasting these implementations, we can better understand the unique approach that Golang brings to the table.

In C++, generics are achieved through templates, which allow generic functions and classes to be created. Templates enable the definition of algorithms and data structures that can work with multiple types without sacrificing type safety.

template <typename T>
void swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

Here, T represents the generic type parameter, and it allows us to write a single swap function that works for various data types.

Java, on the other hand, introduced generics with the release of Java 5. Generics in Java are implemented using type erasure, a technique where type information is removed at runtime, making generics a compile-time feature.

public class Box<T> {
    private T value;

    public void setValue(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

In this example, T is the type parameter that allows the Box class to work with different types of values.

Now, let’s shift our focus back to Go and explore its take on generics.

Prerequisites

To get started with this tutorial, you’ll need:

Go version 1.18 or greater installed: Make sure you have Go installed on your system, preferably version 1.18 or a newer release.
Solid understanding of Go basics: Ensure that you have a good understanding of Go’s fundamental concepts, including struct types, for loops, slices, and interfaces.
With these prerequisites fulfilled, we’re all set to dive into the fascinating world of Golang generics. Let’s begin our coding journey together!

Golang Generics Syntax

In the world of Go, generics have made their grand entrance starting from version 1.18, adding a whole new level of flexibility and power to the language. Now, let’s dive into the syntax of Golang generics, exploring how they can be used with functions and types.

Golang Generic Function Syntax
To define a generic function in Go, we utilize the following syntax:

func FunctionName[T Constraint](a, b T) T {
    // Function Body
}

In the above syntax, FunctionName represents the name of our generic function. The square brackets [T Constraint] indicate the use of a type parameter T, which can be any type constraint.

Inside the function parentheses (a, b T), we define the input parameters a and b of type T. The return type of the function is also T, denoted after the parentheses. You can replace T with any valid identifier that fits your needs.

Read full from original Post: Golang Generics. Find the blog on Google.

Python Lambda Function

Divyanshu Shekhar — Mon, 19 Jun 2023 15:42:04 +0000

In Python, developers use lambda functions as anonymous, inline functions that can be defined and called on the fly without needing a separate function. Programmers commonly use lambda functions to pass functions as arguments to higher-order functions or to define simple, one-time-use functions.

In this article, we’ll be exploring Python lambda functions in-depth and how they work. We’ll cover their syntax, use cases, advantages, and limitations. Furthermore, we’ll provide practical examples to help us understand how to use lambda functions effectively in Python.

Python Lambda Function Syntax

People know the Lambda function in Python as an anonymous function that can have any number of arguments but can only contain expressions in its body.

Let’s take a closer look at the syntax of a lambda function and explore each characteristic in detail:

lambda arguments: expression

Expressions Only

A lambda function can only contain expressions, which means it cannot include statements, such as print statements or assignments, in its body.

If we try to add a statement in a lambda function, it will raise a SyntaxError.

# Invalid syntax
lambda x, y: print(x + y)

# Valid syntax
lambda x, y: x + y

One Line, One Shot

We write a lambda function as a single line of execution, which means we cannot include multiple lines of code in it.

However, we can include multiple expressions by separating them with commas.

Example of invalid Python lambda function syntax:

# Invalid syntax
lambda x, y:
    x += 1
    y += 1
    return x + y

# Valid syntax
lambda x, y: (x + 1, y + 1)

Inference over Annotation

A lambda function does not support type annotations, which means we cannot specify the type of arguments or the return type of a lambda function.

However, Python can infer the type of arguments and the return type of a lambda function.

# Invalid syntax
lambda x: int: x + 1

# Valid syntax
lambda x: x + 1

Lambda on the Fly (IIFE)

We can immediately invoke or execute a lambda function, which means we can call it as soon as we define it.

This is also known as an Immediately Invoked Function Expression (IIFE) in Python.

# Invalid syntax
(lambda x, y: x + y)(10, 20)

# Valid syntax
result = (lambda x, y: x + y)(10, 20)
print(result)

Python Lambda Function Arguments

Python lambda functions can take any number of arguments, but they can only have a single expression. Developers often use lambda functions as a substitute for named functions when the function’s functionality is simple and a named function would be excessively complex.

The arguments to a lambda function are passed in the same way as they would be for a named function. They can be positional arguments, default arguments, variable-length arguments, or keyword arguments.

No Arguments, No Problem

A lambda function in Python can have any number of arguments, including zero arguments. Lambda function with no arguments performs a simple operation without needing any inputs.

# a lambda function that returns the string "Hello, World!"
hello = lambda: "Hello, World!"
print(hello())  # Output: Hello, World!

We use lambda functions with no arguments when we need to perform a simple operation that does not require any input from the user. We can use them in scenarios where we need to pass a function as an argument to another function, but the function itself does not require any arguments.

Positional Arguments

The lambda function takes positional arguments based on their position. This means that the first argument in the lambda function definition corresponds to the first argument passed to the function, the second argument in the lambda function definition corresponds to the second argument passed to the function, and so on.

# a lambda function that takes two positional arguments and returns their product
product = lambda x, y: x * y
print(product(2, 3))  # Output: 6

In the above example, we have defined a lambda function product that takes two positional arguments and returns their product. We have called this lambda function and passed two arguments 2 and 3.

Default Arguments

The lambda function specifies a default value for an argument using default arguments when the caller does not pass the argument. If the caller does not pass an argument to a lambda function that has a default value, the function uses the default value.

# a lambda function that takes one positional argument and one default argument
power = lambda x, y=2: x ** y
print(power(3))  # Output: 9
print(power(3, 3))  # Output: 27

In the above example, we have defined a lambda function power that takes one positional argument and one default argument. If we do not pass the second argument, the default value will be 2. We have called this lambda function with only one argument in the first case, and with both arguments in the second case.

Variable-Length Arguments

In a lambda function, we use variable-length arguments to accept an arbitrary number of arguments. We denote the variable-length argument by an asterisk (*) before the argument name. This enables the lambda function to accept any number of arguments that someone passes to it.

# a lambda function that takes a variable-length argument and returns the sum of all the numbers
sum_lambda = lambda *args: 0 if len(args) == 0 else args[0] + sum_lambda(*args[1:])
print(sum_lambda(1, 2, 3, 4))  # Output: 10

In the above example, we have defined a lambda function sum that takes a variable-length argument and returns the sum of all the numbers passed to it.

Continue Reading: Python Lambda Function. Find Blog on Google.

Python Classmethod

Divyanshu Shekhar — Mon, 19 Jun 2023 15:31:15 +0000

Python’s classmethod is a special type of method that is bound to the class rather than an instance of the class. This means that you can call a classmethod on the class itself, rather than on an instance of the class. In this guide, we will explore the ins and outs of Python classmethod, including its syntax, uses, and benefits.

Understanding Python Methods

Before we dive into the world of Python classmethods, it’s essential to have a solid understanding of Python methods in general.

In Python, a method is a function that belongs to an object or a class. It allows us to perform specific actions or computations on the object it’s associated with.

Basics of Python Methods

In Python, methods are defined within the body of a class. They have access to the data and attributes of the class and can manipulate them as necessary.

When an object invokes a method, it passes itself as the first parameter to the method, conventionally named self. This parameter allows the method to access and manipulate the object’s state.

class MyClass:
    def my_method(self, arg1, arg2):
        # Access instance-specific data using self
        # Perform operations using arg1 and arg2
        return result

Invoking Methods in Python

To invoke a method, we need an instance of the class. We create an instance by calling the class as if it were a function.

Once we have the instance, we can call its methods using the dot notation.

my_object = MyClass()  # Create an instance of MyClass
result = my_object.my_method(arg1_value, arg2_value)  # Invoke the method on the instance

The self Parameter in Python

The self parameter is a convention in Python, and you can use any valid variable name in its place. However, it’s best to stick with the convention to maintain consistency and make your code more readable and understandable to other developers.

The self parameter allows methods to access and modify the attributes of the instance. By using self.attribute_name, you can access the instance’s attributes within the method. Similarly, by using self.attribute_name = value, you can modify the instance’s attributes.

class MyClass:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print(f"Hello, {self.name}!")

my_object = MyClass("Alice")
my_object.greet()  # Output: Hello, Alice!

What is a classmethod in Python?

A classmethod, as the name suggests, is a special type of method that belongs to a class rather than an instance of the class. Unlike regular methods, classmethods can be called on the class itself without the need to create an instance of the class.

They provide a way to access and manipulate class-specific data, perform operations that are independent of any particular instance, and enable alternative constructors for class instantiation.

A classmethod is defined using the @classmethod decorator. The decorator is placed above the method definition and indicates that the method is a classmethod.

Different Ways of Creating Python classmethod

Python provides multiple ways to create classmethods, each with its own advantages and use cases. Let’s explore the various techniques for defining classmethods and understand when and why you might choose one over the other.

1. Using the @classmethod Decorator

The most common and straightforward way to create a classmethod is by using the @classmethod decorator.

As mentioned earlier, this decorator is placed before the method definition to indicate that it should be treated as a classmethod.

Example:

class MyClass:
    @classmethod
    def my_class_method(cls, arg1, arg2):
        # Access class-specific data using cls
        # Perform operations using arg1 and arg2
        return result

In this approach, the cls parameter is automatically passed to the method, representing the class itself.

It allows you to access class-specific attributes and perform operations that are relevant to the class as a whole.

Continue Reading: Python Classmethod. Find Blog on Google.

Python Enumerate: Making Iterations Easier than Ever

Divyanshu Shekhar — Mon, 19 Jun 2023 15:01:00 +0000

Are you tired of writing complex loops in Python just to access both the index and value of each element? Say goodbye to manual indexing and welcome Python Enumerate! In this blog, we’ll show you how Enumerate simplifies iterations, improves code readability, and pairs each element with its index. Let’s dive in and unleash the power of Python Enumerate together. Oh, and don’t miss the fun fact about Python Enumerate at the end!

Understanding The Problem

Have you ever found yourself in a situation where you needed to iterate over a list in Python and access both the index and value of each element? If you’ve been coding in Python for a while, you might be familiar with the traditional approach of using a for loop and manually managing the indices. However, this method can quickly become tedious and prone to errors, especially when dealing with larger datasets.

Let’s consider a simple example to understand the problem. Suppose we have a list, and we want to iterate over this list and print both the index and the value, we might write something like this:

fruits = ["apple", "banana", "cherry"]
for i in range(len(fruits)):
    print("Index:", i, "Fruit:", fruits[i])

Or something like this:

fruits = ["apple", "banana", "cherry"]
i = 0
for fruit in fruits:
    print("Index:", i, "Fruit:", fruit)
    i += 1

Output:

Index: 0 Fruit: apple
Index: 1 Fruit: banana
Index: 2 Fruit: cherry

Well both approaches do the job, but it involves an extra step of either using the range function or manually maintain indices using a counter variable. This can make the code less readable and prone to off-by-one errors if we’re not careful with our index calculations.

Fortunately, Python provides us with a better solution: enumerate.

What is Enumerate in Python?

In Python, enumerate is a built-in function that simplifies the process of iterating over iterable objects, such as lists, or tuples, by providing an automatic index assigned to each item.

With enumerate, you no longer need to rely on traditional methods like using a counter variable or accessing elements by their indices. Instead, enumerate pairs each element of the iterable with its corresponding index, making it easier to access both the value and its position in the sequence.

Python Enumerate Syntax

Now that we understand what enumerate is, let’s dive into its syntax and see how we can use it in our code.

Syntax of Python enumerate:

enumerate(iterable, start=0)
Let’s understand the enumerate parameters:

iterable: The iterable parameter represents the object that we want to iterate over. It can be any iterable, such as a list, tuple, or string.
start (optional): The start parameter allows us to customize the starting index of the enumeration. By default, it is set to 0, which means the first element in the iterable will have an index of 0. However, we can specify a different value for start if needed. For instance, if we want the enumeration to start from 1, we can set start=1. To better understand the syntax, let’s explore an example:

orgs = ['google', 'twitter', 'facebook']

for index, org in enumerate(orgs, start=1):
    print(f"At position {index}, we have a {org}")

Output:

At position 1, we have a google
At position 2, we have a twitter
At position 3, we have a facebook

In this example, we have a list called orgs containing different types of organizations. By using enumerate, we iterate over the orgs list. The index variable represents the index or position of each organization in the list, while the org variable holds the value of the corresponding organization.

Read the full tutorial on original post: Python Enumerate. Find Blog on Google. Python Enumerate.

Blind 75 LeetCode: Crack DSA Interview

Divyanshu Shekhar — Mon, 19 Jun 2023 07:29:22 +0000

Are you here in search of the much-talked-about Blind 75 LeetCode Questions that can potentially help you crack your interview rounds? Well, you’ve come to the right place! Originally, Blind 75 was created as a collection of LeetCode Questions, but we believe that cracking interviews requires more than just DSA skills. To truly excel, you need to become an all-rounder.

Being an all-rounder means having a strong grasp of problem-solving techniques, DSA concepts, at least intermediate knowledge of a programming language, and, most importantly, the ability to work on projects.

By following this blog, we aim to equip you with the skills needed to tackle any interview scenario with confidence. So, are you ready to embark on this exciting journey of growth and learning? Let’s get started but first, get our basics clear!

What is Blind 75?

Blind 75 is an effective practice technique designed to help you prepare for interview rounds by solving 75 LeetCode questions, ranging from easy to hard difficulty levels, within an 8-week timeframe. It provides a structured roadmap for your interview preparation journey. By following this approach, you can enhance your problem-solving skills and boost your chances of cracking those important interviews.

The idea behind Blind 75 is simple yet powerful. It involves dedicating a focused amount of time each day to solve LeetCode questions. The curated set of 75 questions ensures that you cover a wide range of problem types and difficulty levels, allowing you to strengthen your understanding of various concepts in data structures and algorithms.

Why Blind 75?

Here are some compelling reasons why Blind 75 is the go-to technique for cracking DSA interviews with ease:

Proper Roadmap: Blind 75 provides a well-defined roadmap for your interview preparation. With a set goal of solving 75 LeetCode questions, you have a clear direction and a tangible target to work towards. This structured approach keeps you focused and motivated throughout your journey.
Effective use of Time: Time management is crucial during interview preparation. Blind 75 instills a sense of discipline by setting time constraints for solving each question. This practice helps you develop the ability to allocate time efficiently, improving your speed and accuracy in problem-solving.
The Habit of Problem-Solving: Blind 75 cultivates a habit of consistent problem-solving. By regularly practicing LeetCode questions, you develop a rhythm of approaching challenges, analyzing problem statements, and designing effective algorithms. This habit strengthens your problem-solving skills and enhances your ability to tackle a wide range of coding scenarios.
Important DSA Concepts: DSA (Data Structures and Algorithms) form the foundation of technical interviews. Blind 75 ensures that you encounter a diverse set of LeetCode questions, covering various DSA concepts such as arrays, linked lists, trees, graphs, dynamic programming, and more. Through this comprehensive exposure, you solidify your understanding of key concepts, enabling you to confidently apply them in interviews.
Interviewers love LeetCode Questions: LeetCode has gained immense popularity among interviewers as a reliable benchmark for assessing candidates’ technical abilities. By practicing Blind 75, you align your preparation with industry standards and interview expectations. ## Modified Blind 75 Let me ask you a question: Is simply solving LeetCode questions enough to crack interview rounds? Well, we may have different opinions on this, but what we believe is that to truly excel, we need to be well-rounded. While practicing LeetCode questions is essential, we should also focus on applying our DSA knowledge by building real-world projects.

In this blog, we present a modified version of Blind 75. Don’t worry, the original Blind 75 LeetCode questions remain the same. However, we have added some extra resources for each week that will help you gain intermediate-level programming knowledge and provide project resources. This way, you’ll embark on an 8-week journey to truly grind and prepare for your interview rounds. Let’s dive into Week 1 and explore what it has to offer.

Read full on the original blog: Blind 75 LeetCode. Find Blog on Google Blind 75.

Golang Interface: The Art of Polymorphism in Go Programming

Divyanshu Shekhar — Sun, 18 Jun 2023 16:19:46 +0000

Have you ever wondered how Golang manages to incorporate the concept of polymorphism, similar to object-oriented programming? The secret lies in the Golang interface! In this blog, we’re going to embark on an exciting journey exploring the world of the Golang interface. From understanding their declaration and implementation to unraveling the mysteries of empty interfaces, embedding, and type assertions, we have a wealth of knowledge waiting to be discovered. So, fasten your seatbelts and get ready to dive into this knowledge-packed blog. And hey, don’t forget to stick around for a fascinating fun fact about the Golang interface at the end!

What is Golang Interface?

In Go, an interface is a special type that defines a set of method signatures. It serves as a blueprint for the expected behavior of a type. By using interfaces, we can write code that operates on different types without worrying about their specific implementations. It promotes flexibility and modularity in our code.

For example, in a Zoo program, we can define an Animal interface with standard methods like MakeSound() and Move(), allowing us to work with different types of animals seamlessly.

Defining Interface in Golang

So, we’ve just explored the definition of a Golang interface. Are you feeling a bit confused? Well, I must admit that I also find it a bit perplexing when reading the definition alone. The good news is that the best way to truly grasp any concept is to dive into how it works in practice. Once we understand its workings, we’ll be able to connect the dots and make sense of that definition. So, let’s waste no time and take a closer look at the syntax of a Golang interface.

In Go, defining an interface is quite easy I would say. We use the type keyword followed by the name we want to assign to our interface. For instance, if we want to create an interface called “Messenger”, we would write:

type Messenger interface {
    // Method declarations go here
}

// OR

type Messenger = interface {
    // Method declarations go here
}

To define the methods that our interface should have, we simply list them within the curly braces. Each method is declared without any implementation details, only specifying the method signature. The method signature consists of the method name, any input parameters it requires (if applicable), and the return type(s) (if applicable).

Interface with the method signature:

type Messenger interface {
    Send(message string) error
    Receive() (string, error)
}

// OR

type Messenger = interface {
    Send(message string) error
    Receive() (string, error)
}

In this example, the Messenger interface specifies two methods:

Send, which takes a message of type string and returns an error, and
Receive, which returns a string and an error.
Any type that implements these two methods will automatically satisfy the Messenger interface.

Next, let’s explore how we can implement these interfaces and witness their functionality firsthand.

Read the full blog on: Golang Interface. Find the blog on Google. Golang Interface.

Operating System Process Scheduling

Divyanshu Shekhar — Sun, 18 Jun 2023 16:14:29 +0000

Do You know, what is that magical behind-the-scenes mechanism that allows your computer to juggle multiple tasks effortlessly? If your answer is no, then Buckle up as we will be going on an adventurous journey to understand the inner workings of process scheduling in operating system, its importance, and how it ensures smooth multitasking. So, let’s get started!

What is Process Scheduling?

Process scheduling is the fundamental mechanism employed by operating systems to manage and allocate system resources to multiple processes or tasks running concurrently.

It determines the order in which processes are executed, ensuring that every task gets its fair share of the CPU’s attention.

You can imagine a chef juggling various dishes simultaneously; that’s what process scheduling does for your computer!

If you are not aware of what a process is in operating system, first learn about process in operating system and then move forward.

Why Process Scheduling is needed?

The Need for Process Scheduling You might be wondering, why bother with process scheduling? Well, imagine a world without it – your computer would freeze up, leaving you stuck with one task at a time.

Process scheduling optimizes resource utilization, improves system efficiency, and enhances user experience. It’s the superhero of multitasking!

Operating System Process Scheduling Algorithms
Now, we’ll explore various operating system process scheduling algorithms that dictate how the CPU selects and assigns tasks.

From the straightforward FCFS to the dynamic Multilevel Queue Scheduling, each algorithm has its quirks and charm.

First-Come, First-Serve (FCFS) Scheduling

Imagine you’re waiting in line at a bustling coffee shop, eagerly anticipating your turn to place an order. Just like in real life, First-Come, First-Serve (FCFS) Scheduling works on the principle of serving tasks based on their arrival time.

How FCFS Scheduling Works?

FCFS scheduling is one of the simplest scheduling algorithms. It operates on the basis of a queue, where processes are placed in the order they arrive.

The CPU executes the processes in the same order, following a “first in, first out” approach. Once a process starts executing, it continues until it completes or is interrupted.

The FCFS algorithm can be explained using a real-life analogy. Imagine you’re a teacher grading assignments. You stack the assignments in the order you received them, and you grade them one by one, starting from the top of the stack. The first assignment you received is the first one you grade, and so on.

Similarly, FCFS scheduling processes tasks in the order they arrive, without considering their execution time or priority.

Read the full blog on: Process Scheduling. Find the blog on Google: Process Scheduling Operating System.

Python str vs repr

Divyanshu Shekhar — Sun, 18 Jun 2023 16:08:11 +0000

Have you ever thought about how you can make your custom Python objects more readable and easy to understand? Well, that’s where the Python str and repr methods come into the picture. It’s like a magical method that gives us the ability to decide how our objects should appear when we convert them into strings. In this blog, we’ll dive into the fascinating world of the str and repr methods and explore how they can elevate your programming skills.

What is Python str function?

The str method in Python is a special function that lets us define how objects should be represented as strings. It provides a way for objects to introduce themselves in a human-readable format. When we print an object or use the str() function, Python looks for the str method and calls it to get the string representation.

If the str method is not explicitly defined for a class, the default implementation provided by the interpreter will be used. This default implementation returns a string containing the class name of the object and its memory address.

Syntax of str in Python

When it comes to understanding the syntax of the str method in Python, we’ll break it down into simple steps. By following these steps, you’ll be able to implement the str method effortlessly in your classes.

Class Definition: To begin, we need to define our class. We use the class keyword followed by the name of our class. Inside the class, we define the str method, which will determine how our object is represented as a string. Method Definition: Within the class, we start defining the str method. It’s important to note that the method name begins and ends with two underscores (underscores are like little huggers for the name).
Return the String Representation: Inside the str method, we need to specify what the method should return. This return value will be the string representation of our object. You can include any information you desire within this string representation, such as attribute values or custom messages.
Complete the Syntax: Lastly, we need to make sure that we close our method definition and class definition properly. This is done by adding appropriate indentation and ensuring that everything lines up correctly. Here’s an example to illustrate the syntax of str in action:

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def __str__(self):
        return f"Meet {self.name}, the adorable {self.breed}."

my_dog = Dog("Max", "Labrador Retriever")
print(my_dog) # Meet Max, the adorable Labrador Retriever.

In this example, we define a class called Dog with attributes name and breed. The str method is implemented to provide a string representation of a Dog object. When we print my_dog, the str method is automatically called, and it returns a string with the dog’s name and breed.

If the str method is not defined in the class and we attempt to print the object, the output would display the memory location of the class instead.

<__main__.Dog object at 0x7f5887f2d210>

What is repr function in Python?

In Python, alongside the well-known str method, we have another special function called repr. While str focuses on providing a human-readable string representation of an object, repr takes a slightly different approach. It aims to provide an unambiguous and developer-oriented representation of the object.

By implementing the repr method in our Python classes, we can define how the object should be represented when the repr() function is called or when the object itself is printed. This allows us to have fine-grained control over the output and enables other developers to understand the object’s structure and properties more effectively.

Read the full blog on: Python str. Find the blog on Google: Python str repr.

Redis Commands

Divyanshu Shekhar — Sun, 18 Jun 2023 12:32:17 +0000

Hey there, Redis enthusiasts! Get ready to embark on an exhilarating journey into the world of Redis commands. In this blog, we’ll dive deep into Redis, a blazing-fast in-memory data structure store, and explore its powerful commands that allow you to manipulate data with ease.

Whether you’re a seasoned Redis user or a curious learner, this blog will equip you with the knowledge you need to harness Redis’s full potential. So, grab your favorite caffeinated beverage and let’s get started!

Before you get started don’t forget to install redis on your machine.

A Quick Overview of Redis

Redis is an open-source, NoSQL, key-value store that has gained immense popularity for its exceptional speed, versatility, and simplicity. It serves as an advanced data structure server, offering a plethora of data manipulation capabilities that go beyond traditional key-value stores.

Redis uses an in-memory data storage approach, making it lightning-fast for read and write operations. It also supports persistence, allowing you to save your data to disk and recover it later, ensuring both speed and durability.

Now that we’ve covered the basics, let’s delve into the exciting world of Redis commands!

Redis revolves around keys, and this category focuses on key manipulation commands. Some key commands include:

Redis SET and GET Commands

The SET command is used to set a key-value pair in Redis.

The syntax is as follows:

SET key value [EX seconds] [PX milliseconds] [NX|XX]

Example:

SET greeting "Hello, Redis!"

The GET command is used to retrieve the value of a key.

Syntax:

GET key

Here’s an example of how to use the Redis GET command to retrieve the value we set earlier:

GET greeting

Redis EXPIRE Command

The EXPIRE command is used to set a timeout on a key. The syntax is as follows:

EXPIRE key seconds

Here’s an example of how to use the EXPIRE command to set a timeout of 10 seconds on the “greeting” key we set earlier:

EXPIRE greeting 10

Redis INCR and DECR Commands

The INCR command is used to increment the value of a key by one. If the key doesn’t exist, it’s set to 0 before performing the operation. The syntax is as follows:

INCR key

Here’s an example of how to use the INCR command to increment the value of a key:

SET counter 0
INCR counter

The DECR command is used to decrement the value of a key by one. If the key doesn’t exist, it’s set to 0 before performing the operation. The syntax is as follows:

DECR key

Here’s an example of how to use the DECR command to decrement the value of a key:

SET counter 10
DECR counter

Read full from the original blog: Redis Commands. Find the blog on Google: Redis Commands.

Function Pointer in C

Divyanshu Shekhar — Sun, 18 Jun 2023 12:26:51 +0000

If you’ve ever wanted to tap into the power and flexibility of function pointers, you’re in the right place. In this blog, we’ll take you on a journey through the ins and outs of a function pointer in C, helping you understand its syntax and practical applications. So, let’s get started and unravel the C language’s fascinating world of function pointers!

Function pointers may seem intimidating at first, but fear not! We’re here to break them down into digestible bits and make them easily understandable. By the end of this guide, you’ll have a solid grasp of how to use function pointers effectively in your C programs.

What is a Function Pointer?
Function pointer in C is a fascinating concept that allows you to store the memory address of functions within variables. Just like you can store numbers or text in variables, function pointers let you store the “location” of a function in your program’s memory. This opens up a world of possibilities by enabling you to create function calls to functions pointed by these variables.

Think of function pointers as signposts that point to the exact location of a function in the vast landscape of your program’s memory. They provide a convenient way to refer to functions without explicitly specifying their names. Instead, you can use the function pointer variable to invoke the function it points to.

By utilizing function pointers, you can create more flexible and dynamic code. Rather than being restricted to calling a specific function, you can determine which function to call at runtime based on various conditions or user input. This ability to dynamically select and call functions is a powerful tool in the hands of a programmer.

To gain a clearer understanding of function pointers, it’s recommended to grasp the basics of how function calls are stacked in the memory layout of a C program.

Declaring a Function Pointer in C
To harness the power of function pointers in C, it’s important to understand their syntax and how they are declared. The syntax may seem a little unfamiliar at first, but fear not! We’ll break it down for you in simple terms.

To declare a function pointer, you need to specify the return type of the function and the types of its parameters. Let’s say we have a function called addNumbers that takes two integers as parameters and returns an integer. Here’s how you can declare a function pointer for it:

Syntax:

return_type (* pointer_name) (arg_1_datatype, arg_2_datatype, ...);

Example:

int (*ptr)(int, int);

Let’s dissect this declaration step by step.

The asterisk (*) indicates that ptr is a pointer variable. In other words, it will store the memory address where the function is located.
(int, int) represents the parameter types of the function that the pointer points to. In this case, int is used for both parameters. Finally, int before the opening parenthesis specifies the return type of the function. In our example, the return type is int. ## Using typedef To enhance readability and reduce complexity, we can utilize the typedef keyword to create a type alias for the function pointer. This way, we can refer to the function pointer type using a more intuitive name. Let’s see how it’s done:

typedef int (*ArithmeticFunction)(int, int);

In this example, we’ve created a type alias ArithmeticFunction for our function pointer. Now we can declare variables of this type without going through the complex syntax each time.

ArithmeticFunction ptr;

By using the typedef approach, the code becomes more expressive and easier to understand. It provides a clear indication that ptr is a function pointer of type ArithmeticFunction.

Remember, when declaring function pointers, it’s crucial to match the return type and parameter types with the corresponding function. Mismatching types can lead to unexpected behavior and errors.

Read full from the original post: C Function Pointer. Find the blog on Google: Function Pointer in C.

DEV Community: Divyanshu Shekhar

MCP Servers Rarely Crash. That’s the Problem.

MCP failures are logical, not technical

Tool contracts exist, but they are not enforced

Hidden dependency chains shape execution

Prompt-based testing does not surface these failures

Why this is specific to MCP-style systems

What this means if you are building an MCP server today

Finding failures earlier

How to Sort in Go?

Golang Sort Package

Go Sort Ints

Check if Int Slice/Array is Sorted

Search in Ints Array/Slice

Golang Generics

Understanding The Problem

What’s New in Go 1.18?

What is a Generic Type?

Generics Overview

Prerequisites

Golang Generics Syntax

Python Lambda Function

Python Lambda Function Syntax

Expressions Only

One Line, One Shot

Inference over Annotation

Lambda on the Fly (IIFE)

Python Lambda Function Arguments

No Arguments, No Problem

Positional Arguments

Default Arguments

Variable-Length Arguments

Python Classmethod

Understanding Python Methods

Basics of Python Methods

Invoking Methods in Python

The self Parameter in Python

What is a classmethod in Python?

Different Ways of Creating Python classmethod

1. Using the @classmethod Decorator

Python Enumerate: Making Iterations Easier than Ever

Understanding The Problem

What is Enumerate in Python?

Python Enumerate Syntax

Blind 75 LeetCode: Crack DSA Interview

What is Blind 75?

Why Blind 75?

Golang Interface: The Art of Polymorphism in Go Programming

What is Golang Interface?

Defining Interface in Golang

Operating System Process Scheduling

What is Process Scheduling?

Why Process Scheduling is needed?

First-Come, First-Serve (FCFS) Scheduling

How FCFS Scheduling Works?

Python __str__ vs __repr__

What is Python str function?

Syntax of str in Python

What is repr function in Python?

Redis Commands

A Quick Overview of Redis

Redis SET and GET Commands

Redis EXPIRE Command

Redis INCR and DECR Commands

DECR key

Function Pointer in C

Python str vs repr