Forem: Common Khadka

Software Architecture for a CHILD

Common Khadka — Tue, 08 Apr 2025 17:37:33 +0000

🏠 What is Software Architecture?

Imagine you're building a house or a LEGO city. You need a plan — where the rooms go, how people move around, where the wires and pipes are. That’s what software architecture is — the big plan for how a software project is built and how all the parts fit together.

Now let’s look at the types of software architecture using easy examples:

1. Monolithic Architecture 🧱

Imagine a giant LEGO castle all built as one big piece.

All rooms are in one big structure.
If you want to change the kitchen, you might break the whole castle.

🟢 Easy to build at first.

🔴 Hard to change when it gets big.

🧠 Example: A single app that does everything — login, shop, pay — all in one codebase.

All in one folder — like a big box of LEGOs.

/MyApp
├── /controllers
├── /models
├── /views
├── /services
├── /utils
├── app.js
├── config.js
└── README.md

Everything is tightly packed together. Easy at first, but hard to move pieces around later.

2. Microservices Architecture 🏘️

Imagine a neighborhood where each house does one thing.

One house for cooking.
One house for games.
One house for sleeping.

Each house talks to the others, but they can be fixed or upgraded separately.

🟢 Easy to manage and scale.

🔴 Harder to set up at first.

🧠 Example: Amazon has one service just for payments, one for searching,
one for orders.

Many small folders, each like its own tiny app.

/MyApp
├── /auth-service
│   ├── /src
│   ├── app.js
│   └── Dockerfile
├── /product-service
│   ├── /src
│   ├── app.js
│   └── Dockerfile
├── /order-service
│   ├── /src
│   ├── app.js
│   └── Dockerfile
├── /api-gateway
│   ├── /src
│   └── gateway.js
└── docker-compose.yml

Each service is independent and talks to others through APIs.

3. Clean Architecture 🧼 (or Hexagonal)

Imagine a house where the living room doesn’t know where the pipes are.

The inside (like the people) don't care about the outside stuff (like the street or electricity).
You can cleanly replace the TV or the power supply without messing up the couch.

🟢 Keeps core logic safe from changes.

🔴 Takes more planning.

🧠 Example: Your game logic doesn’t care whether the player uses keyboard or touch screen.

Separates the “what” from the “how” — like keeping your school books in subjects.

/MyApp
├── /src
│   ├── /core
│   │   ├── /entities
│   │   ├── /use-cases
│   ├── /infrastructure
│   │   ├── /database
│   │   ├── /external-apis
│   ├── /interface
│   │   ├── /controllers
│   │   └── /routes
├── app.js
└── README.md

Core logic stays clean and isolated — like the rules of your game that don’t depend on who’s playing.

4. Onion Architecture 🧅

Imagine layers of an onion — each layer protects the one inside.

The center is your core logic.
Around that is stuff like business rules, then APIs, then UI.

Only outer layers talk to inner layers — not the other way around.

🟢 Makes the important code safe from changes outside.

🔴 Can be hard to understand at first.

🧠 Example: You can change the way data is saved (database) without touching your game rules.

Layers that protect the core, like a security system around your treasure.

/MyApp
├── /Domain
│   └── /Entities
├── /Application
│   └── /UseCases
├── /Infrastructure
│   ├── /Data
│   └── /External
├── /Presentation
│   └── /Controllers
├── app.js
└── README.md

Outer layers (like controllers) depend on the inner logic, but never the other way around.

5. Layered Architecture 🍰

Like a cake with layers — base, cream, topping.

Each layer does one job:
- Data layer (bottom): like the fridge with all the food.
- Logic layer (middle): the cook that makes the food.
- UI layer (top): the waiter that serves it.

🟢 Easy to organize and understand.

🔴 Sometimes layers talk too much and get messy.

🧠 Example: Your app’s UI doesn’t need to know how the database works — it just asks for stuff.

Stacked like a birthday cake 🎂 — base, middle, and top layers.

/MyApp
├── /PresentationLayer
│   └── /UI
├── /BusinessLogicLayer
│   └── /Services
├── /DataAccessLayer
│   └── /Repositories
├── /Common
│   └── /Helpers
├── app.js
└── README.md

Each layer only talks to the one right below or above it. Like a kitchen: waiter → chef → fridge.

💡 In short:

Type	Like a...	Good for
Monolithic	One big LEGO block	Small apps
Microservices	Tiny houses in a city	Large, fast-growing apps
Clean	Tidy and independent rooms	Testable, flexible code
Onion	Onion with strong core	Safe core logic
Layered	Layer cake	Simple and organized apps

PLINQ Extension Methods in C#

Common Khadka — Tue, 11 Feb 2025 17:37:48 +0000

Parallel LINQ (PLINQ) is an extension of LINQ that enables parallel processing of queries to improve performance by utilizing multiple cores of a processor. Below is a list of PLINQ extension methods along with code snippets demonstrating their usage.

1. AsParallel

Converts an IEnumerable to a parallel query, enabling parallel execution.

var numbers = Enumerable.Range(1, 10);
var parallelQuery = numbers.AsParallel().Where(n => n % 2 == 0);
foreach (var num in parallelQuery)
{
    Console.WriteLine(num);
}

2. WithDegreeOfParallelism

Limits the number of processor cores used for the query execution.

var numbers = Enumerable.Range(1, 20);
var parallelQuery = numbers.AsParallel()
                           .WithDegreeOfParallelism(2) // Limits to 2 cores
                           .Where(n => n % 2 == 0);
foreach (var num in parallelQuery)
{
    Console.WriteLine(num);
}

3. ParallelEnumerable.Range

Generates a range of numbers in parallel.

var parallelRange = ParallelEnumerable.Range(1, 10);
parallelRange.ForAll(Console.WriteLine);

4. ParallelEnumerable.Repeat

Generates a sequence where a specified value is repeated multiple times in parallel.

var repeatedValues = ParallelEnumerable.Repeat("Hello", 5);
repeatedValues.ForAll(Console.WriteLine);

5. ParallelEnumerable.Empty

Returns an empty parallel sequence.

var emptySequence = ParallelEnumerable.Empty<int>();
Console.WriteLine("Count: " + emptySequence.Count());

6. AsSequential

Forces a PLINQ query to process sequentially instead of in parallel.

var numbers = Enumerable.Range(1, 10).AsParallel();
var sequentialQuery = numbers.AsSequential().Where(n => n % 2 == 0);
foreach (var num in sequentialQuery)
{
    Console.WriteLine(num);
}

7. AsOrdered

Preserves the ordering of the original sequence in a PLINQ query.

var numbers = Enumerable.Range(1, 10).AsParallel().AsOrdered();
foreach (var num in numbers)
{
    Console.WriteLine(num);
}

8. AsUnordered

Removes ordering constraints for better parallel performance.

var numbers = Enumerable.Range(1, 10).AsParallel().AsUnordered();
numbers.ForAll(Console.WriteLine);

9. WithCancellation

Enables cancellation of a PLINQ query using a CancellationToken.

var cts = new CancellationTokenSource();
var numbers = Enumerable.Range(1, 100).AsParallel().WithCancellation(cts.Token);
Task.Run(() => cts.Cancel());
try
{
    foreach (var num in numbers)
    {
        Console.WriteLine(num);
    }
}
catch (OperationCanceledException)
{
    Console.WriteLine("Query was canceled.");
}

10. WithMergeOptions

Specifies how results should be merged after parallel execution.

var numbers = Enumerable.Range(1, 10).AsParallel()
                        .WithMergeOptions(ParallelMergeOptions.NotBuffered);
numbers.ForAll(Console.WriteLine);

11. WithExecutionMode

Forces a query to run in parallel or sequential mode.

var numbers = Enumerable.Range(1, 10).AsParallel()
                        .WithExecutionMode(ParallelExecutionMode.ForceParallelism);
numbers.ForAll(Console.WriteLine);

12. ForAll

Executes a parallel query and applies an action to each element.

var numbers = Enumerable.Range(1, 10).AsParallel();
numbers.ForAll(Console.WriteLine);

Conclusion

PLINQ provides powerful methods to enable efficient parallel processing in C#. Understanding these methods can help improve performance in applications that handle large data processing tasks.

References

Microsoft Docs: PLINQ Overview

Understanding LINQ Extension Methods in C#

Common Khadka — Mon, 10 Feb 2025 15:59:21 +0000

In C#, Language Integrated Query (LINQ) is a powerful feature that allows developers to query and manipulate data in a more concise and readable manner. One of the key concepts in LINQ is the use of extension methods. These methods are used to extend the functionality of existing types, enabling you to query data sources in a fluent, declarative style. In this blog post, we’ll dive into what LINQ extension methods are, why they’re important, and how to use them effectively.

What are LINQ Extension Methods?

LINQ extension methods are methods that are added to types like IEnumerable<T> and IQueryable<T> to enable LINQ-style querying. These methods are defined in the System.Linq namespace and are part of the Enumerable and Queryable classes. They allow developers to perform operations such as filtering, grouping, sorting, and projecting data directly from collections like arrays, lists, or databases.

Although these methods are not explicitly part of the IEnumerable<T> or IQueryable<T> interfaces, they are made available through C#’s extension method feature. By using extension methods, you can call LINQ methods like Where(), Select(), OrderBy(), and GroupBy() directly on collections that implement IEnumerable<T>.

Importance of LINQ Extension Methods

LINQ extension methods significantly improve the readability, maintainability, and efficiency of your code. Here are a few reasons why they are important:

Declarative Syntax: LINQ provides a declarative syntax for querying collections. Instead of writing complex loops, you can describe the logic of your query in a way that closely resembles the structure of SQL.
Increased Productivity: LINQ simplifies the code you need to write, reducing the chances of errors. With LINQ extension methods, you can perform operations like filtering, ordering, and projecting data in just one line of code.
Cleaner and More Readable Code: Using LINQ extension methods makes your code concise and easier to understand. Rather than dealing with low-level iteration or complex conditional logic, you can focus on the core business logic.
Extensibility: Since LINQ methods are based on extension methods, you can extend the functionality of any type that implements IEnumerable<T> or IQueryable<T>, making your code flexible and extensible.

How to Use LINQ Extension Methods

To use LINQ extension methods, you must first import the System.Linq namespace. After that, you can apply various methods to collections. Let’s look at some common examples:

1. Filtering Data: `Where()`

The Where() method filters a sequence based on a predicate (a boolean expression). Here’s an example:

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        var numbers = new[] { 1, 2, 3, 4, 5, 6 };

        var evenNumbers = numbers.Where(n => n % 2 == 0);

        foreach (var num in evenNumbers)
        {
            Console.WriteLine(num);
        }
    }
}

Output:

2
4
6

In this example, Where() is used to filter out the even numbers from the array.

2. Projecting Data: `Select()`

The Select() method projects each element of a collection into a new form. Here’s an example that transforms each number into its square:

var numbers = new[] { 1, 2, 3, 4, 5 };

var squaredNumbers = numbers.Select(n => n * n);

foreach (var num in squaredNumbers)
{
    Console.WriteLine(num);
}

Output:

3. Sorting Data: `OrderBy()`

The OrderBy() method sorts the elements of a collection in ascending order. You can also use OrderByDescending() for descending order:

var numbers = new[] { 5, 3, 8, 1, 4 };

var sortedNumbers = numbers.OrderBy(n => n);

foreach (var num in sortedNumbers)
{
    Console.WriteLine(num);
}

Output:

4. Grouping Data: `GroupBy()`

The GroupBy() method is used to group elements based on a key. Here's an example of grouping a list of people by their age:

var people = new[]
{
    new { Name = "John", Age = 25 },
    new { Name = "Jane", Age = 30 },
    new { Name = "Mike", Age = 25 },
    new { Name = "Sarah", Age = 30 }
};

var groupedByAge = people.GroupBy(p => p.Age);

foreach (var group in groupedByAge)
{
    Console.WriteLine($"Age: {group.Key}");
    foreach (var person in group)
    {
        Console.WriteLine($"- {person.Name}");
    }
}

Output:

Age: 25
- John
- Mike
Age: 30
- Jane
- Sarah

More LINQ Extension Methods

The above methods are just a few examples of the many powerful LINQ extension methods available in C#. There are several other methods that can help you perform more complex operations like joining collections, checking for conditions, concatenating sequences, and more.

To explore these additional methods, I have included more examples and detailed explanations in my GitHub repository. You can check out the full list of LINQ extension methods along with code snippets by visiting my repository:

LINQ Extension Methods - GitHub Repository

Conclusion

LINQ extension methods are a crucial tool in C# for making code more efficient, readable, and maintainable. They provide an intuitive way to query, filter, transform, and manipulate data. By using LINQ, developers can avoid writing verbose and error-prone loops, reducing the complexity of their code. Whether you're working with in-memory collections, databases, or remote data sources, LINQ extension methods offer a simple yet powerful way to handle data in C#.

Creational Patterns : Factory Method

Common Khadka — Thu, 05 Dec 2024 17:10:33 +0000

Factory Method

The Factory Method is a creational design pattern that defines an interface for creating objects but lets subclasses alter the type of objects that will be created.

It promotes loose coupling and enhances flexibility by delegating object instantiation to subclasses.

This pattern is useful when a class cannot anticipate the type of objects it must create or wants to delegate creation to derived classes.

using System;

// Step 1: Define the Product interface

public interface IAnimal

{

    void Speak();

}

// Step 2: Create Concrete Products

public class Dog : IAnimal

{

    public void Speak() => Console.WriteLine("Woof!");

}

public class Cat : IAnimal

{

    public void Speak() => Console.WriteLine("Meow!");

}

// Step 3: Create the Creator (Factory) Abstract Class

public abstract class AnimalFactory

{

    public abstract IAnimal CreateAnimal();

}

// Step 4: Implement Concrete Creators

public class DogFactory : AnimalFactory

{

    public override IAnimal CreateAnimal() => new Dog();

}

public class CatFactory : AnimalFactory

{

    public override IAnimal CreateAnimal() => new Cat();

}

// Step 5: Client Code

public class Program

{

    public static void Main()

    {

        AnimalFactory dogFactory = new DogFactory();

        IAnimal dog = dogFactory.CreateAnimal();

        dog.Speak(); // Output: Woof!

    AnimalFactory catFactory = new CatFactory();
    IAnimal cat = catFactory.CreateAnimal();
    cat.Speak(); // Output: Meow!
}



}

Key Points:

IAnimal: Defines the interface for the objects created.

Concrete Classes (Dog, Cat): Implement the interface.

Abstract Factory (AnimalFactory): Declares the method for creating objects.

Concrete Factories (DogFactory, CatFactory): Override the creation method to return specific objects.

This example shows how the Factory Method allows you to encapsulate object creation, making the system scalable and maintaining the open/closed principle.

Adapter Design Pattern

Common Khadka — Mon, 15 Jan 2024 08:17:05 +0000

Allows two completely incompatiable interface to work together.
Used when the client excepts a (target) interface
The adapter class allows the use of the available interface and the target interface.
Any class can work together as long as the adapter solves the issue that all classes must implement every method defined by the shared interface.

Video Source

The Adapter design pattern is used to allow incompatible interfaces to work together.
It acts as a bridge between two incompatible interfaces by converting the interface of a class into another interface that a client expects.

Here's a simple example in C# to illustrate the Adapter pattern:

Suppose you have an existing OldSystem class with a method Request, and you want to adapt it to work with a new system that expects a different interface, INewSystem.
The OldSystemAdapter class serves as the adapter to make the OldSystem compatible with the INewSystem interface.

using System;

// Existing system with an incompatible interface
public class OldSystem
{
    public void Request()
    {
        Console.WriteLine("OldSystem is handling the request.");
    }
}

// New system with a different interface
public interface INewSystem
{
    void NewRequest();
}

// Adapter class that adapts OldSystem to INewSystem
public class OldSystemAdapter : INewSystem
{
    private readonly OldSystem oldSystem;

    public OldSystemAdapter(OldSystem oldSystem)
    {
        this.oldSystem = oldSystem;
    }

    public void NewRequest()
    {
        // Call the existing OldSystem's method from the adapted interface
        oldSystem.Request();
    }
}

// Client code that expects INewSystem interface
public class Client
{
    public void UseSystem(INewSystem system)
    {
        system.NewRequest();
    }
}

class Program
{
    static void Main()
    {
        // Using the existing OldSystem with the help of the adapter
        OldSystem oldSystem = new OldSystem();
        INewSystem adapter = new OldSystemAdapter(oldSystem);

        // Client code works with the INewSystem interface
        Client client = new Client();
        client.UseSystem(adapter);
    }
}

In this example:

OldSystem is the existing class with an incompatible interface.
INewSystem is the new interface expected by the client.
OldSystemAdapter is the adapter class that implements INewSystem by delegating calls to the existing OldSystem.

The client code (Client class) works with INewSystem and is unaware of the existence of OldSystem.
The adapter bridges the gap between the existing system and the client's expectations.

This is a simplified example, but it illustrates the basic structure of the Adapter pattern. In real-world scenarios, you might encounter more complex interfaces and interactions.

"Optimizing Email Workflows: From Ethereal Testing to Production Perfection"

Common Khadka — Sat, 09 Dec 2023 10:52:11 +0000

Sending automated emails is a fundamental feature in modern software development. However, sharing the credentials of your official Google Account during the development phase might not be the wisest choice. Enter Ethereal Email, a game-changer in the world of test email servers.

Ethereal is a faux SMTP service, designed primarily for Nodemailer and EmailEngine users, though its applications are not limited to these. This free, anti-transactional email service ensures messages never reach their intended destination, making it ideal for development.

Having utilized Ethereal Email for over two years, I can attest to its flawless performance, especially in collaborative team environments. It seamlessly handles monkey testing scenarios, allowing you to use any dummy email as a receiver and view the messages sent in the Ethereal Email message section.

Now, when it comes to production, the initial inclination might be to provide actual credentials for your official Gmail account. However, thanks to positive changes from Google, this is no longer necessary. A few tweaks to the settings, and you'll receive a random password to use for your project services.

While crafting this post, I stumbled upon this guide, which presents a straightforward procedure for configuring your Google account as an email sender.

In summary, I employ Ethereal Email as my go-to test mail server during development. I'd love to hear about your preferences and strategies for managing development and production email systems.

That's all for now. Until next time!

ABSTRACT CLASS VS INTERFACE

Common Khadka — Thu, 31 Aug 2023 11:56:43 +0000

One of the most frequently asked questions in any technical interview is "Tell me something about abstract class and interface."
Although it is rather straightforward, occasionally it can be difficult to distinguish between them.

Let's begin with their description:

Abstract Class
A class that cannot be created on its own but is frequently used as a model for other classes is referred to as an abstract class. It
may include both concrete (implemented) and abstract (not yet
implemented) methods.

Interface
An interface refers to a contract that specifies a group of methods that a class which implements it, must offer. It does not include any implementation; it simply contains method signatures.

The most important thing to take away from this is that although Interface only has unimplemented methods, Abstract classes can contain both implemented and unimplemented methods.

Usage

Abstract Class
Use an abstract class when you have a base class with shared behavior between its subclasses. Some methods should have a standard implementation, while others should be left up to subclasses to implement.

Interface
Use an interface when you wish to establish a contract that several classes can operate without imposing a particular class hierarchy. Method signatures may be inherited more than once.

Implementing a method:

Abstract Class
Both abstract and concrete methods are possible for an abstract class.
The abstract methods must have implementations provided by subclasses.

Interface:
Only method signatures are present; no implementation is
present. All of the methods in an interface must have concrete
implementations in classes that implement the interface.

I have an simple real life example which will make it more clear.

Abstract Class
Abstract class are more like a company employee's. Company can have full time employee who will handle day to day work. And, company can also hire part time employee who will handle that specific work.

Interface
Interface is like a job contractor. You just define job to be done to a contractor and they will handle the rest. if any employee leaves the work than it won't matter to you because it will be handled by the contractor itself.

Let's explain with the help of some code examples.


using System;
// Abstract class  
abstract  class  Shape
{ 
// Concrete method  
    public void PrintColor() 
    { 
        Console.WriteLine("The shape is colored."); 
    } 
    // Abstract method to calculate area (to be implemented by subclasses)  
    public abstract double CalculateArea(); 
} 
// Concrete subclass  
class  Circle : Shape 
{ 
    private  double radius; 
    public Circle(double radius) 
    { 
        this.radius = radius; 
    } 
    public override double CalculateArea() 
    { 
        return Math.PI * radius * radius; 
    } 
} 
// Concrete subclass 
class  Rectangle : Shape 
{ 
    private  double length;
    private  double width; 
    public Rectangle(double length, double width) 
    { 
        this.length = length; this.width = width; 
    } 
    public override double CalculateArea() 
    { 
        return length * width; 
    } 
}

In this C# example, the Shape class is an abstract class with a concrete method PrintColor() and an abstract method CalculateArea(). Subclasses Circle and Rectangle inherit from Shape and provide concrete implementations for the CalculateArea() method.

using System;

// Interface for drawing
interface IDrawable
{
    void Draw();
}

// Interface for filling
interface IFillable
{
    void Fill();
}

// Class implementing both interfaces
class Circle : IDrawable, IFillable
{
    private double radius;

    public Circle(double radius)
    {
        this.radius = radius;
    }

    public void Draw()
    {
        // Implementation for drawing a circle
        Console.WriteLine("Drawing a circle.");
    }

    public void Fill()
    {
        // Implementation for filling a circle
        Console.WriteLine("Filling a circle.");
    }
}

In this C# example, we have two interfaces, IDrawable and IFillable, each with a method signature. The Circle class implements both interfaces and provides concrete implementations for the Draw() and Fill() methods. This demonstrates how C# allows a class to implement multiple interfaces to achieve multiple inheritance of method signatures.

I guess that's all. Hope you understand. Enjoy.

BOILERPLATE AND WHY?

Common Khadka — Fri, 25 Aug 2023 07:16:43 +0000

Why Boilerplate Code is Important in the Development of Software

Boilerplate code is frequently seen in the context of software development with mixed feelings. It is viewed as redundant and time-consuming on the one hand, and necessary for effective and maintained codebases on the other. The importance of boilerplate code will be discussed in this essay, along with the reasons why it should be embraced rather than avoided.

Boilerplate Code: What is it?

Code that needs to be written repeatedly with little to no variation is referred to as boilerplate code. This contains the setup code, configuration files, imports, and other repetitious building blocks that make up a software project's framework. Although it may seem like a boring process, boilerplate code has a number of important functions.

1. Regularity and Standardization

Boilerplate code helps maintain consistency and standardization inside a codebase, which is one of its main benefits. The code is simpler to comprehend, maintain, and extend when developers adhere to a set framework for their projects. This consistency applies to all teams and projects, which improves teamwork.

2. Reduced Error Rates

Best practices and necessary error-checking methods are frequently included in boilerplate code. For instance, it might consist of security protections, input validation, and exception handling. Boilerplate code is frequently used because it makes engineers less likely to forget these important details, which lowers the risk of errors and security flaws.

3. Faster Development

The use of boilerplate code speeds up development. They can use pre-existing templates or code snippets to reduce the amount of time spent on development by not having to reinvent the wheel for every project. This is very helpful when setting up a build system, a project structure, or initializing a database connection.

4. Maintenance and Scalability

Software projects frequently need upgrades, improvements, or bug patches as they develop. By enabling uniform application of changes, boilerplate code encourages maintainability. Developers can make changes with better assurance and predictability when they are aware of specific code patterns. Large-scale projects with a long lifespan require this.

5. Code Readability

Maintainable code is readable code. When boilerplate code is organized correctly, readability is improved. It offers a reliable structure that programmers may adhere to. This uniformity improves the readability of the entire codebase and makes it simpler for team members to understand each other's code.

6. Code Reusability

The common functionalities that can be reused across projects are frequently encapsulated in boilerplate code. Reusable boilerplate code includes frameworks, libraries, and code generators. By utilizing these tools, developers can lessen redundancy and take use of tried-and-true methods, further enhancing the caliber of their product.

Embracing Boilerplate Code

Let's talk about how to successfully use boilerplate code now that we've established its significance:

1. Templates and Generators

Use code generators and templates if you can. You can construct unique templates for your boilerplate code using tools found in many contemporary integrated development environments (IDEs). You might also look at code generation tools that are tailored to your programming language or framework.

2. Code Reviews and Standards

Make your code review process include boilerplate coding guidelines. Establish coding guidelines, including boilerplate code norms, and make sure that everyone on the team follows them. Your projects will become more consistent and maintainable as a result.

3. Reusable Libraries and Frameworks

Utilize reusable frameworks and libraries that offer well-organized boilerplate code for typical tasks. For instance, web developers can use well-known frameworks with predetermined project structures and conventions.

4. Documentation

Effectively document your boilerplate code. Boilerplate sections' purpose and usage should be made clear in comments and documentation so that developers can more easily comprehend them and make the necessary modifications.

5. Continuous Improvement

Boilerplate code shouldn't stay the same forever. Review and update your boilerplate code frequently to include the latest best practices, innovations, and security precautions. This makes sure that it continues to be an important component of your development process.

Conclusion

Software development that is effective has boilerplate code on its side rather than against it. Boilerplate code is a vital weapon in a developer's toolbox since it offers uniformity, lowers errors, speeds up development, and improves maintainability. Boilerplate code should be embraced rather than avoided since it serves as a springboard for creating strong, dependable, and scalable software solutions. Boilerplate code continues to provide a solid basis upon which to create unique and fruitful projects in the ever-changing world of software development.

Improve your Javascript debugging Skills

Common Khadka — Fri, 03 Mar 2023 15:44:58 +0000

Debugging a code is an art. If you don't have good debugging skills, it can really be pain in the ass. If you don't understand the working mechanism of Javascript code, finding a bug can be hard. Having knowledge of debugging tools/methods that JS provides, it can be really helpful . Besides, having good knowledge of debugging can save a lot of time. Following are some of the methods / statement in JS that aids debugging .

console.log
console.table
console.trace
console.warn
console.error
console.assert
debugger
console.time && console.timeEnd

Let's get into these in detail

console.log

This method takes any number of arguments and prints the value in console window. It is helpful when you want to know the value of variable at specific instant of time.

Usage:

let student ={
 firstName: "Niroj",
 lastName: "Dahal"
}
console.log('student detail',student);

Result Screenshot

console.table

This method is useful when you want to see the values of array in console. It shows the data in table format so that the datas are readable

Usage:

let values = [1,2,3,4,5,6];

console.table(values);

Result Screenshot

console.trace

This methods prints out the stack trace of code. It is useful when same method is called from multiple places and we are having hard time figuring out why and from where the specified method is called.

Usage:

function CalledMethod(){
    console.trace('trace from where this method is called');
}

function CallerMethod1(){
   CalledMethod();
}

function CallerMethod2(){
   CalledMethod();
}
CallerMethod1();
CallerMethod2();

Result Screenshot

In the above example, we called CalledMethod twice once through CallerMethod1 method and again through CallerMethod2 . As seen in screenshot, trace is written in console stating the same.

console.warn

This method shown message in yellow color (warning) .

Usage:

console.warn('This is a warning message');

Result Screenshot

console.error

This method shows message in red color (error).

Usage:

console.error('This is an error message');

Result Screenshot

console.assert

This method writes a message to the console if an expression evaluates to false. It is useful to log against unexpected/invalid conditions

Usage:

let studentDataFromApi=null;
console.assert(studentDataFromApi !=null,'Student data cannot be null');

Result Screenshot

In this example, since first expression

studentDataFromApi !=null

evaluates to false, second parameter message is logged.

debugger

This method is used to set breakpoint during the program flow. If you want to see the values of variables at some point of time, consider using a debugger. The debugger statement stops the execution of JavaScript, and calls the debugger

Usage:

function TestDebugger(){
   let val =1,secondVal=2,thirdVal=3,forthVal=4;
    debugger;
}
TestDebugger();

Result Screenshot

In screenshot , we can clearly see the value of variables of state before debugger is called.

console.time && console.timeEnd

These methods are used to print the execution time of the code .

console.time starts the timer and console.timeEnd stops previous timer and logs the time taken to execute code between those methods. Both methods take a string parameter for named timer. You can specify name to timer in console.time method and specify same parameter to stop a timer. If parameter is not provided, name defaults to default

Usage:

console.time('start');
console.timeEnd('start');

Result Screenshot

Thank you for reading and happy debugging!

Refactoring To Improve Performance

Common Khadka — Fri, 03 Mar 2023 15:08:27 +0000

We, as developers, get lost in getting a feature complete within a time-frame and negate performance most of the time. Currently, I am working on an application where I was requested to improve performance. A page was taking around 14-15s to get loaded. I brought it down to 4-5s although it is still a lot to wait. Here are some things that impacted performance of application and how I sorted it out

Lazy-loading everywhere

We used Entity Framework as ORM. In order to process data, we had couple of foreach statements and nested loops . Inside loop, properties of referenced entities and collections were manipulated. Loading such data's eagerly reduced around 100 queries.

Automapper used everywhere

Automapper was used extensively in our application. Suppose we had an Address Entity and it had reference to State entity which further had reference to Province entity , we mapped Address entity to AddressViewModel using automapper. Even when I needed detail of Address entity in AddressViewModel, it would map all details of references in AddressViewModel. One way to get rid of it was to configure Automapper in a way to exclude mapping references of entity but that would cause our application to break since it was used elsewhere. Mapping only required references helped to improve performance.

Selecting every fields from Database

Even if only some fields in a table were needed, every fields were retrieved from database. Some of the columns stored large amount of data's which resulted in weak performance. Selecting only the required fields improved performance by some margin.

Less Use of TryParse

In order to parse Enum from string or int , code used to wrapped inside Try/Catch block . If exception was caught, do something. Exceptions are meant to be unintentional but we depend on exceptions to perform an action. Changing those statements to use TryParse improved readability and performance slightly.

Unaware of SelectMany querying pattern

Whenever we needed a reference inside collections , we did SelectMany . Our common misconception was SelectMany does a single query to database and retrieved data. Using a profiler showed more number of queries than expected. Suppose , we had 5 items in collection and we used SelectMany to get references inside a collection, it did 5 queries where only 1 was expected. At the end, our solution was to issue a single query to required reference table.

That's all for now. Happy Coding !!

Forem: Common Khadka

Software Architecture for a CHILD

🏠 What is Software Architecture?

1. Monolithic Architecture 🧱

2. Microservices Architecture 🏘️

3. Clean Architecture 🧼 (or Hexagonal)

🧠 Example: Your game logic doesn’t care whether the player uses keyboard or touch screen.

4. Onion Architecture 🧅

5. Layered Architecture 🍰

💡 In short:

PLINQ Extension Methods in C#

1. AsParallel

2. WithDegreeOfParallelism

3. ParallelEnumerable.Range

4. ParallelEnumerable.Repeat

5. ParallelEnumerable.Empty

6. AsSequential

7. AsOrdered

8. AsUnordered

9. WithCancellation

10. WithMergeOptions

11. WithExecutionMode

12. ForAll

Conclusion

References

Understanding LINQ Extension Methods in C#

What are LINQ Extension Methods?

Importance of LINQ Extension Methods

How to Use LINQ Extension Methods

1. Filtering Data: Where()

2. Projecting Data: Select()

3. Sorting Data: OrderBy()

4. Grouping Data: GroupBy()

More LINQ Extension Methods

Conclusion

Creational Patterns : Factory Method

Factory Method

Key Points:

Adapter Design Pattern

"Optimizing Email Workflows: From Ethereal Testing to Production Perfection"

ABSTRACT CLASS VS INTERFACE

BOILERPLATE AND WHY?

Why Boilerplate Code is Important in the Development of Software

Boilerplate Code: What is it?

1. Regularity and Standardization

2. Reduced Error Rates

3. Faster Development

4. Maintenance and Scalability

5. Code Readability

6. Code Reusability

Embracing Boilerplate Code

1. Templates and Generators

2. Code Reviews and Standards

3. Reusable Libraries and Frameworks

4. Documentation

5. Continuous Improvement

Conclusion

Improve your Javascript debugging Skills

console.log

console.table

console.trace

console.warn

console.error

console.assert

debugger

console.time && console.timeEnd

Refactoring To Improve Performance

Lazy-loading everywhere

Automapper used everywhere

Selecting every fields from Database

Less Use of TryParse

Unaware of SelectMany querying pattern

1. Filtering Data: `Where()`

2. Projecting Data: `Select()`

3. Sorting Data: `OrderBy()`

4. Grouping Data: `GroupBy()`