Forem: Syed Nadeem Hussain

[Boost]

Syed Nadeem Hussain — Fri, 05 Dec 2025 01:24:00 +0000

DotNet Basics: What are the three main types of errors in C#? 🐞

Jarryd ・ Jun 4

#csharp #microsoft #dotnet #programming

[Boost]

Syed Nadeem Hussain — Thu, 23 Oct 2025 14:42:07 +0000

Beyond the basics: 21 TypeScript features you might not know about

David Turnbull for Lingo.dev ・ Oct 22

#webdev #typescript #programming

Building Scalable Microservices with .NET 8.0 and Kubernetes

Syed Nadeem Hussain — Tue, 09 Jul 2024 13:30:00 +0000

Microservices architecture has revolutionized software development, enabling scalable and maintainable applications. With the latest .NET 8.0, building microservices is more efficient and powerful than ever. Here’s a quick guide to get you started:

Setting Up Your Environment

Install .NET 8.0 SDK
Install Docker
Set Up Kubernetes

Developing Your Microservices

Create your microservices with ASP.NET Core Web API. Here’s a simple example:

OrderService/OrderController.cs:

using Microsoft.AspNetCore.Mvc;

namespace OrderService.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class OrderController : ControllerBase
    {
        [HttpGet]
        public IActionResult GetOrders()
        {
            var orders = new List<string> { "Order1", "Order2", "Order3" };
            return Ok(orders);
        }
    }
}

Containerizing with Docker

Create Dockerfiles to containerize your microservices:

OrderService/Dockerfile:

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["OrderService/OrderService.csproj", "OrderService/"]
RUN dotnet restore "OrderService/OrderService.csproj"
COPY . .
WORKDIR "/src/OrderService"
RUN dotnet build "OrderService.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "OrderService.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "OrderService.dll"]

Deploying to Kubernetes

Deploy your Dockerized microservices to Kubernetes with simple manifests:

OrderService/k8s-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: orderservice-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: orderservice
  template:
    metadata:
      labels:
        app: orderservice
    spec:
      containers:
      - name: orderservice
        image: orderservice:latest
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: orderservice
spec:
  selector:
    app: orderservice
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

Learn More

To dive deeper into building and scaling microservices with .NET 8.0 and Kubernetes, read the full blog post here.

Debouncing and Throttling: Taming the Wild West of JavaScript Events

Syed Nadeem Hussain — Fri, 23 Feb 2024 07:46:47 +0000

What is Debouncing and Throttling in JavaScript?

Imagine the Wild West, where gunslingers fire at will, creating chaos and confusion. In the web development world, untamed events can wreak similar havoc on your JavaScript applications. But fear not, for we have two trusty sheriffs in town: debouncing and throttling. Let's saddle up and explore how these techniques bring order to the event-driven frontier.

Debouncing: The Patient Gunslinger

Debouncing is like the sharpshooter who waits for the right moment before drawing his gun. In JavaScript, it delays the execution of a function until a certain amount of time has passed since the last event, ensuring it fires only when necessary.

Real-world example:

Scenario: You're building a search bar that displays live suggestions as the user types. Every keystroke triggers a search, overwhelming the server and confusing the user with flickering results.
Solution: Debounce the search function! Here's the posse: Set a delay: Choose a suitable waiting time, like 250 milliseconds (ms). *Create a gunslinger (function): This function displays the search suggestions.
Hire a marshal (debounce function): This marshal:
Keeps track of a timer (like a wanted poster).
When the user types:
Cancel any existing timer (no double-firing!).
Starts a new timer with the chosen delay.
When the timer ticks down:
The marshal signals the gunslinger to draw (execute the search function).

With debouncing, the search function only fires after the user finishes typing, providing more accurate and stable suggestions. No more shootouts at the keystroke corral!

Throttling: The Measured Marshal

Throttling, on the other hand, acts like the town marshal who limits the number of times gunslingers can draw their weapons within a specific timeframe. In JavaScript, it restricts how often a function can be called within a certain period, preventing excessive firing and maintaining order.

Real-world example:

Scenario: You've implemented infinite scrolling on your webpage. With every pixel scrolled, an API call fetches new content, potentially overloading the server and slowing down the experience.
Solution: Throttle the scroll handler! Here's the posse:
Set a firing limit: Decide how often the function can fire (e.g., once every 100 pixels).
Create a vigilant marshal (throttle function): This marshal:
Keeps track of the last time the function fired (like a town clock).
When the user scrolls:
Check if enough time has passed since the last firing.
If so, allow the function to fire (fetch new content).
If not, the marshal holds its badge high (prevents firing).
The API calls are spaced out with throttling, ensuring smooth scrolling and efficient server usage. No more pixel-perfect pandemonium!

JavaScript Roundup:

Here's a quick draw of how these techniques look in code:

// Debounce with Lodash (for simplicity)
const debouncedSearch = _.debounce(searchText => {
  // Your search logic here
}, 250);
// Throttle vanilla JavaScript style
let lastScroll = 0;
const throttledScroll = () => {
  const now = Date.now();
  if (now - lastScroll > 100) {
    // Your scrolling logic here
    lastScroll = now;
  }
};

Beyond the Basics:
Remember, this is just the posse arriving in town. The full story includes:
Crafting your own debounce and throttle functions: Become a coding gunslinger!
Taming older browsers with polyfills: Don't leave any browser saloon unaddressed.
Advanced maneuvers: Explore edge cases and trade-offs like a seasoned ranger.
Answering interview questions: Be ready to draw on your knowledge!
By wielding debouncing and throttling, you can create JavaScript applications that are smooth, efficient, and user-friendly. Remember, taming wild events isn't just about performance; it's about crafting a web experience that's a delight to use. So, saddle up, partner, and bring order to your JavaScript frontier!

And Keep Learning till the Next Time

Assalamualaikum - Allahuma Barik
Peace Out✌️