C# on Brian Braatz Blog

Finite State Machines, Hierarchical State Machines, and SAGA

Wed, 12 Sep 2018 00:00:00 +0000

Used with Saga, Finite State Machines (FSMs) and Hierarchical State Machines (HSMs)—two powerful tools that can help structure SAGA workflows. 🚀

What is a Finite State Machine (FSM)? 🤖

A Finite State Machine (FSM) is a model where a system can only be in one state at a time and transitions between states based on predefined rules.

Example: Order Processing FSM

An order system typically has these states:

Pending → Paid → Shipped → Delivered
If payment fails, transition to Failed
If the item is out of stock, transition to Cancelled

Here’s a basic FSM implementation in C# using enum:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


enum OrderState { Pending, Paid, Shipped, Delivered, Failed, Cancelled }

class Order
{
 public OrderState State { get; private set; } = OrderState.Pending;

 public void Pay() { if (State == OrderState.Pending) State = OrderState.Paid; }
 public void Ship() { if (State == OrderState.Paid) State = OrderState.Shipped; }
 public void Deliver() { if (State == OrderState.Shipped) State = OrderState.Delivered; }
 public void Fail() { State = OrderState.Failed; }
 public void Cancel() { State = OrderState.Cancelled; }
}

Python Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


from enum import Enum

class OrderState(Enum):
 PENDING = "Pending"
 PAID = "Paid"
 SHIPPED = "Shipped"
 DELIVERED = "Delivered"
 FAILED = "Failed"
 CANCELLED = "Cancelled"

class Order:
 def __init__(self):
 self.state = OrderState.PENDING

 def pay(self):
 if self.state == OrderState.PENDING:
 self.state = OrderState.PAID

 def ship(self):
 if self.state == OrderState.PAID:
 self.state = OrderState.SHIPPED

 def deliver(self):
 if self.state == OrderState.SHIPPED:
 self.state = OrderState.DELIVERED

 def fail(self):
 self.state = OrderState.FAILED

 def cancel(self):
 self.state = OrderState.CANCELLED

How FSMs Relate to SAGA 🌀

SAGA consists of multiple services interacting asynchronously, but each step in the SAGA workflow is essentially a state transition.

Each microservice acts as an FSM, progressing through defined states.
If a step fails, the system transitions into a failure state and triggers compensating actions.
Using FSMs in SAGA ensures we always know where the process is and what action to take next.

What is a Hierarchical State Machine (HSM)? 🏛️

A Hierarchical State Machine (HSM) is an FSM with nested states.

Example: Expanding Order Processing with Substates

Order → Processing → Payment → Paid
Order → Processing → Payment → Failed → Retry
Order → Fulfillment → Shipped → Delivered

With HSMs, we group related states and handle transitions within them.

C# Example: HSM for Order Processing

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


class OrderProcess
{
 public enum State { OrderPlaced, PaymentProcessing, PaymentFailed, Shipped, Delivered }
 private State _state = State.OrderPlaced;

 public void ProcessPayment(bool success)
 {
 if (_state == State.OrderPlaced)
 _state = success ? State.Shipped : State.PaymentFailed;
 }

 public void RetryPayment()
 {
 if (_state == State.PaymentFailed)
 _state = State.PaymentProcessing;
 }
}

Python Example: HSM for Order Processing

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class OrderProcess:
 class State:
 ORDER_PLACED = "OrderPlaced"
 PAYMENT_PROCESSING = "PaymentProcessing"
 PAYMENT_FAILED = "PaymentFailed"
 SHIPPED = "Shipped"
 DELIVERED = "Delivered"

 def __init__(self):
 self.state = self.State.ORDER_PLACED

 def process_payment(self, success):
 if self.state == self.State.ORDER_PLACED:
 self.state = self.State.SHIPPED if success else self.State.PAYMENT_FAILED

 def retry_payment(self):
 if self.state == self.State.PAYMENT_FAILED:
 self.state = self.State.PAYMENT_PROCESSING

How HSMs Relate to SAGA 🏗️

HSMs fit perfectly into orchestrated SAGA workflows where:

Substates define smaller steps within a SAGA process.
Retry mechanisms for failed steps can be modeled as state transitions.
- Nested states help manage complex workflows like order processing, refunds, and stock availability.

Final Thoughts 💡

FSMs and HSMs provide structure and clarity to microservices. SAGA is already a state-driven workflow, and using FSMs/HSMs makes it easier to manage state transitions.

If your microservices are struggling with state tracking, consider using FSMs or HSMs to keep them predictable and resilient. 🚀

🔑 Key Ideas Table

Concept	Explanation
Finite State Machine (FSM)	System transitions between a limited number of states.
Hierarchical State Machine (HSM)	FSM with nested states for better organization.
FSM in SAGA	Each service acts as a state machine.
HSM in SAGA	Nested states help manage complex workflows.
C# and Python Examples	Demonstrate FSM and HSM implementations.

📚 References

Multi-Threaded Lock-Free Programming in C#

Sun, 15 Dec 2024 00:00:00 +0000

What Is Lock-Free Programming?

Imagine you’re at a party, and everyone wants to use the bathroom.

Traditional locking is like handing out keys—only one person can go at a time.

But lock-free programming?

It’s like installing a bunch of bathrooms so everyone can go simultaneously without waiting.

Cool, right?

In technical terms, lock-free programming allows multiple threads to access shared data structures without traditional locks, ensuring that at least one thread makes progress at any given time.

This approach is crucial for high-performance applications where waiting is a no-go.

Why Should You Care?

Performance Boost: By avoiding the overhead of locks, your application can handle more operations in less time.
Scalability: As your app grows and more threads join the party, lock-free structures help maintain smooth operations.
Reduced Deadlocks: Without locks, the dreaded deadlock monster stays away.

How to Do It in C# ?

1. Use Concurrent Collections

Example: Using `ConcurrentDictionary`

Instead of using a regular Dictionary with locking, use ConcurrentDictionary:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


using System;
using System.Collections.Concurrent;

class Program
{
 static void Main()
 {
 var concurrentDict = new ConcurrentDictionary<int, string>();

 // Adding key-value pairs safely
 concurrentDict.TryAdd(1, "Value1");
 concurrentDict.TryAdd(2, "Value2");

 // Updating a value atomically
 concurrentDict.AddOrUpdate(1, oldValue => "UpdatedValue", (key, oldValue) => "UpdatedValue");

 // Retrieving a value safely
 if (concurrentDict.TryGetValue(1, out string value))
 {
 Console.WriteLine($"Key 1 has value: {value}");
 }
 }
}

Example: Using `ConcurrentQueue`

ConcurrentQueue<T> is a thread-safe queue that allows multiple threads to enqueue and dequeue items safely.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;

class Program
{
 static void Main()
 {
 var queue = new ConcurrentQueue<int>();

 // Simulate multiple threads enqueuing items
 Parallel.For(0, 10, i => queue.Enqueue(i));

 // Dequeue items safely
 while (queue.TryDequeue(out int item))
 {
 Console.WriteLine($"Dequeued: {item}");
 }
 }
}

Example: Using `ConcurrentBag`

A ConcurrentBag<T> is useful for scenarios where multiple threads are producing and consuming items in a non-deterministic order.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;

class Program
{
 static void Main()
 {
 var bag = new ConcurrentBag<int>();

 // Add items concurrently
 Parallel.For(0, 10, i => bag.Add(i));

 // Retrieve items (order is undefined)
 while (!bag.IsEmpty)
 {
 if (bag.TryTake(out int item))
 {
 Console.WriteLine($"Took: {item}");
 }
 }
 }
}

Example: Using `ConcurrentStack`

If you need a thread-safe stack, ConcurrentStack<T> is your go-to choice.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;

class Program
{
 static void Main()
 {
 var stack = new ConcurrentStack<int>();

 // Push items concurrently
 Parallel.For(0, 10, i => stack.Push(i));

 // Pop items safely
 while (!stack.IsEmpty)
 {
 if (stack.TryPop(out int item))
 {
 Console.WriteLine($"Popped: {item}");
 }
 }
 }
}

These Concurrent collections allow you to avoid explicit locking while maintaining thread safety, making your C# applications more performant and scalable.

These collections handle the nitty-gritty of synchronization for you, so you can focus on the fun stuff. (learn.microsoft.com)

2. Dive into Interlocked Operations

For simple types like integers or booleans, the Interlocked class is your friend. It provides atomic operations, ensuring that your threads don’t step on each other’s toes.

1
2


int counter = 0;
Interlocked.Increment(ref counter); // Atomically increments counter

This ensures that even if multiple threads are incrementing the counter simultaneously, they won’t cause a race condition.

3. Embrace the Power of Volatile

The volatile keyword tells the compiler and runtime that a field’s value can be changed by multiple threads. It’s like saying, “Hey, don’t cache this value; always read it fresh.”

1

private volatile bool isRunning;

Use it wisely, though! It’s not a silver bullet and doesn’t replace proper synchronization.

4. Create Your Own Lock-Free Structures

Feeling adventurous?

You can build your own lock-free data structures using atomic operations.

It’s like crafting your own superhero cape…

Here’s a simple example of a lock-free stack using Interlocked.CompareExchange:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


public class LockFreeStack<T>
{
 private Node head;

 public void Push(T value)
 {
 Node newHead = new Node(value);
 do
 {
 newHead.Next = head;
 } while (Interlocked.CompareExchange(ref head, newHead, newHead.Next) != newHead.Next);
 }

 public T Pop()
 {
 Node oldHead = head;
 do
 {
 if (oldHead == null) throw new InvalidOperationException("Stack is empty.");
 } while (Interlocked.CompareExchange(ref head, oldHead.Next, oldHead) != oldHead);
 return oldHead.Value;
 }

 private class Node
 {
 public T Value;
 public Node Next;
 public Node(T value) { Value = value; }
 }
}

This stack allows multiple threads to push and pop items without traditional locks.

(codeproject.com)

Key Ideas

Concept	Description
Lock-Free Programming	Allows multiple threads to access shared data without traditional locks.
Concurrent Collections	.NET’s thread-safe collections like `ConcurrentQueue<T>` and `ConcurrentDictionary<TKey, TValue>`.
Interlocked Operations	Atomic operations provided by the `Interlocked` class for simple types.
Volatile Keyword	Indicates that a field’s value can be changed by multiple threads.
Custom Lock-Free Structures	Building your own lock-free data structures using atomic operations.

Building a Hybrid On-Prem Cloud App with a Secret API!

Sat, 25 Jan 2020 00:00:00 +0000

Background and Related project: eFit Aware IOS and Android Mobile Apps
eFit Aware - Android iPhone Mobile with Azure Cloud Sync

Introduction

Hybrid cloud architecture is one of those things that sounds fancy, but in reality, it’s just a way to mix on-premise computing with cloud services.

There are many reasons to not put everything in the cloud, and I once had a real-world use case for this.

The Problem: Our algorithms were highly sensitive, and we didn’t want to put even the compiled code on a cloud VM. The best solution? Keep our algorithm running on-premise while using the cloud for everything else.

This article will show how to build a similar hybrid cloud setup using the latest features in AWS, Azure, and Google Cloud.

What is a Hybrid Cloud?

A hybrid cloud is an IT architecture where some workloads run on-premise (your own servers) while others run in the public cloud (AWS, Azure, Google Cloud).

✅ Why Use a Hybrid Cloud?

Security – Keep sensitive data/code on-prem.
Performance – Keep high-speed processing local.
Cost Savings – Reduce cloud costs for predictable workloads.
Compliance – Some industries have regulations requiring on-premise storage.

How I Built a Hybrid Cloud Before Modern Cloud Services

Back in the day, I built a hybrid cloud system using an early version of Azure. It worked, but it was painful:

We had a secret algorithm running on a local server in our office.
Our cloud-based app called the on-premise server via a VPN.
We manually managed connections.

Now, let’s do this properly with modern AWS, Azure, and Google Cloud.

The Hybrid Cloud Architecture

💡 Use Case: We will build a super-secret microservice that divides two numbers (yeah, real spy stuff 🕵️‍♂️).

📌 How it works:

The secret division algorithm runs on-premise (Python & C# microservices).
A public cloud microservice (AWS/Azure/GCP) acts as a proxy API.
The cloud forwards API requests to the on-premise service.

Architecture Diagram

Step 1: Write the Super-Secret Microservice (Python & C#)

Python Version (Runs On-Prem)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/divide', methods=['POST'])
def divide():
 data = request.json
 try:
 result = data['a'] / data['b']
 return jsonify({"result": result})
 except ZeroDivisionError:
 return jsonify({"error": "Division by zero!"}), 400

if __name__ == '__main__':
 app.run(host='0.0.0.0', port=5001)

C# Version (Runs On-Prem)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class DivideController : ControllerBase
{
 [HttpPost]
 public IActionResult Divide([FromBody] DivisionRequest request)
 {
 if (request.B == 0)
 return BadRequest("Division by zero!");

 return Ok(new { result = request.A / request.B });
 }
}

public class DivisionRequest
{
 public double A { get; set; }
 public double B { get; set; }
}

Step 2: Deploy the Microservice in Docker (On-Prem)

Create a Dockerfile:

1
2
3
4
5


FROM python:3.9
WORKDIR /app
COPY app.py .
RUN pip install flask
CMD ["python", "app.py"]

Build and Run:

1
2


docker build -t secret-division .
docker run -p 5001:5001 secret-division

Now, we have our secret microservice running under my desk.

Step 3: Build the Cloud Proxy Microservice

Cloud Proxy Service (Python Flask)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


import requests
from flask import Flask, request, jsonify

app = Flask(__name__)
ON_PREM_SERVICE = "http://my-office-server:5001/divide"

@app.route('/divide', methods=['POST'])
def proxy_divide():
 data = request.json
 response = requests.post(ON_PREM_SERVICE, json=data)
 return response.json(), response.status_code

if __name__ == '__main__':
 app.run(host='0.0.0.0', port=5000)

Step 4: Deploy the Proxy Service in AWS, Azure, and Google Cloud

AWS: Use Elastic Beanstalk or Lambda + API Gateway

Deploy the proxy microservice using AWS Elastic Beanstalk.
Set up AWS API Gateway to expose it publicly.
Configure AWS Site-to-Site VPN to connect to the on-prem service.

Azure: Use Azure App Service + VPN Gateway

Deploy the proxy microservice to Azure App Service.
Use Azure API Management to expose it.
Configure Azure VPN Gateway to reach the on-prem service.

Google Cloud: Use Cloud Run + Hybrid Connectivity

Deploy the proxy to Google Cloud Run.
Expose it via Google API Gateway.
Use Google Cloud Interconnect to talk to on-prem services.

Key Takeaways

Hybrid Cloud = Best of Both Worlds → Security + Cloud Benefits.
We kept our sensitive division algorithm on-prem while using cloud for API proxying.
Modern hybrid cloud solutions (AWS VPN, Azure Hybrid Cloud, Google Interconnect) make this easy.

References

Non-Blocking I/O- The Secret Sauce Behind Snappy Applications

Sun, 14 Jul 2019 00:00:00 +0000

What on Earth is Non-Blocking I/O?

Imagine you’re at a coffee shop (because who doesn’t love caffeine?).

You order a latte, and instead of waiting idly at the counter (blocking), you grab a seat, start reading a book, and the barista brings your drink when it’s ready.

That’s non-blocking I/O in a nutshell: not waiting around for things to happen.

In tech terms, non-blocking I/O allows your application to initiate an operation (like reading a file or fetching data from the internet) and then move on to other tasks.

When the operation completes, your app gets a notification and handles the result.

No more twiddling thumbs!

The Good, the Bad, and the Ugly of Non-Blocking I/O

Pros:

Speed Demon: Your app can handle multiple operations simultaneously without waiting for each to finish.

It’s like being in a relay race where everyone runs at the same time.

citeturn0search2

Resource Saver: By not dedicating threads to waiting tasks, your app uses less memory.

Cons:

Brain Twister: Writing non-blocking code can feel like playing 4D chess.

It’s easy to get lost in a maze of callbacks and promises.

Error Handling Hoopla: With multiple operations happening at once, tracking down bugs can be like finding a needle in a haystack.

A haystack that’s on fire.

Not Always a Silver Bullet: For CPU-heavy tasks, non-blocking I/O might not offer significant benefits.

It’s like trying to use a skateboard to tow a truck.

Non-Blocking I/O in the Wild: Node.js, C#, and Python

Node.js: The Non-Blocking Ninja

Node.js was practically born for non-blocking I/O.

Built on Chrome’s V8 JavaScript engine, it uses an event-driven, non-blocking model.

This makes it ideal for handling multiple connections without breaking a sweat.

It’s like the multitasking octopus of the programming world.

citeturn0search2

However, with great power comes great responsibility.

Node.js developers often face the dreaded “callback hell,” where nested callbacks resemble a labyrinth.

Thankfully, modern JavaScript offers promises and async/await to make the code more readable and maintainable.

C#: The Asynchronous Ace

C# is no stranger to the non-blocking party.

With the introduction of the async and await keywords, writing asynchronous code became as smooth as butter.

These features allow developers to write non-blocking code that looks and feels synchronous, reducing complexity and making it easier to read.

It’s like having your cake and eating it too.

citeturn0search10

But beware!

Mixing synchronous and asynchronous code can lead to unexpected hiccups.

It’s essential to understand when and where to use these features to avoid turning your code into a tangled mess.

Python: The Coroutine Connoisseur

Python, the darling of simplicity, offers non-blocking capabilities through its asyncio library.

By using async and await, Python developers can write asynchronous code that’s both elegant and efficient.

It’s like having a Swiss Army knife in your coding toolkit.

However, not all libraries in Python are async-friendly.

Integrating synchronous and asynchronous code can be tricky, like trying to fit a square peg in a round hole.

Developers need to ensure that their entire stack supports non-blocking operations to reap the full benefits.

Wrapping Up

Non-blocking I/O is a powerful tool in a developer’s arsenal, enabling the creation of fast, efficient, and scalable applications.

Whether you’re rocking Node.js, C#, or Python, understanding and implementing non-blocking operations can take your apps to the next level.

Just remember: with great power comes great complexity.

So, code responsibly!

Key Idea	Description
Non-Blocking I/O	Allows applications to initiate operations and continue without waiting for them to complete
Pros	Enhances speed, resource efficiency, and scalability.
Cons	Increases code complexity and can complicate error handling.
Node.js	Utilizes an event-driven, non-blocking model, ideal for handling multiple connections.
C#	Employs `async` and `await` keywords to write non-blocking code that appears synchronous.
Python	Uses the `asyncio` library with `async` and `await` for elegant asynchronous code.

References:

gRPC in a Nutshell

Mon, 22 Mar 2021 00:00:00 +0000

📜 A Quick History Lesson

Back in 2015, Google said, “Let there be gRPC,” and boom 💥—we got a powerful framework built on HTTP/2, Protobuf, and a sprinkle of Google magic.

(BOOM!)

It was designed to make microservices talk like best friends.

OR at least friends that like to talk to each other…

efficiently

For the nerdy details, check out gRPC.io or dive into Google’s blog.

🧠 What is gRPC Anyway?

gRPC stands for Google Remote Procedure Call.

It’s like calling a method on a remote server as if it was your local function.

Think of it as teleportation for function calls.

Feature	Description
Protocol	HTTP/2
Serialization	Protocol Buffers (Protobuf)
Language	Polyglot (supports tons of languages)
Streaming	Bidirectional and unary streaming

🛠️ Code Examples

1. Python: Protobuf Definition

1
2
3
4
5
6


syntax = "proto3";
message Person {
 string name = 1;
 int32 age = 2;
 string email = 3;
}

2. Python: gRPC Service Definition

1
2
3
4
5
6
7
8
9


service Greeter {
 rpc SayHello (HelloRequest) returns (HelloReply);
}
message HelloRequest {
 string name = 1;
}
message HelloReply {
 string message = 1;
}

3. Python: Server Implementation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


import grpc
from concurrent import futures
import helloworld_pb2
import helloworld_pb2_grpc

class Greeter(helloworld_pb2_grpc.GreeterServicer):
 def SayHello(self, request, context):
 return helloworld_pb2.HelloReply(message=f"Hello {request.name}!")

def serve():
 server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
 helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
 server.add_insecure_port('[::]:50051')
 server.start()
 server.wait_for_termination()

serve()

4. Python: Client Code

1
2
3
4
5
6
7
8


import grpc
import helloworld_pb2
import helloworld_pb2_grpc

channel = grpc.insecure_channel('localhost:50051')
stub = helloworld_pb2_grpc.GreeterStub(channel)
response = stub.SayHello(helloworld_pb2.HelloRequest(name='Pythonista'))
print(response.message)

5. C#: Protobuf Definition

1
2
3
4
5


syntax = "proto3";
message User {
 string username = 1;
 int32 id = 2;
}

6. C#: Server Implementation

1
2
3
4
5


public class GreeterService : Greeter.GreeterBase {
 public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context) {
 return Task.FromResult(new HelloReply { Message = $"Hello {request.Name}" });
 }
}

7. C#: Client Code

1
2
3
4


var channel = GrpcChannel.ForAddress("http://localhost:50051");
var client = new Greeter.GreeterClient(channel);
var reply = client.SayHello(new HelloRequest { Name = "C# Wizard" });
Console.WriteLine(reply.Message);

8. Go: Protobuf Definition

1
2
3
4
5


syntax = "proto3";
message Task {
 string description = 1;
 bool completed = 2;
}

9. Go: Server Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


import (
 "context"
 "fmt"
 "google.golang.org/grpc"
 "net"
)
type server struct{}
func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
 return &pb.HelloReply{Message: "Hello " + in.Name}, nil
}
func main() {
 lis, _ := net.Listen("tcp", ":50051")
 s := grpc.NewServer()
 pb.RegisterGreeterServer(s, &server{})
 s.Serve(lis)
}

10. Go: Client Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


import (
 "context"
 "fmt"
 "google.golang.org/grpc"
 "log"
 "time"
)
func main() {
 conn, _ := grpc.Dial("localhost:50051", grpc.WithInsecure())
 defer conn.Close()
 c := pb.NewGreeterClient(conn)
 ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 defer cancel()
 resp, _ := c.SayHello(ctx, &pb.HelloRequest{Name: "Go Guru"})
 fmt.Println(resp.Message)
}

🔑 Key Ideas

Concept	Explanation
gRPC	Remote Procedure Call framework by Google
Protobuf	Serialization format used by gRPC
HTTP/2	Underlying protocol enabling streaming
Polyglot	Supports multiple programming languages
Efficiency	More efficient than REST with JSON

📚 References

WCF in a Nutshell

Sun, 18 Jun 2017 00:00:00 +0000

WCF in a Nutshell: A Wild Ride Through Windows Communication Foundation

Ah, Windows Communication Foundation (WCF)—the technology that every .NET developer loved, hated, or just Googled whenever they had to work with it.

It’s one of those things that sounded great in theory but often made you question your life choices when debugging cryptic SOAP faults at 3 AM.

A Brief History of WCF

Back in the early 2000s, Microsoft looked at the mess of communication frameworks they had created and thought, “What if we could unify all this chaos?”

At the time, developers were juggling:

ASP.NET Web Services (ASMX) for basic SOAP-based web services.
Remoting for inter-process communication.
Enterprise Services (COM+) for distributed transactions.
MSMQ (Message Queuing) for reliable messaging.
Sockets for custom communication.

Each of these had its own APIs, quirks, and fantastic debugging experiences.
(cough, cough , cough…..)

Enter Windows Communication Foundation (WCF), launched with .NET 3.0 in 2006.

It was marketed as the One Framework to Rule Them All, letting developers use a single API to build services for SOAP, REST, TCP, MSMQ, and everything in between.

It was great! Until it wasn’t.

With the rise of RESTful APIs and the simplicity of ASP.NET Web API, WCF started to feel like a bloated relic. Eventually,

Microsoft moved on, and by .NET Core, WCF was politely left behind like an old Windows XP machine.

How WCF Works (In Plain English)

WCF is all about services and endpoints.

A WCF service is like a restaurant:

Service contract (Menu) – Defines what the service offers.
Binding (How food is served) – Specifies the protocol (HTTP, TCP, named pipes, etc.).
Endpoint (The waiter) – The actual address where requests are sent.

To use a WCF service, you basically:

Define a contract (what the service does).
Implement the contract in a service.
Configure bindings and endpoints (how clients talk to it).
Host it (IIS, a Windows Service, or even a console app).
Clients consume it like a web service or remote API.

It sounds simple, but in reality, the configuration XML files often felt like reading ancient hieroglyphs.

Writing a Basic WCF Service

Alright, let’s actually write some WCF code so you can impress your coworkers (or at least pretend to know what you’re doing).

1. Define the Service Contract

First, we create a contract using an interface.

1
2
3
4
5
6


[ServiceContract]
public interface IHelloService
{
 [OperationContract]
 string SayHello(string name);
}

That [ServiceContract] tells WCF that this interface is a service, and [OperationContract] marks methods that clients can call.

2. Implement the Service

1
2
3
4
5
6
7


public class HelloService : IHelloService
{
 public string SayHello(string name)
 {
 return $"Hello, {name}! Welcome to the world of WCF!";
 }
}

Nice and simple.

3. Configure the Service in `Web.config`

Now comes the fun part—configuration.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


<configuration>
 <system.serviceModel>
 <services>
 <service name="HelloService">
 <endpoint address=""
 binding="basicHttpBinding"
 contract="IHelloService" />
 </service>
 </services>
 </system.serviceModel>
</configuration>

This tells WCF to expose our service over HTTP using BasicHttpBinding, which is perfect if you want SOAP-based communication.

4. Hosting the Service

WCF services can be hosted in IIS, a Windows Service, or even a Console App.

For quick testing, let’s host it in a simple console application:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class Program
{
 static void Main()
 {
 using (ServiceHost host = new ServiceHost(typeof(HelloService)))
 {
 host.Open();
 Console.WriteLine("HelloService is running...");
 Console.ReadLine();
 }
 }
}

Run this, and boom—your WCF service is live!

5. Consuming the Service

If you want to call this from a client, you can generate a proxy using Add Service Reference in Visual Studio or just use a simple ChannelFactory:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class Client
{
 static void Main()
 {
 ChannelFactory<IHelloService> factory =
 new ChannelFactory<IHelloService>(
 new BasicHttpBinding(),
 new EndpointAddress("http://localhost/HelloService"));

 IHelloService proxy = factory.CreateChannel();
 Console.WriteLine(proxy.SayHello("WCF Developer"));
 }
}

Key Ideas

Concept	Summary
WCF Origins	Microsoft created WCF to unify multiple communication frameworks into one.
Core Components	Service contracts, bindings, and endpoints define a WCF service.
Basic Example	A simple `IHelloService` contract, an implementation, and a `basicHttpBinding` configuration.
Hosting Options	Can be hosted in IIS, a Windows Service, or a Console App.
Client Consumption	Use `ChannelFactory` or Visual Studio’s “Add Service Reference.”
Relevance Today	WCF is largely replaced by REST APIs, gRPC, and WebSockets, but it still exists in legacy systems.

Buffer Overrun Attacks and How to Prevent Them

Sun, 10 Oct 2021 00:00:00 +0000

History of Buffer Overrun Attacks and How to Prevent Them in Python, C#, and Go

Ah, buffer overruns—one of the oldest and most infamous programming blunders in the history of software development. If memory bugs had a “Most Wanted” list, buffer overruns would be at the top, right next to null pointer dereferences and accidentally deleting production databases.

What is a Buffer Overrun?

A buffer overrun (or buffer overflow) happens when a program writes more data into a buffer than it can hold.

The excess data then spills over into adjacent memory, leading to corruption, crashes, and—if a hacker is feeling spicy—remote code execution. Sounds bad? It is. Real bad.

This type of vulnerability has been around since the dawn of programming, and it’s responsible for some of the biggest cybersecurity disasters ever.

If you’ve ever wondered why your C program segfaults randomly, you might be looking at a baby buffer overflow.

Wikipedia Buffer Overflow.

A Brief and Ridiculous History of Buffer Overruns

Buffer overruns have been around longer than your average internet meme. Let’s go on a journey through time:

The 1980s: Buffer overruns were just getting started. Early operating systems like UNIX were riddled with these vulnerabilities. Hackers were just beginning to understand how they could exploit them.
The 1990s: The golden era of buffer overflows. Thanks to languages like C and C++, which basically tell programmers, “Do whatever you want, I trust you,” buffer overruns became a hacker’s best friend. The infamous 1988 Morris Worm, one of the first-ever worms, exploited a buffer overflow.
The 2000s: The Internet boom meant more software, more security flaws, and more high-profile attacks. The 2001 Code Red and Nimda worms used buffer overflows to wreak havoc.
The 2010s: Memory-safe languages like Python and Go started gaining popularity, helping prevent buffer overruns. But legacy code in C and C++ continued to haunt the world.
Today: Buffer overruns still exist. Modern tools like AddressSanitizer and memory-safe languages have made them rarer, but in old-school systems, they’re still a problem.

How Buffer Overruns Work (For the Curious and Brave)

Imagine your program is a house, and your buffer is a glass of water. If you pour too much, it overflows onto the floor, ruining your carpet. In computing, that “spilled water” is extra data overwriting whatever is next in memory.

In C, this happens easily:

1
2
3
4
5
6
7
8
9


#include <stdio.h>
#include <string.h>

int main() {
 char buffer[10];
 strcpy(buffer, "This string is way too long!");
 printf("Buffer: %s\n", buffer);
 return 0;
}

Oops. strcpy doesn’t care if the string fits. It just pours in all the data, even if it floods everything in its path.

SO what ? IT ran over the buffer.. big deal or no?

Imagine that I put some chars in a string that overrun a buffer on a webserver… And those chars.. the bytes of them , will be interpreted as Assembly language.

Finding and leveraging these exploits was alot of work. But it paid off for the hacker because they can literally deliver executable assembly languge directly into someone elses sevrer. .

Usually that code would try to do something like make an admin account with a password the hacker knew.. Once the hacker could get “in” to the system with admin rights, thats where they could cause the real damage..

In the 2000s, (and still now - but systems were more vulnerable then ). Hackers would write scripts to automatically go out and “own” a bunch of servers.. and then install software on the server to sit and wait for instructions.

Then if the hacked wanted to Denial of Service attack someone, he would send instructions to his compromised systems telling them to attack.

All of sudden your grandmother’s computer in the den is visciously attacking amazon.com…

Preventing Buffer Overruns in Python, C#, and Go

Python: The Chill, Memory-Safe Language

Python is mostly immune to buffer overruns because it manages memory automatically. You don’t manually allocate memory for strings or arrays; Python just handles it. But beware—Python code that interfaces with C (like using ctypes) can still be vulnerable.

If you’re using C extensions or ctypes, always check buffer sizes before copying data.

1
2
3
4
5


import ctypes

buffer = ctypes.create_string_buffer(10)
# Safe: Limiting string length
ctypes.memmove(buffer, b"Hello", 5)

C#: The Managed Middle Ground

C# runs on the .NET runtime, which means memory management is mostly handled for you. But, if you decide to go full metal and use unsafe code, you’re asking for trouble.

1
2
3
4
5
6
7


unsafe {
 char* buffer = stackalloc char[10];
 for (int i = 0; i < 15; i++) // Whoops, buffer is only 10!
 {
 buffer[i] = 'A';
 }
}

Prevention tips:

Stick to managed memory whenever possible.
If you must use unsafe code, use Span or SafeHandle for safety.

Go: The Modern Memory-Safe Champion

Go has built-in memory safety features, so buffer overflows are rare. However, if you’re using cgo (calling C code), you can still fall into this trap.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

/*
#include <string.h>
#include <stdio.h>
*/
import "C"
import "unsafe"

func main() {
 buffer := make([]byte, 10)
 str := "This is too long!"

 C.strcpy((*C.char)(unsafe.Pointer(&buffer[0])), C.CString(str)) // Danger!
}

Prevention tips:

Avoid unsafe.Pointer unless absolutely necessary.
Use Go’s built-in slices and copy functions instead of C functions like strcpy.

Conclusion: Stay Safe, Code Smart

Buffer overruns have a long history of causing chaos, but modern programming languages and tools make them easier to prevent. If you’re writing in Python, C#, or Go, you’re already in a better spot than old-school C programmers. But if you’re working with legacy C or C++ code, always be mindful of memory safety!

Key Ideas Table

Concept	Explanation
Buffer Overrun	When data overflows a buffer, overwriting adjacent memory.
Memory Safety	Ensuring a program does not accidentally access memory incorrectly.
Python	Memory-safe but can still have issues when interfacing with C.
C#	Managed memory but can still have unsafe operations.
Go	Strong memory safety unless using `unsafe.Pointer`.

References

Testing C# and Python with Behavior-Driven Development (BDD)

Sat, 22 Jun 2019 00:00:00 +0000

This is the C# and Python Version of this Article

The Angular and React Version of this Article is here:
Testing Angular and React with Behavior-Driven Development (BDD)

Also check out

All Testing Articles here:
https://brianbraatz.github.io/search/?keyword=testing

A Brief History of BDD

Once upon a time, in the dark ages of software development (a.k.a the early 2000s), developers and testers were at war.
Developers wrote code that they thought made sense, while testers wrote test cases that developers barely understood. Chaos ensued.

Then, in 2003, Dan North had a revelation: “What if developers and testers spoke the same language?” And thus, Behavior-Driven Development (BDD) was born.

BDD took inspiration from Test-Driven Development (TDD) but aimed to make tests more human-readable, so that business people, testers, and developers could all be on the same page. Instead of cryptic unit test names, BDD focused on describing behavior in plain English using a structured format called Gherkin (yep, like the pickle).

The idea? Tests should be human-readable and describe what the system actually does. That way, even non-tech people (gasp!) could understand what was going on. So instead of writing a test that checks if 2 + 2 === 4, you’d write:

1
2
3
4


Scenario: Adding two numbers
 Given I have a calculator
 When I add 2 and 2
 Then the result should be 4

Now the Non-Engineers and the Engineers have a common way to communicate features and how to test them .

And this plain language, can be used directly- or semi-directly to actually “be” the test!

How Does BDD Compare to Other Testing Approaches?

Approach	What It Focuses On	Pros	Cons
TDD	Writing tests before code	Ensures code correctness	Harder for non-devs to understand
BDD	Defining behavior in human-readable scenarios	Improves collaboration	More setup required
Unit Testing	Testing small, isolated pieces of code	Fast feedback loop	Doesn’t test full behavior
Integration Testing	Ensuring multiple components work together	Catches system-wide issues	Slower and more complex

BDD is like TDD’s more extroverted cousin—it wants everyone involved, not just developers.

How to Do BDD: The Gherkin Language

As introduced above, BDD scenarios are written in Gherkin, a simple syntax that follows a Given-When-Then structure:

1
2
3
4


Feature: Login System
 Scenario: Successful Login
 Given a registered user "Alice"\ When they enter valid credentials
 Then they should see the dashboard

Readable, right? Even your non-technical boss can understand that.

Now, let’s implement this in C# and Python!

BDD Example in C# (Using SpecFlow)

Step 1: Install SpecFlow via NuGet:

1

Install-Package SpecFlow

Step 2: Write a Gherkin feature file (Login.feature):

1
2
3
4
5


Feature: Login System
 Scenario: Successful Login
 Given a registered user "Alice"
 When they enter valid credentials
 Then they should see the dashboard

Step 3: Implement step definitions in C#:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


[Binding]
public class LoginSteps
{
 private string _username;
 private bool _isLoggedIn;

 [Given("a registered user \"(.*)\"")]
 public void GivenARegisteredUser(string username)
 {
 _username = username;
 }

 [When("they enter valid credentials")]
 public void WhenTheyEnterValidCredentials()
 {
 _isLoggedIn = (_username == "Alice");
 }

 [Then("they should see the dashboard")]
 public void ThenTheyShouldSeeTheDashboard()
 {
 Assert.IsTrue(_isLoggedIn);
 }
}

BDD Example in Python (Using Behave)

Step 1: Install Behave:

1

pip install behave

Step 2: Write a Gherkin feature file (login.feature):

1
2
3
4
5


Feature: Login System
 Scenario: Successful Login
 Given a registered user "Alice"
 When they enter valid credentials
 Then they should see the dashboard

Step 3: Implement step definitions in Python (steps/login_steps.py):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


from behave import given, when, then

users = {"Alice": "password123"}

@given('a registered user "{username}"')
def step_given_registered_user(context, username):
 context.username = username

@when("they enter valid credentials")
def step_when_enter_credentials(context):
 context.is_logged_in = context.username in users

@then("they should see the dashboard")
def step_then_see_dashboard(context):
 assert context.is_logged_in

BDD Tools by Language

Language	Popular BDD Tools
C#	SpecFlow, xBehave.NET
Python	Behave, pytest-bdd
Java	Cucumber, JBehave
JavaScript/TypeScript	Cucumber.js, Jest with Gherkin
Ruby	Cucumber

Yes, you CAN test JavaScript and TypeScript with BDD! Cucumber.js lets you write tests in Gherkin just like in Python or C#.

Key Ideas

Concept	Description
BDD Origin	Created by Dan North in 2003 to improve collaboration
Gherkin	A human-readable language for writing test scenarios
C# BDD	Uses SpecFlow for Gherkin-based tests
Python BDD	Uses Behave to implement Gherkin tests
Tools	SpecFlow, Behave, Cucumber, and more
JS/TS Support	Yes! Cucumber.js makes it possible

References

gRPC can you use it without Protobuf?

Sun, 14 Aug 2022 00:00:00 +0000

🕰️ A Brief History (Because All Good Stories Need One)

Back in 2015, Google launched gRPC to let services communicate easily over the web. It uses HTTP/2 for faster and more reliable connections and Protobuf for efficient, binary serialization. More on this here.

But what if you don’t want Protobuf? Enter gRPC with alternative serialization….

🤔 Why Protobuf vs Without Protobuf?

Feature	With Protobuf	Without Protobuf
Performance	Blazing fast ⚡️	Slower (e.g., JSON serialization)
Type Safety	Strong typing with schemas	Loose typing, more errors
Interoperability	Cross-language compatible	Language-specific quirks

This article is mostly for Fun and Learning..

There is likely not a good reason to use JSON.. but you CAN! And thats the point..

🛠️ Let’s Get to the Code!

1. Python: Protobuf gRPC Server

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


import grpc
from concurrent import futures
import example_pb2
import example_pb2_grpc

class Greeter(example_pb2_grpc.GreeterServicer):
 def SayHello(self, request, context):
 return example_pb2.HelloReply(message=f"Hello, {request.name}!")

def serve():
 server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
 example_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
 server.add_insecure_port('[::]:50051')
 server.start()
 server.wait_for_termination()

serve()

2. Python: Protobuf gRPC Client

1
2
3
4
5
6
7
8


import grpc
import example_pb2
import example_pb2_grpc

channel = grpc.insecure_channel('localhost:50051')
stub = example_pb2_grpc.GreeterStub(channel)
response = stub.SayHello(example_pb2.HelloRequest(name="Pythonista"))
print(response.message)

3. Python: gRPC with JSON

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


import grpc
import json
from concurrent import futures
from grpc.experimental import json_format

class GreeterService:
 def SayHello(self, request, context):
 data = json.loads(request.data)
 return json_format.MessageToJson({"message": f"Hello, {data['name']}!"})

def serve():
 server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
 server.add_insecure_port('[::]:50051')
 server.start()
 server.wait_for_termination()

serve()

4. C#: Protobuf gRPC Server

1
2
3
4
5
6
7


public class GreeterService : Greeter.GreeterBase
{
 public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context)
 {
 return Task.FromResult(new HelloReply { Message = $"Hello, {request.Name}!" });
 }
}

5. C#: Protobuf gRPC Client

1
2
3
4


var channel = GrpcChannel.ForAddress("http://localhost:50051");
var client = new Greeter.GreeterClient(channel);
var response = client.SayHello(new HelloRequest { Name = "C# Guru" });
Console.WriteLine(response.Message);

6. C#: gRPC with JSON

1
2
3
4
5


HttpClient client = new HttpClient();
var content = new StringContent("{\"name\":\"C# Guru\"}", Encoding.UTF8, "application/json");
var response = await client.PostAsync("http://localhost:50051/greet", content);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);

7. Go: Protobuf gRPC Server

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package main

import (
 "context"
 "fmt"
 "google.golang.org/grpc"
 "net"
 pb "example"
)

type server struct{}

func (s *server) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
 return &pb.HelloReply{Message: "Hello, " + req.Name + "!"}, nil
}

func main() {
 lis, _ := net.Listen("tcp", ":50051")
 s := grpc.NewServer()
 pb.RegisterGreeterServer(s, &server{})
 s.Serve(lis)
}

8. Go: Protobuf gRPC Client

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package main

import (
 "context"
 "fmt"
 "google.golang.org/grpc"
 pb "example"
)

func main() {
 conn, _ := grpc.Dial("localhost:50051", grpc.WithInsecure())
 defer conn.Close()
 c := pb.NewGreeterClient(conn)
 resp, _ := c.SayHello(context.Background(), &pb.HelloRequest{Name: "Go Dev"})
 fmt.Println(resp.Message)
}

9. Go: gRPC with JSON

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package main

import (
 "bytes"
 "fmt"
 "net/http"
)

func main() {
 data := `{"name":"Go Dev"}`
 resp, _ := http.Post("http://localhost:50051/greet", "application/json", bytes.NewBuffer([]byte(data)))
 defer resp.Body.Close()
 body, _ := io.ReadAll(resp.Body)
 fmt.Println(string(body))
}

10. Protobuf Definition (Proto3)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


syntax = "proto3";
service Greeter {
 rpc SayHello (HelloRequest) returns (HelloReply);
}
message HelloRequest {
 string name = 1;
}
message HelloReply {
 string message = 1;
}

🔑 Key Ideas

Concept	Explanation
gRPC	RPC framework using HTTP/2 & Protobuf
Protobuf	Binary serialization for performance
JSON in gRPC	Alternative to Protobuf for flexibility
Cross-platform	Works across multiple languages

📚 References

Finite State Machines-FSM Explained

Sun, 30 Oct 2022 00:00:00 +0000

Finite State Machines, History, Understanding How They Work, and Code Examples in Go, Python, C#, and C++

A Brief History of FSMs

Finite state machines have been around longer than your grandpa’s first calculator. The concept was formalized by Warren McCulloch and Walter Pitts in 1943 when they described neural networks using logic gates. Later, the idea of state machines was expanded by John Myhill and Raymond Moore, leading to what we now call Mealy and Moore Machines.

Smart people figured out that a system could have different states and transition between them based on inputs. And here we are, still using that idea to control robots, games, and—most importantly—vending machines.

Understanding How FSMs Work

An FSM consists of:

States: The different conditions a system can be in.
Transitions: Rules for moving from one state to another.
Inputs: Events that trigger transitions.
Outputs: Actions performed when entering, exiting, or being in a state.

Imagine a turnstile at a subway station:

Locked state: If you insert a coin, it transitions to Unlocked.
Unlocked state: If you push, it transitions back to Locked.

Boom! That’s a finite state machine. Simple, right? Now let’s look at some code!

Code Examples

Go Implementation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


package main

import (
 "fmt"
)

type State string

const (
 Locked State = "Locked"
 Unlocked State = "Unlocked"
)

type Turnstile struct {
 state State
}

func (t *Turnstile) InsertCoin() {
 if t.state == Locked {
 fmt.Println("Coin inserted. Unlocking...")
 t.state = Unlocked
 } else {
 fmt.Println("Already unlocked! Just push!")
 }
}

func (t *Turnstile) Push() {
 if t.state == Unlocked {
 fmt.Println("Pushed. Locking...")
 t.state = Locked
 } else {
 fmt.Println("It's locked! Insert a coin first.")
 }
}

func main() {
 t := &Turnstile{state: Locked}
 t.InsertCoin()
 t.Push()
 t.Push()
}

Python Implementation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Turnstile:
 def __init__(self):
 self.state = "Locked"

 def insert_coin(self):
 if self.state == "Locked":
 print("Coin inserted. Unlocking...")
 self.state = "Unlocked"
 else:
 print("Already unlocked! Just push!")

 def push(self):
 if self.state == "Unlocked":
 print("Pushed. Locking...")
 self.state = "Locked"
 else:
 print("It's locked! Insert a coin first.")

# Example usage
t = Turnstile()
t.insert_coin()
t.push()
t.push()

C# Implementation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


using System;

class Turnstile
{
 private string state = "Locked";

 public void InsertCoin()
 {
 if (state == "Locked")
 {
 Console.WriteLine("Coin inserted. Unlocking...");
 state = "Unlocked";
 }
 else
 {
 Console.WriteLine("Already unlocked! Just push!");
 }
 }

 public void Push()
 {
 if (state == "Unlocked")
 {
 Console.WriteLine("Pushed. Locking...");
 state = "Locked";
 }
 else
 {
 Console.WriteLine("It's locked! Insert a coin first.");
 }
 }
}

class Program
{
 static void Main()
 {
 Turnstile t = new Turnstile();
 t.InsertCoin();
 t.Push();
 t.Push();
 }
}

C++ Implementation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


#include <iostream>
#include <string>

class Turnstile {
private:
 std::string state = "Locked";

public:
 void insertCoin() {
 if (state == "Locked") {
 std::cout << "Coin inserted. Unlocking..." << std::endl;
 state = "Unlocked";
 } else {
 std::cout << "Already unlocked! Just push!" << std::endl;
 }
 }

 void push() {
 if (state == "Unlocked") {
 std::cout << "Pushed. Locking..." << std::endl;
 state = "Locked";
 } else {
 std::cout << "It's locked! Insert a coin first." << std::endl;
 }
 }
};

int main() {
 Turnstile t;
 t.insertCoin();
 t.push();
 t.push();
 return 0;
}

Conclusion

Finite state machines are incredibly useful and appear in more places than you might think. Whether it’s controlling UI flows, video game characters, or vending machines (the true MVPs of life), FSMs keep things organized and predictable.

So go forth and implement FSMs in your projects! And if nothing else, you can now impress your friends by explaining why the turnstile at the subway works the way it does.

Ideas for Further Exploration

Implement FSMs for a simple game AI.
Use FSMs in a web application to handle user states.
Simulate a real-world vending machine with an FSM.
Implement a state machine in Rust or Java.

References

Hierarchical State Machines-HSM, Explained

Mon, 20 May 2019 00:00:00 +0000

A Brief History of Hierarchical State Machines

Finite State Machines (FSMs) are great and all, but they can become a spaghetti mess when dealing with complex systems. This led to the evolution of FSMs into hierarchical state machines (HSMs), which were formalized in the 1980s by David Harel.

His work introduced Statecharts, which allowed states to have substates—kind of like folders within folders. This reduced duplication and made systems more manageable.

How Hierarchical State Machines Work

An HSM is an FSM but with superpowers. Instead of having a flat list of states, HSMs group states into parent-child relationships.

Example:

Car State Machine
- Moving State
  - Accelerating
  - Cruising
  - Braking
- Stopped State
  - Engine Off
  - Engine On

If you’re in “Braking,” you’re also in “Moving.” If you transition to “Engine Off,” you also transition out of “Moving.”

This reduces redundancy since common behaviors can be inherited.

FSM vs. HSM: The Showdown

Feature	Finite State Machine (FSM)	Hierarchical State Machine (HSM)
Structure	Flat	Nested
Complexity	Grows exponentially	More manageable
Code Duplication	High	Low
Readability	Messy for large systems	Cleaner
Use Case	Simple workflows	Complex systems like robotics

Code Examples

Go Implementation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


package main

import (
 "fmt"
)

type State string

const (
 StoppedEngineOff State = "Stopped.EngineOff"
 StoppedEngineOn State = "Stopped.EngineOn"
 MovingCruising State = "Moving.Cruising"
)

type CarStateMachine struct {
 state State
}

func (c *CarStateMachine) TurnOnEngine() {
 if c.state == StoppedEngineOff {
 fmt.Println("Engine started!")
 c.state = StoppedEngineOn
 } else {
 fmt.Println("Engine is already on!")
 }
}

func (c *CarStateMachine) StartMoving() {
 if c.state == StoppedEngineOn {
 fmt.Println("Car is now moving!")
 c.state = MovingCruising
 } else {
 fmt.Println("Can't move unless the engine is on!")
 }
}

func (c *CarStateMachine) Brake() {
 if c.state == MovingCruising {
 fmt.Println("Braking...")
 c.state = StoppedEngineOn
 } else {
 fmt.Println("You're already stopped!")
 }
}

func main() {
 car := &CarStateMachine{state: StoppedEngineOff}
 car.TurnOnEngine()
 car.StartMoving()
 car.Brake()
}

Python Implementation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


class CarStateMachine:
 def __init__(self):
 self.state = "Stopped.EngineOff"

 def turn_on_engine(self):
 if self.state == "Stopped.EngineOff":
 print("Engine started!")
 self.state = "Stopped.EngineOn"
 else:
 print("Engine is already on!")

 def start_moving(self):
 if self.state == "Stopped.EngineOn":
 print("Car is now moving!")
 self.state = "Moving.Cruising"
 else:
 print("Can't move unless the engine is on!")

 def brake(self):
 if self.state == "Moving.Cruising":
 print("Braking...")
 self.state = "Stopped.EngineOn"
 else:
 print("You're already stopped!")

# Example usage
car = CarStateMachine()
car.turn_on_engine()
car.start_moving()
car.brake()

C# Implementation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


using System;

class CarStateMachine
{
 private string state = "Stopped.EngineOff";

 public void TurnOnEngine()
 {
 if (state == "Stopped.EngineOff")
 {
 Console.WriteLine("Engine started!");
 state = "Stopped.EngineOn";
 }
 else
 {
 Console.WriteLine("Engine is already on!");
 }
 }

 public void StartMoving()
 {
 if (state == "Stopped.EngineOn")
 {
 Console.WriteLine("Car is now moving!");
 state = "Moving.Cruising";
 }
 else
 {
 Console.WriteLine("Can't move unless the engine is on!");
 }
 }

 public void Brake()
 {
 if (state == "Moving.Cruising")
 {
 Console.WriteLine("Braking...");
 state = "Stopped.EngineOn";
 }
 else
 {
 Console.WriteLine("You're already stopped!");
 }
 }
}

class Program
{
 static void Main()
 {
 CarStateMachine car = new CarStateMachine();
 car.TurnOnEngine();
 car.StartMoving();
 car.Brake();
 }
}

C++ Implementation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


#include <iostream>
#include <string>

class CarStateMachine {
private:
 std::string state = "Stopped.EngineOff";

public:
 void turnOnEngine() {
 if (state == "Stopped.EngineOff") {
 std::cout << "Engine started!" << std::endl;
 state = "Stopped.EngineOn";
 } else {
 std::cout << "Engine is already on!" << std::endl;
 }
 }

 void startMoving() {
 if (state == "Stopped.EngineOn") {
 std::cout << "Car is now moving!" << std::endl;
 state = "Moving.Cruising";
 } else {
 std::cout << "Can't move unless the engine is on!" << std::endl;
 }
 }

 void brake() {
 if (state == "Moving.Cruising") {
 std::cout << "Braking..." << std::endl;
 state = "Stopped.EngineOn";
 } else {
 std::cout << "You're already stopped!" << std::endl;
 }
 }
};

int main() {
 CarStateMachine car;
 car.turnOnEngine();
 car.startMoving();
 car.brake();
 return 0;
}

Conclusion

Hierarchical State Machines are better-organized versions of FSMs. They help prevent duplicate logic, make complex systems manageable, and are used in robotics, games, and UI frameworks.

If FSMs were basic notes, HSMs would be well-organized notebooks.

Now, go forth and use HSMs in your projects!

Ideas for Further Exploration

Implement HSMs for robot navigation.
Use HSMs in video game AI.
Apply HSMs in UI workflows.
Implement a hierarchical vending machine.

References

LINQPad in a Nutshell

Sat, 15 Apr 2017 00:00:00 +0000

LINQPad in a Nutshell

A Little History

Once upon a time (2007, to be exact), a hero named Joe Albahari looked at the world of .NET development and thought, Why is running a simple LINQ query harder than it needs to be? And so, LINQPad was born.

Initially, it was just a handy way to test LINQ queries. But over time, it evolved into a full-fledged C# scratchpad, supporting LINQ, SQL, and even full-blown C# programs. Think of it as Notepad for .NET—except way cooler and significantly more useful.

Why Should You Care?

Because LINQPad is awesome. It lets you:

Write and test LINQ queries instantly.
Query databases without setting up a massive project.
Execute C# code on the fly.
Explore and interact with your EF Core or SQL databases like a boss.
Use Dump() to output results in a way that actually makes sense.

And the best part? No need to open Visual Studio and wait while your coffee gets cold.

Getting Started with LINQPad

Download LINQPad from linqpad.net.
Install it (this part is surprisingly easy).
Open it and start writing queries.

Boom! You’re now 10x more productive than you were five minutes ago.

Code Examples

1. Running a Simple LINQ Query

1
2
3
4
5
6


void Main()
{
 var numbers = Enumerable.Range(1, 10);
 var evens = numbers.Where(n => n % 2 == 0);
 evens.Dump(); // LINQPad's magic output method
}

2. Querying a Database

1
2
3
4
5


void Main()
{
 var db = new Query("SELECT * FROM Customers");
 db.Dump();
}

3. Writing a Quick C# Script

1
2
3
4
5


void Main()
{
 Console.WriteLine("Hello, LINQPad!");
 "Hello, LINQPad!".Dump(); // The LINQPad way
}

4. Using Entity Framework Core

1
2
3
4
5
6


void Main()
{
 var ctx = new MyDbContext();
 var users = ctx.Users.Where(u => u.IsActive).ToList();
 users.Dump();
}

Why Dump() is Life-Changing

Forget Console.WriteLine(). LINQPad’s Dump() method is what every C# developer has dreamed of. It takes any object and displays it in a beautifully formatted way—tables, graphs, JSON, whatever makes sense.

The Paid Version: Is It Worth It?

LINQPad comes in a free version that does almost everything you need. But if you want auto-completion and advanced features, the paid version is a no-brainer. Seriously, if you use LINQPad regularly, just buy it. Joe Albahari deserves a coffee.

Key Ideas

Topic	Summary
History	Created by Joe Albahari in 2007 to simplify LINQ queries.
Features	Supports LINQ, SQL, C# scripting, and EF Core.
Benefits	No need for Visual Studio; quick and easy testing of queries.
Code Examples	Demonstrates LINQ queries, database interaction, and scripting.
Dump()	The magical method that makes debugging easy.

References

SOLID in a Nutshell

Sat, 14 Sep 2013 00:00:00 +0000

SOLID in a Nutshell: A Fun Dive into Clean Code

If you’ve ever looked at your own code a month after writing it and thought, Who wrote this mess?, then buddy, you might need some SOLID principles in your life.

The SOLID Principles

Each letter in SOLID stands for a design principle.

1. Single Responsibility Principle (SRP)

A class should have only one reason to change.

Think of it this way: You wouldn’t want your toaster to also wash your dishes. (Although that would be amazing.)

Bad Example (C++):

1
2
3
4
5
6
7
8
9


class Report {
public:
 void generateReport() {
 // Generates the report
 }
 void saveToFile() {
 // Saves the report to a file
 }
};

Why is this bad? Because generating and saving are two different responsibilities.

Good Example (C++):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class ReportGenerator {
public:
 void generateReport() {
 // Generates the report
 }
};

class ReportSaver {
public:
 void saveToFile(ReportGenerator& report) {
 // Saves report
 }
};

Boom! Separation of concerns.

2. Open/Closed Principle (OCP)

A class should be open for extension, but closed for modification.

Imagine if every time you wanted to add a new feature to your game, you had to rewrite the whole game. That would be awful.

Bad Example (C#):

1
2
3
4
5
6
7


class DiscountService {
 public double ApplyDiscount(double price, string discountType) {
 if (discountType == "Christmas") return price * 0.9;
 if (discountType == "BlackFriday") return price * 0.8;
 return price;
 }
}

Every time we need a new discount, we have to change the method. Bad!

Good Example (C#):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


interface IDiscount {
 double Apply(double price);
}

class ChristmasDiscount : IDiscount {
 public double Apply(double price) => price * 0.9;
}

class BlackFridayDiscount : IDiscount {
 public double Apply(double price) => price * 0.8;
}

class DiscountService {
 public double ApplyDiscount(double price, IDiscount discount) => discount.Apply(price);
}

Now we can add new discounts without modifying existing code. Win!

3. Liskov Substitution Principle (LSP)

If a class is a subclass of another, it should be able to replace it without causing issues.

Basically, if it looks like a duck, quacks like a duck, and doesn’t break the program when used as a duck, it’s good.

Bad Example (Python):

1
2
3
4
5
6
7


class Bird:
 def fly(self):
 print("Flap flap")

class Ostrich(Bird):
 def fly(self):
 raise Exception("Ostriches can't fly!")

An Ostrich should be a Bird, but it breaks the expectations. Not good!

Good Example (Python):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class Bird:
 pass

class FlyingBird(Bird):
 def fly(self):
 print("Flap flap")

class Ostrich(Bird):
 def run(self):
 print("Running fast!")

Now we separate flying birds and non-flying birds. Problem solved!

4. Interface Segregation Principle (ISP)

Don’t force classes to implement methods they don’t need.

If your fridge also required a MakeCoffee() method because of a general Appliance interface, you’d be in trouble.

Bad Example (C++):

1
2
3
4
5


class Worker {
public:
 virtual void code() = 0;
 virtual void manage() = 0;
};

A Manager shouldn’t have to implement code(). Not everyone codes!

Good Example (C++):

1
2
3
4
5
6
7
8
9


class Coder {
public:
 virtual void code() = 0;
};

class Manager {
public:
 virtual void manage() = 0;
};

Now we have separate concerns.

5. Dependency Inversion Principle (DIP)

High-level modules should not depend on low-level modules. Both should depend on abstractions.

Bad Example (C#):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class SQLDatabase {
 public void Save(string data) { /* Save to database */ }
}

class DataManager {
 private SQLDatabase db = new SQLDatabase();
 public void SaveData(string data) {
 db.Save(data);
 }
}

If we change databases, we need to rewrite DataManager. Yikes!

Good Example (C#):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


interface IDatabase {
 void Save(string data);
}

class SQLDatabase : IDatabase {
 public void Save(string data) { /* Save to database */ }
}

class DataManager {
 private IDatabase db;
 public DataManager(IDatabase database) {
 db = database;
 }
 public void SaveData(string data) {
 db.Save(data);
 }
}

Now we can switch databases easily.

Comparison Table

Principle	C++	C#	Python
SRP	✅	✅	✅
OCP	✅	✅	✅
LSP	✅	✅	✅
ISP	✅	✅	✅
DIP	✅	✅	✅

Key Ideas

Concept	Summary
SOLID	Five principles for maintainable code
SRP	One class, one job
OCP	Extend, don’t modify
LSP	Subclasses should behave like their parent class
ISP	Interfaces should be small and specific
DIP	Depend on abstractions, not concrete implementations

References

SpecFlow and Gherkin in a Nutshell

Mon, 12 Sep 2016 00:00:00 +0000

WESTMONT PICKLES

A Little History

Before SpecFlow and Gherkin showed up to the testing party, most of us were writing unit tests in pure code.

This was fine… if you enjoyed deciphering cryptic test methods and assertions that read like ancient spells.

Enter Behavior-Driven Development (BDD)—a methodology that encourages writing tests in plain English (or whatever human language you prefer).

This makes it easier for developers, testers, and business folks to be on the same page.

Gherkin is the structured language used to describe these tests.

SpecFlow is a C# implementation of BDD, using Gherkin to define test cases in a way that mere mortals can understand.

How Gherkin Works (It’s Not a Pickle, I Swear)

Gherkin follows a simple structure:

Feature: Describes the functionality you’re testing
Scenario: A specific example of the feature in action
Given: The preconditions
When: The action
Then: The expected outcome

1
2
3
4
5
6
7


Feature: User Login

Scenario: Valid Login
 Given the user enters "admin" as the username
 And the user enters "password123" as the password
 When the user clicks the login button
 Then the user should be redirected to the dashboard

See? It’s like writing a user story instead of a test case. Even your manager can understand it (well, maybe). 😆

How SpecFlow Turns Gherkin Into Automation Magic ✨

SpecFlow takes the Gherkin scenario and maps it to actual C# test code.

Here’s how you’d implement the above scenario in SpecFlow:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


[Binding]
public class LoginSteps
{
 private readonly LoginPage _loginPage = new LoginPage();

 [Given("the user enters \"(.*)\" as the username")]
 public void GivenUserEntersUsername(string username)
 {
 _loginPage.EnterUsername(username);
 }

 [Given("the user enters \"(.*)\" as the password")]
 public void GivenUserEntersPassword(string password)
 {
 _loginPage.EnterPassword(password);
 }

 [When("the user clicks the login button")]
 public void WhenUserClicksLogin()
 {
 _loginPage.ClickLogin();
 }

 [Then("the user should be redirected to the dashboard")]
 public void ThenUserSeesDashboard()
 {
 Assert.IsTrue(_loginPage.IsOnDashboard());
 }
}

The magic here is [Binding], which tells SpecFlow that this class contains the step definitions for your tests.

How It’s Different from Normal Unit Testing

Feature	Unit Testing	SpecFlow/Gherkin (BDD)
Readability	Code-heavy, requires dev knowledge	Plain English, anyone can read
Collaboration	Mostly developers	Testers, BAs, and even managers can contribute
Structure	Independent test methods	Scenarios that describe real-world behavior
Reusability	Can be repetitive	Steps can be reused across multiple tests

Unit tests are great for checking the nitty-gritty details of individual components, but SpecFlow & Gherkin shine when you want to describe user behavior and ensure everything works end-to-end.

Why Should You Care?

Less Confusion, More Clarity – Everyone can read and understand tests.
Better Collaboration – No need to explain test cases to non-techies.
Reusable Steps – You don’t have to rewrite similar tests over and over.
Documentation as Code – Your test cases double as living documentation.
It’s Just Cool – I mean, wouldn’t you rather write tests like a story instead of debugging fragile unit tests?

Key Ideas

Concept	Summary
SpecFlow	A C# framework for BDD, using Gherkin for test scenarios
Gherkin	A simple, human-readable language for writing test cases
Feature Files	Contain test scenarios written in Gherkin syntax
Step Definitions	C# methods that automate the steps in a scenario
BDD vs Unit Tests	BDD focuses on behavior, Unit Tests focus on code logic

References

PLINQ in a Nutshell

Tue, 21 Mar 2017 00:00:00 +0000

PLINQ in a Nutshell

Alright, let’s talk about PLINQ—Parallel Language-Integrated Query. It’s a cool thing in C# that allows us to run LINQ queries in parallel. If you’re tired of waiting for your queries to finish like they’re stuck in traffic, PLINQ’s here to help you speed things up.

What is PLINQ?

In case you haven’t met LINQ yet (and if you haven’t, I’m judging you), it’s the sweet syntax in C# that lets you run queries on arrays, lists, or any collection. Now, PLINQ takes LINQ and injects some parallelism into it.

It splits your queries into chunks and executes them on multiple threads. Imagine having a whole team of developers working on different parts of the project at the same time instead of just one poor soul doing everything. It’s like the Avengers, but for your code.

Why Should You Care?

Because performance! PLINQ can speed up queries, especially when you’re dealing with large datasets. For example, if you’re doing some heavy lifting with a huge list of objects, PLINQ can break the work into smaller tasks, run them simultaneously, and give you the result faster than you can say “concurrency issues.”

But, let’s get real—PLINQ isn’t magic. It won’t always make your code faster, and it’s definitely not a one-size-fits-all solution. Like any superhero, you’ve got to use it wisely.

How Does It Work?

You use PLINQ just like regular LINQ but with a simple .AsParallel() method. Here’s a quick example:

1
2
3
4


var numbers = Enumerable.Range(1, 1000000);
var result = numbers.AsParallel()
 .Where(n => n % 2 == 0)
 .ToList();

See that .AsParallel()? That’s the magic wand that tells PLINQ to work its parallelism charm. Behind the scenes, PLINQ breaks the collection into parts, processes them at the same time, and then combines the results.

Where Does PLINQ Shine?

PLINQ is most effective when your tasks are:

CPU-bound: If your query requires heavy computation, PLINQ can definitely help.
Independent: Each part of the query must be independent of others. If tasks rely on each other, PLINQ won’t be able to parallelize them efficiently.

For example, if you’re processing a collection of customer records and each record requires independent calculations, PLINQ can break that down across multiple threads.

But if you’re doing something like sorting or grouping data, PLINQ might make things more complicated and slower, so be careful.

When Should You Avoid PLINQ?

Sometimes, parallelism can add unnecessary complexity, and sometimes you’ll end up with a slower performance than just sticking with regular LINQ. The overhead of managing multiple threads can outweigh the benefits.

Also, PLINQ doesn’t always play nice with things like stateful operations (where the result of one task affects the next). You’ll want to avoid using PLINQ when your code has a lot of interdependent operations.

A Quick Example to Show Off

Let’s say you’ve got a collection of integers, and you want to square each one and then add them up. Here’s what it would look like with regular LINQ vs. PLINQ:

Regular LINQ:

1
2
3


var numbers = Enumerable.Range(1, 1000000);
var sum = numbers.Select(n => n * n).Sum();
Console.WriteLine(sum);

PLINQ:

1
2
3
4
5


var numbers = Enumerable.Range(1, 1000000);
var sum = numbers.AsParallel()
 .Select(n => n * n)
 .Sum();
Console.WriteLine(sum);

Notice how you just toss .AsParallel() in there, and suddenly it’s working in parallel. Pretty slick, huh?

Potential Pitfalls

Overhead: The task of managing threads can take more time than just doing it sequentially for smaller collections. So don’t use PLINQ for tiny datasets; it’s overkill.
Exceptions: Handling exceptions in parallel execution can get tricky. Each thread operates independently, so if one of them throws an exception, it won’t automatically bubble up to the main thread unless you handle it carefully.
Ordering: If you care about the order of your results, you’ll need to use .AsOrdered() to preserve the original order. By default, PLINQ doesn’t guarantee that, so be cautious.

Best Practices

Use PLINQ with large datasets: For big collections, PLINQ can really speed things up.
Monitor Performance: Always benchmark. Just because PLINQ is a “parallel” solution doesn’t mean it’s always the fastest. Test it out and see if it works for your specific scenario.
Thread Safety: Be mindful of shared state between threads. Ensure your code is thread-safe or else you might end up with some really confusing bugs.

Key Ideas

Idea	Description
PLINQ	Parallel version of LINQ
`.AsParallel()`	The magic that makes LINQ parallel
When to use PLINQ	Large datasets, CPU-bound tasks
When to avoid PLINQ	Small datasets, dependent tasks

References

Bluetooth communication- Windows in C++ & C#

Mon, 14 Aug 2017 00:00:00 +0000

Setting Up Bluetooth Communication in C++

Using Windows Sockets for Bluetooth (Winsock)

Microsoft provides the winsock2.h library for Bluetooth communication. Here’s a basic example of how to scan for Bluetooth devices using Winsock in C++:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <winsock2.h>
#include <ws2bth.h>
#include <iostream>

#pragma comment(lib, "Ws2_32.lib")

int main() {
 WSADATA wsaData;
 WSAStartup(MAKEWORD(2, 2), &wsaData);

 SOCKET btSocket = socket(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
 if (btSocket == INVALID_SOCKET) {
 std::cerr << "Failed to create Bluetooth socket!" << std::endl;
 return 1;
 }

 std::cout << "Bluetooth socket created successfully!" << std::endl;
 closesocket(btSocket);
 WSACleanup();
 return 0;
}

This initializes Winsock, creates a Bluetooth socket, and then closes it. Simple, right?

Sending Data Over Bluetooth in C++

Once you’ve found a Bluetooth device, you can connect and send data using connect() and send().

1
2
3


// Assume socket is already created and connected
const char* message = "Hello Bluetooth!";
send(btSocket, message, strlen(message), 0);

That’s all you need for a basic Bluetooth connection in C++! (Except for all the error handling you should be doing. But let’s not kill the vibe.)

The most important thing to rememebr-is this is just like a socket or serial port.

Bluetooth Communication in C#

C# makes Bluetooth development a little easier thanks to the Windows APIs and .NET libraries.

Discovering Bluetooth Devices

Here’s how to list paired Bluetooth devices using C#:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


using System;
using System.Linq;
using Windows.Devices.Enumeration;
using Windows.Devices.Bluetooth;

class Program {
 static async System.Threading.Tasks.Task Main() {
 var devices = await DeviceInformation.FindAllAsync(BluetoothDevice.GetDeviceSelector());
 foreach (var device in devices) {
 Console.WriteLine($"Found: {device.Name}");
 }
 }
}

This snippet scans for Bluetooth devices and prints their names. Short, sweet, and to the point.

Connecting and Sending Data in C#

Let’s send data over Bluetooth using RfcommDeviceService (the C# equivalent of raw socket programming in C++ but without the suffering):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


using System;
using System.Text;
using System.IO;
using Windows.Devices.Bluetooth.Rfcomm;
using Windows.Storage.Streams;

class Program {
 static async System.Threading.Tasks.Task Main() {
 var device = await BluetoothDevice.FromIdAsync("YourDeviceIdHere");
 var service = await device.GetRfcommServicesAsync();
 var stream = service.Services[0].ConnectionHostName;

 using (DataWriter writer = new DataWriter(new MemoryStream().AsOutputStream())) {
 writer.WriteString("Hello, Bluetooth!");
 await writer.StoreAsync();
 }
 }
}

And just like that, we’re talking to Bluetooth devices without diving into raw sockets.

Blazor In a Nutshell

Thu, 14 Nov 2024 00:00:00 +0000

A Brief History of Blazor

Blazor started as an experimental project by Microsoft, and when people saw it actually worked, Microsoft was like, “Well, guess we gotta support this now!” Since then, it has evolved into a full-fledged framework with different hosting models:

Blazor WebAssembly (WASM): Runs completely in the browser using WebAssembly. No need for a server-side connection—just load the app and go!
Blazor Server: Renders everything on the server and sends updates to the client over SignalR. It’s fast and great for real-time apps, but requires a constant connection.
Blazor Hybrid: Use Blazor inside desktop and mobile apps with .NET MAUI or Electron. C# everywhere, baby!

Now that Blazor has matured, let’s look at some of the shiny new features that make it even more awesome.

New Features in Blazor

1. Blazor United (Blazor Server + WASM = ❤️)

One of the biggest new features in Blazor is Blazor United, which allows developers to mix and match Blazor Server and Blazor WASM in the same app.

Want some components to load instantly using Blazor Server but others to be client-side for offline support? Now you can!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


@page "/weather"

@if (IsWasmSupported)
{
 <WeatherWidgetWasm />
}
else
{
 <WeatherWidgetServer />
}

2. Rendering Improvements (Faster Blazor, Less Waiting)

Blazor’s rendering engine got some serious gains, like it’s been hitting the gym. Microsoft optimized the diffing algorithm, reducing unnecessary DOM updates and improving interactivity.

1
2
3
4
5
6
7
8


@code {
 private List<string> items = new();

 protected override void OnInitialized()
 {
 items = Enumerable.Range(1, 100).Select(i => $"Item {i}").ToList();
 }
}

3. Streaming Rendering (Because Nobody Likes Waiting)

With Streaming Rendering, Blazor can now send partial page updates as the content becomes available, improving perceived load times.

1
2
3
4
5


@page "/news"

<StreamRender>
 <NewsFeed />
</StreamRender>

This means users don’t have to stare at a blank screen while waiting for data to load. Instead, they get content as soon as it’s ready!

4. Enhanced JavaScript Interop (Yes, We Still Need JS Sometimes)

Look, we tried to get rid of JavaScript, but sometimes we still need it. The good news? JavaScript interop in Blazor is now smoother than ever.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


<button @onclick="ShowAlert">Click me!</button>

@code {
 [Inject] IJSRuntime JS { get; set; }

 private async Task ShowAlert()
 {
 await JS.InvokeVoidAsync("alert", "Hello from Blazor!");
 }
}

5. Auto-Reconnect for Blazor Server

Ever had a Blazor Server app lose connection and just… die? Well, not anymore! Blazor now includes automatic reconnection, so if the network blips, your app will try to reconnect on its own.

1
2
3


<CircuitHandler>
 <h3>Reconnecting...</h3>
</CircuitHandler>

The Future of Blazor

Blazor is evolving rapidly, and Microsoft has big plans. Some of the upcoming features include:

AOT Compilation for WebAssembly: Even faster Blazor WASM apps!
Better Mobile Support: Blazor + .NET MAUI = ❤️
More Interop with JavaScript Frameworks: If you can’t beat them, integrate with them.
Server-Side Rendering (SSR) with Blazor Components: Because why not borrow a good idea from React?

Key Ideas

Concept	Summary
Blazor WebAssembly	Runs in the browser using WebAssembly
Blazor Server	Uses SignalR to render UI from the server
Blazor United	Mixes Server & WASM for best performance
Streaming Rendering	Sends content progressively for faster UX
Enhanced JS Interop	Better ways to call JS from Blazor
Auto-Reconnect	Blazor Server can now recover from outages
Future of Blazor	Faster, better, and more features incoming

References

Parsing NCPDP & HIPAA X12

Wed, 14 Jun 2017 00:00:00 +0000

So, You Have to Parse NCPDP or HIPAA X12 EDI?

I’m Sorry.

If you’re here, you’ve probably been voluntold to deal with healthcare EDI transactions.

You’ve seen the cryptic format, wondered if someone spilled alphabet soup into your file, and now you need help.

No worries!

I got you.

Let’s talk about the best open-source frameworks in C#, Python, and Node.js to make your life less miserable when handling NCPDP and HIPAA X12 transactions like 277, 835, 837, 997, 999, and TA1.

C# Frameworks for EDI Parsing

1. EDI.Net

A solid open-source library for parsing and generating X12 EDI transactions in C#.

Great for dealing with HIPAA 837, 835, and other standard transactions.

Installation:

1

Install-Package Edi.Net

Example Usage:

1
2
3
4
5


using indice.Edi;
using System.IO;

var ediText = File.ReadAllText("sample.edi");
var transaction = EdiSerializer.Deserialize<MyEdiModel>(ediText);

2. X12Parser

This library helps process HIPAA X12 files and can convert them into JSON or XML.

Installation:

1

Install-Package X12Parser

Example Usage:

1
2
3


var parser = new X12Parser();
var transaction = parser.Parse("path/to/edi/file");
Console.WriteLine(transaction.ToJson());

Python Frameworks for EDI Parsing

1. PyX12

A veteran library for parsing and generating HIPAA X12 transactions.

It includes validation tools, which is great because EDI errors are the worst.

Installation:

1

pip install pyx12

Example Usage:

1
2
3
4
5
6


from pyx12.x12file import X12Reader

with open("sample.edi", "r") as edi_file:
reader = X12Reader(edi_file)
for segment in reader:
print(segment)

2. edi-parser

A lightweight library for parsing X12 files in Python, with support for HIPAA transactions.

Installation:

1

pip install edi-parser

Example Usage:

1
2
3
4
5


from edi_parser import parse

with open("sample.edi", "r") as f:
transaction = parse(f.read())
print(transaction)

Node.js Frameworks for EDI Parsing

1. node-x12

This library provides an easy way to parse and generate X12 EDI files.

It’s simple and effective.

Installation:

1

npm install node-x12

Example Usage:

1
2
3
4
5
6


const { X12Parser } = require("node-x12");
const parser = new X12Parser();

const ediText = "ISA*00*..."; // Replace with actual EDI content
const transaction = parser.parse(ediText);
console.log(transaction);

2. edi-parser-js

A minimalistic but powerful X12 parser for Node.js.

Installation:

1

npm install edi-parser-js

Example Usage:

1
2
3
4
5


const { parseEDI } = require("edi-parser-js");

const ediData = "ISA*00*..."; // Your EDI file content
const result = parseEDI(ediData);
console.log(result);

Wrapping It Up

You don’t have to suffer alone in the abyss of EDI.

Whether you’re coding in C#, Python, or Node.js, these open-source frameworks will save you time, headaches, and possibly your sanity.

If you’re working with NCPDP transactions, unfortunately, open-source support is sparse.

Most solutions are proprietary, but you might find limited parsing capability in the libraries above.

Happy coding (or at least, less painful debugging)!

Key Ideas

Topic	Summary
EDI Parsing in C#	Use `EDI.Net` or `X12Parser` to process HIPAA X12 transactions.
EDI Parsing in Python	`pyx12` and `edi-parser` are solid choices for handling HIPAA X12 files.
EDI Parsing in Node.js	`node-x12` and `edi-parser-js` are the best libraries for working with EDI in JavaScript.
Common Transactions	The libraries above support 277, 835, 837, 997, 999, and TA1 transactions.
NCPDP Support	Open-source options for NCPDP transactions are limited.

References

Task Parallel Library (TPL) in a Nutshell

Fri, 23 Jun 2017 00:00:00 +0000

What Is the TPL?

The Task Parallel Library is like your super-organized, efficiency-obsessed friend who loves to delegate work. Instead of you doing all the heavy lifting in a program (you know, one thing at a time), the TPL lets your computer handle multiple tasks in parallel, which means it can get a lot more done in less time.

The TPL is built around the concept of tasks. These tasks are units of work that can run asynchronously, and they can even run in parallel if your hardware is cool enough to support that.

But Wait, What Does ‘Parallel’ Mean?

In simple terms: parallelism is when tasks run at the same time. Imagine if you and your buddy were both cleaning different rooms in the house. You’re both working simultaneously, so the whole place gets cleaned faster.

Concurrency, on the other hand, is when tasks don’t necessarily run at the same time but take turns executing. Think of it like both of you trying to clean the same room but swapping places every once in a while.

The TPL helps you handle both parallelism and concurrency, and it does it with style.

Why Should I Care About TPL?

You might be thinking, “Why would I need parallelism in my app? It’s just a simple to-do list, after all.”

Well, even if your app isn’t solving super-complex scientific problems, task parallelism can make your program run faster by utilizing multiple CPU cores. This means better performance, smoother user experience, and less time waiting for your app to do its thing.

For example, imagine you’re downloading several files at once or processing a large batch of data. If you’re doing this one after the other (a.k.a. sequentially), it’s like you’re waiting for a single person to handle all those tasks, and they’re really slow about it.

But with the TPL, you can have different tasks run at the same time, and boom, your program finishes in a fraction of the time.

How Does It Work?

In C#, tasks are represented by the Task class. This class is your best buddy when it comes to parallel execution.

The Basics of a Task

You can create a task using the Task.Run() method. This is like saying, “Hey, C#, take care of this task while I go do other things.”

Here’s a quick example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


using System;
using System.Threading.Tasks;

class Program
{
 static void Main()
 {
 Task myTask = Task.Run(() =>
 {
 Console.WriteLine("I am running in parallel!");
 });

 myTask.Wait(); // Wait for the task to complete
 }
}

In this example, the task runs in the background while your main thread can do other stuff. You don’t have to wait for it to finish right away. You can continue doing other things while it’s working in the background.

Handling Multiple Tasks

What if you want to run multiple tasks in parallel? Easy. The TPL has got your back with something called Task.WhenAll().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


Task task1 = Task.Run(() => DoWork("Task 1"));
Task task2 = Task.Run(() => DoWork("Task 2"));
Task task3 = Task.Run(() => DoWork("Task 3"));

await Task.WhenAll(task1, task2, task3);

void DoWork(string taskName)
{
 Console.WriteLine($"{taskName} is working...");
}

This will run all three tasks simultaneously (well, almost simultaneously, depending on your machine’s cores). The TPL takes care of scheduling and executing the tasks in the most efficient way possible.

Error Handling

Of course, things don’t always go as planned. What if one of your tasks throws an error?

The TPL provides a way to handle errors gracefully using Task.Exception or Task.WhenAny() and Task.WhenAll() to deal with partial failures.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


Task myTask = Task.Run(() =>
{
 throw new InvalidOperationException("Something went wrong!");
});

try
{
 myTask.Wait(); // Wait for the task to complete
}
catch (AggregateException ex)
{
 Console.WriteLine($"Caught an exception: {ex.Message}");
}

This catches any exceptions thrown by the task, so you can gracefully handle them without causing the whole program to crash. Very fancy!

Cancellation Support

Another neat feature of the TPL is the ability to cancel tasks before they finish. This is great when you want to give the user control or prevent wasted computation.

You can do this with a CancellationToken, which is a little flag that tells the task, “Hey, stop what you’re doing!”

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


CancellationTokenSource cts = new CancellationTokenSource();
Task myTask = Task.Run(() =>
{
 for (int i = 0; i < 100; i++)
 {
 if (cts.Token.IsCancellationRequested)
 {
 Console.WriteLine("Task was canceled.");
 return;
 }

 // Simulate some work
 Thread.Sleep(100);
 }
}, cts.Token);

// Cancel the task after 500 milliseconds
Thread.Sleep(500);
cts.Cancel();

This allows you to stop tasks that might take too long or aren’t needed anymore. It’s like giving your tasks a “time-out” button.

Best Practices for Using TPL

Now that you know the basics, let’s talk about some best practices to avoid disaster.

Don’t Overuse Tasks: Creating too many tasks can actually slow down your application. Think about it like a traffic jam. A few cars on the road? No problem. But if you add too many, things get stuck. So, don’t go creating tasks for every little thing.
Be Mindful of Thread Pool Size: Tasks don’t always run on separate threads. Instead, they often use a pool of threads. Too many tasks can overwhelm the pool, causing delays.
Avoid Blocking Threads: Try not to block threads with Task.Wait() or Task.Result. This kind of defeats the purpose of asynchronous programming!
Handle Exceptions: Always account for potential exceptions. If something goes wrong, you don’t want your entire app to collapse like a house of cards.

Key Ideas

Idea	Summary
Task Parallel Library	A library for managing parallel tasks in C#.
Parallelism	Running tasks simultaneously to speed things up.
Concurrency	Handling multiple tasks that might not run simultaneously.
Task Class	The core unit of work in TPL, representing an asynchronous task.
Task.WhenAll	Runs multiple tasks in parallel and waits for all to complete.

References

Understanding Azure Service Fabric with Examples in C# and Python

Tue, 03 Dec 2019 00:00:00 +0000

Understanding Azure Service Fabric with Examples in C# and Python

Introduction

Ah, Azure Service Fabric — Microsoft’s secret sauce for microservices before it was cool to even say “microservices” at networking events. If you’ve ever wondered how apps like Skype or Azure SQL Database scale like an over-caffeinated octopus juggling thousands of requests, Service Fabric is part of the magic.

A Brief History of Azure Service Fabric

Once upon a time (specifically around 2015), Microsoft unveiled Azure Service Fabric to the world. But don’t be fooled — this wasn’t a brand-new invention. Service Fabric had already been the powerhouse behind internal Microsoft services like Skype for Business and Azure SQL for years.

Microsoft saw the world moving toward microservices architectures, where applications are composed of small, independently deployable services. Service Fabric was their response to this trend — a platform that made building, deploying, and managing microservices as simple as binge-watching your favorite show on a Sunday afternoon.

What is Azure Service Fabric, and Why Should You Care?

Azure Service Fabric is a distributed systems platform that makes it easy to package, deploy, and manage scalable and reliable microservices. It handles complex infrastructure tasks like service discovery, load balancing, and state management. And the best part? It supports both stateless and stateful services — yes, your services can actually remember stuff without relying on external databases!

Key features include:

Microservices support: Both stateless and stateful.
Polyglot-friendly: Supports C#, Python, Java, and more.
Automatic scaling: Scale up/down based on demand.
Built-in monitoring: Track service performance without breaking a sweat.

Architecture Overview

At its core, Azure Service Fabric is like an orchestra conductor for microservices. It manages clusters of machines (physical or virtual) and ensures that services stay healthy, available, and responsive.

Key Components

Clusters: Collections of nodes that run microservices.
Nodes: Individual machines (virtual or physical) within the cluster.
Applications and Services: Applications are composed of services that implement specific tasks.
Partitions and Replicas: Stateful services can be partitioned for better scalability.
Reliable Collections: Special data structures that maintain state across failures.

Setting Up Azure Service Fabric

Let’s get practical! We’ll create a simple Service Fabric application with C# and Python.

Prerequisites

Azure CLI installed.
Service Fabric SDK (for C#).
Python 3.x.

C# Example: Building a Simple Stateless Service

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


using System;
using Microsoft.ServiceFabric.Services.Runtime;

namespace HelloFabric
{
 internal static class Program
 {
 private static void Main()
 {
 try
 {
 ServiceRuntime.RegisterServiceAsync("HelloFabricType",
 context => new HelloService(context)).GetAwaiter().GetResult();

 Console.WriteLine("Service is running. Press Ctrl+C to stop.");
 Thread.Sleep(Timeout.Infinite);
 }
 catch (Exception e)
 {
 Console.WriteLine($"Service failed to start: {e}");
 }
 }
 }

 internal class HelloService : StatelessService
 {
 public HelloService(StatelessServiceContext context) : base(context) { }

 protected override async Task RunAsync(CancellationToken cancellationToken)
 {
 while (!cancellationToken.IsCancellationRequested)
 {
 Console.WriteLine("Hello from Azure Service Fabric!");
 await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken);
 }
 }
 }
}

Explanation:

Registers a stateless service named HelloFabricType.
Prints a message every 5 seconds to simulate activity.

To deploy this, create a Service Fabric application and use the Azure CLI:

1

az sf application create --application-name fabric:/HelloFabric --application-type HelloFabricType --application-version 1.0.0

Python Example: Building a Stateless Service

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


import time

def main():
 print("Starting Azure Service Fabric simulation in Python!")
 while True:
 print("Hello from Azure Service Fabric (Python Edition)!")
 time.sleep(5)

if __name__ == "__main__":
 main()

Okay, technically this Python example isn’t using the official Service Fabric SDK, but hey, it simulates the behavior of a microservice running in a Service Fabric-like environment. If you’re deploying real Python services, check out the Azure Service Fabric Python SDK.

Advanced Concepts: Stateful Services

Stateless services are great for tasks like API endpoints, but what if you need to remember stuff (like session data)? That’s where stateful services come in.

Here’s a simplified C# example with a counter:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


protected override async Task RunAsync(CancellationToken cancellationToken)
{
 long counter = 0;
 while (!cancellationToken.IsCancellationRequested)
 {
 counter++;
 Console.WriteLine($"Counter value: {counter}");
 await Task.Delay(TimeSpan.FromSeconds(5), cancellationToken);
 }
}

This counter increments every five seconds and remembers its value across service restarts.

Debugging and Monitoring

Azure Service Fabric comes with built-in tools for monitoring service health. You can use Service Fabric Explorer (the UI tool) or hook into Azure Monitor for more advanced telemetry.

Key commands:

1
2


az sf cluster show --cluster-name <cluster-name>
az sf service list --application-name fabric:/HelloFabric

When Should You Use Azure Service Fabric?

Azure Service Fabric shines when you need:

Highly scalable applications.
Stateful services without external databases.
On-premise deployment options.

However, if you’re going all-in on Kubernetes and containers, Azure Kubernetes Service (AKS) might be the simpler choice.

Key Ideas

Azure Service Fabric simplifies microservices management.
Supports both stateless and stateful services.
Built-in resilience, scalability, and monitoring.
C# and Python are both welcome to the Service Fabric party.

References

Microsoft Azure Documentation - https://docs.microsoft.com/azure/service-fabric
Service Fabric SDK GitHub Repository - https://github.com/microsoft/service-fabric
Microservices Architecture Patterns by Martin Fowler
Azure Service Fabric: The Definitive Guide by Microsoft Press
Official Python SDK for Azure - https://pypi.org/project/azure-servicefabric/
Distributed Systems Explained - https://martinfowler.com/articles/microservices.html
Service Fabric Community Q&A - https://techcommunity.microsoft.com/

Modern Age Machine Learning- Azure, AWS, and Google Cloud

Tue, 03 Oct 2023 00:00:00 +0000

The Cloud ML Showdown: Azure vs. AWS vs. Google Cloud

Welcome to the Machine Learning Olympics! In one corner, we have Microsoft Azure flexing its enterprise muscles.

In another, Amazon Web Services (AWS) with its cloud dominance.

And finally, Google Cloud, the brainiac with deep learning chops. Let’s compare their machine learning features, tools, and APIs with some code examples in C#, Python, and Go.

1. Azure Machine Learning

What Makes Azure Shine?

Azure Machine Learning Studio: A drag-and-drop interface — perfect for those who fear command lines.
AutoML: Automates model selection and hyperparameter tuning.
ML.NET: Built-in support for C# enthusiasts.
Azure Cognitive Services: Pre-built models for vision, language, and speech.

C# Example with Azure ML

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


using Azure.AI.TextAnalytics;
using Azure;

var endpoint = new Uri("https://your-endpoint.cognitiveservices.azure.com/");
var apiKey = "your_api_key";
var client = new TextAnalyticsClient(endpoint, new AzureKeyCredential(apiKey));

string text = "Machine learning is fascinating!";
var result = client.DetectLanguage(text);

Console.WriteLine($"Language: {result.PrimaryLanguage.Name}");

Python Example with Azure ML

1
2
3
4
5
6
7
8
9


from azure.ai.textanalytics import TextAnalyticsClient
from azure.core.credentials import AzureKeyCredential

endpoint = "https://your-endpoint.cognitiveservices.azure.com/"
key = "your_api_key"
client = TextAnalyticsClient(endpoint=endpoint, credential=AzureKeyCredential(key))

response = client.detect_language(["Machine learning is fascinating!"])
print(f"Language: {response[0].primary_language.name}")

Go Example with Azure ML

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import (
 "fmt"
 "net/http"
 "io/ioutil"
 "strings"
)

func main() {
 url := "https://your-endpoint.cognitiveservices.azure.com/text/analytics/v3.0/languages"
 apiKey := "your_api_key"
 text := `{ "documents": [ { "id": "1", "text": "Machine learning is fascinating!" } ] }`

 req, _ := http.NewRequest("POST", url, strings.NewReader(text))
 req.Header.Add("Ocp-Apim-Subscription-Key", apiKey)
 req.Header.Add("Content-Type", "application/json")
 resp, _ := http.DefaultClient.Do(req)
 body, _ := ioutil.ReadAll(resp.Body)
 fmt.Println(string(body))
}

Azure Strengths

Strong enterprise integration (think Power BI & Office 365).
Great for C# developers.

Azure Weaknesses

Pricing can get tricky for smaller projects.
UI can feel overwhelming to newcomers.

2. AWS Machine Learning

What Makes AWS Shine?

SageMaker: End-to-end machine learning model building.
AWS Rekognition: Image and video analysis.
Comprehend: NLP services.
Deep Learning AMIs: Pre-configured environments for heavy-duty AI.

C# Example with AWS Comprehend

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


using Amazon.Comprehend;
using Amazon.Comprehend.Model;

var client = new AmazonComprehendClient();
var request = new DetectSentimentRequest
{
 Text = "Machine learning is amazing!",
 LanguageCode = "en"
};
var response = client.DetectSentimentAsync(request).Result;
Console.WriteLine($"Sentiment: {response.Sentiment}");

Python Example with AWS Comprehend

1
2
3
4
5


import boto3

client = boto3.client('comprehend', region_name='us-east-1')
response = client.detect_sentiment(Text="Machine learning is amazing!", LanguageCode="en")
print(f"Sentiment: {response['Sentiment']}")

Go Example with AWS Comprehend

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


package main

import (
 "fmt"
 "github.com/aws/aws-sdk-go/aws"
 "github.com/aws/aws-sdk-go/aws/session"
 "github.com/aws/aws-sdk-go/service/comprehend"
)

func main() {
 sess := session.Must(session.NewSessionWithOptions(session.Options{
 Config: aws.Config{Region: aws.String("us-east-1")},
 }))

 svc := comprehend.New(sess)

 input := &comprehend.DetectSentimentInput{
 Text: aws.String("Machine learning is amazing!"),
 LanguageCode: aws.String("en"),
 }

 result, _ := svc.DetectSentiment(input)
 fmt.Printf("Sentiment: %s\n", *result.Sentiment)
}

AWS Strengths

Huge variety of AI services.
Flexible infrastructure with powerful customization.

AWS Weaknesses

Complex IAM policies can drive you nuts.
The UI is… let’s say “utilitarian”.

3. Google Cloud AI

What Makes Google Cloud Shine?

Vertex AI: Unified platform for model training and deployment.
AutoML: No-code/low-code machine learning.
TPUs (Tensor Processing Units): Hardware optimized for machine learning.
NLP and Vision APIs: World-class tools built from Google’s AI expertise.

C# Example with Google Cloud NLP

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


using Google.Cloud.Language.V1;

var client = LanguageServiceClient.Create();
var response = client.AnalyzeSentiment(new Document
{
 Content = "Machine learning is revolutionary!",
 Type = Document.Types.Type.PlainText
});

Console.WriteLine($"Sentiment score: {response.DocumentSentiment.Score}");

Python Example with Google Cloud NLP

1
2
3
4
5
6


from google.cloud import language_v1

client = language_v1.LanguageServiceClient()
document = language_v1.Document(content="Machine learning is revolutionary!", type_=language_v1.Document.Type.PLAIN_TEXT)
response = client.analyze_sentiment(request={"document": document})
print(f"Sentiment score: {response.document_sentiment.score}")

Go Example with Google Cloud NLP

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import (
 "context"
 "fmt"
 "cloud.google.com/go/language/apiv1"
 "google.golang.org/genproto/googleapis/cloud/language/v1"
)

func main() {
 ctx := context.Background()
 client, _ := language.NewClient(ctx)
 doc := &languagepb.Document{
 Content: "Machine learning is revolutionary!",
 Type: languagepb.Document_PLAIN_TEXT,
 }
 resp, _ := client.AnalyzeSentiment(ctx, &languagepb.AnalyzeSentimentRequest{Document: doc})
 fmt.Printf("Sentiment score: %.2f\n", resp.DocumentSentiment.Score)
}

Google Cloud Strengths

Top-tier NLP and vision APIs.
Simple UI and easy-to-use APIs.

Google Cloud Weaknesses

Less enterprise adoption compared to Azure/AWS.
Pricing can surprise you if you’re not careful.

Side-by-Side Comparison

Feature	Azure	AWS	Google Cloud
Best For	Enterprise AI	Versatile AI tools	NLP & Vision APIs
No-Code Options	Yes (Azure ML Studio)	Yes (SageMaker Canvas)	Yes (Vertex AI AutoML)
Language Support	C#, Python, R	Python, Go, Java	Python, Go, Java
Unique Strength	Office 365/Power BI integration	Broadest cloud coverage	Google NLP/TPUs

Key Ideas

Azure excels with enterprise-friendly tools like ML.NET.
AWS is the Swiss Army knife of cloud AI.
Google Cloud leads in NLP and deep learning.

References

https://azure.microsoft.com/en-us/services/machine-learning/
https://aws.amazon.com/machine-learning/
https://cloud.google.com/ai
Russell, S., & Norvig, P. (2010). Artificial Intelligence: A Modern Approach.
Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep Learning.

Razor Pages in a Nutshell

Sun, 22 Jul 2018 00:00:00 +0000

The Ottoman

A Little History Lesson (Yes, You Have to Read This)

Back in the day, Microsoft gave us WebForms, which was like trying to build a modern skyscraper out of LEGOs. Then came ASP.NET MVC, which was much better but also forced us to write a lot of boilerplate code just to get a simple page running.

Then, in .NET Core 2.0 (circa 2017), Microsoft introduced Razor Pages. It was their way of saying:

“Hey, what if we made something that didn’t require a full MVC structure, but still let you use Razor syntax?”

And thus, Razor Pages were born. It’s like MVC, but without the “C” (Controller), because apparently, nobody likes writing controllers.

What is Razor Pages, Really?

Imagine if MVC decided to hit the gym, shed some complexity, and came back leaner and more focused. That’s Razor Pages.

Each page is self-contained with its own .cshtml file (HTML + Razor) and a PageModel (C# code-behind). No more dealing with routing headaches—each page gets its own URL automagically.

It’s perfect for apps that aren’t huge, where you just need a simple, structured way to build pages without drowning in the usual MVC setup.

Setting Up Razor Pages (Because You’re Curious, Right?)

First, create an ASP.NET Core project and enable Razor Pages in Startup.cs (or Program.cs in newer versions):

1
2
3
4
5
6
7
8


var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRazorPages();
var app = builder.Build();

app.UseRouting();
app.MapRazorPages();

app.Run();

Boom! Razor Pages are now in business.

A Simple Razor Page Example

Every Razor Page has two files:

Index.cshtml → The front-end page
Index.cshtml.cs → The PageModel (code-behind file)

Here’s what Index.cshtml might look like:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


@page
@model IndexModel

<!DOCTYPE html>
<html>
<head>
 <title>Welcome!</title>
</head>
<body>
 <h1>Hello, @Model.Message</h1>
</body>
</html>

And here’s Index.cshtml.cs:

1
2
3
4
5
6


using Microsoft.AspNetCore.Mvc.RazorPages;

public class IndexModel : PageModel
{
 public string Message { get; private set; } = "World!";
}

That’s it! No controller, no routing files, no drama. Just a page and its logic, neatly packaged together.

Handling Forms in Razor Pages

Need to process a form? Razor Pages has got you covered. Here’s a simple example:

The Form (`Contact.cshtml`)

1
2
3
4
5
6
7
8
9


@page
@model ContactModel

<form method="post">
 <label>Name:</label>
 <input type="text" asp-for="Name" />
 <button type="submit">Submit</button>
</form>
<p>@Model.Message</p>

The Page Model (`Contact.cshtml.cs`)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


using Microsoft.AspNetCore.Mvc.RazorPages;

public class ContactModel : PageModel
{
 public string Message { get; private set; }
 public string Name { get; set; }

 public void OnPost()
 {
 Message = $"Hello, {Name}!";
 }
}

Simple, clean, and no unnecessary ceremony. Forms just work!

Why Should You Use Razor Pages?

Less Boilerplate – No need to define controllers and routes manually.
More Structure – Each page has its logic, making code more organized.
Built-in Model Binding – Form submissions are straightforward.
Great for Small to Medium Apps – If you don’t need the full MVC structure, Razor Pages is the way to go.

When Should You Not Use Razor Pages?

If you’re building a huge enterprise app with tons of APIs—stick to MVC.
If you need to share logic between multiple views—MVC is better for that.
If you just enjoy suffering—go ahead, write everything in JavaScript.

Key Ideas

Concept	Summary
What is Razor Pages?	A simpler, page-based alternative to MVC
History	Introduced in ASP.NET Core 2.0 (2017)
Setup	`AddRazorPages()` and `MapRazorPages()` in `Startup.cs`
Basic Structure	`.cshtml` (view) + `.cshtml.cs` (PageModel)
Form Handling	Uses model binding, just like MVC
When to Use It?	Great for small-to-medium projects
When Not to Use It?	Not ideal for large, complex applications

References

Dapper in a Nutshell

Sun, 14 Aug 2016 00:00:00 +0000

Dapper in a Nutshell

What the Heck is Dapper, and Why Should You Care?

So, you’ve been using Entity Framework (EF) and loving its sweet, sweet LINQ queries. But one day, your database starts crying because EF is making a bazillion queries and your app is moving slower than a snail in molasses.

Enter Dapper—the lightweight, super-fast micro ORM (Object-Relational Mapper) that lets you talk to your database with the speed of a caffeinated squirrel.

A Brief History of Dapper (With Minimal Boredom)

Back in 2011, the team at Stack Overflow (yes, the very people who save our butts daily) needed something faster than Entity Framework but still easy to use. They wanted raw SQL speed without the boilerplate nonsense of ADO.NET.

So, they built Dapper.

Dapper basically wraps ADO.NET but makes it ridiculously easy to execute queries and map results to C# objects. Think of it as ADO.NET with a personal assistant who takes care of all the tedious work.

Why Use Dapper? (Or: Why You Should Break Up With EF—Sometimes)

Speed Demon: Dapper is almost as fast as raw ADO.NET because it avoids all the fancy ORM magic.
Lightweight: No baggage, no unnecessary abstraction—just SQL with some mapping awesomeness.
SQL-Friendly: You write SQL directly, which means no weird query translation problems.
Control: You have full control over what gets executed, how it performs, and how data is shaped.
Flexible: Works with any database (SQL Server, PostgreSQL, MySQL, SQLite—you name it!).

Dapper vs Entity Framework: The Ultimate Showdown

Feature	Dapper	Entity Framework
Performance	Insanely fast 🚀	Can be slow on large queries 🐢
Ease of Use	Simple and direct SQL	LINQ queries, auto-mapping
Control	Full control over SQL	Abstraction layer hides SQL
Learning Curve	Very easy if you know SQL	Slightly steeper with LINQ
Database Support	Works with everything	Mostly SQL Server, others need tweaking
Best For	Read-heavy apps, APIs	Complex domain models

Dapper in Action

1. Install Dapper

1
2


// Install via NuGet
Install-Package Dapper

2. Setting Up a Database Connection

1
2
3
4
5
6
7
8
9


using System.Data;
using System.Data.SqlClient;

var connectionString = "YourConnectionStringHere";
using (var db = new SqlConnection(connectionString))
{
 db.Open();
 Console.WriteLine("Database connected!");
}

3. Fetching a Single Record

1

var user = db.QueryFirstOrDefault<User>("SELECT * FROM Users WHERE Id = @Id", new { Id = 1 });

4. Fetching Multiple Records

1

var users = db.Query<User>("SELECT * FROM Users").ToList();

5. Insert Data

1
2


var rowsAffected = db.Execute("INSERT INTO Users (Name, Age) VALUES (@Name, @Age)",
 new { Name = "Alice", Age = 25 });

6. Update Data

1
2


var rowsAffected = db.Execute("UPDATE Users SET Age = @Age WHERE Name = @Name",
 new { Name = "Alice", Age = 26 });

7. Delete Data

1
2


var rowsAffected = db.Execute("DELETE FROM Users WHERE Name = @Name",
 new { Name = "Alice" });

8. Handling Transactions

1
2
3
4
5
6
7


using (var transaction = db.BeginTransaction())
{
 db.Execute("INSERT INTO Orders (UserId, Amount) VALUES (@UserId, @Amount)",
 new { UserId = 1, Amount = 99.99 }, transaction);

 transaction.Commit();
}

9. Stored Procedure Calls

1

var orders = db.Query<Order>("sp_GetUserOrders", new { UserId = 1 }, commandType: CommandType.StoredProcedure);

10. Mapping Complex Relationships

1
2
3
4
5
6


var sql = "SELECT * FROM Users u INNER JOIN Orders o ON u.Id = o.UserId";
var userOrders = db.Query<User, Order, User>(sql, (user, order) =>
{
 user.Orders.Add(order);
 return user;
}, splitOn: "Id").ToList();

Final Thoughts

Dapper is like that reliable, no-nonsense friend who gets things done—fast and efficiently. If you need high performance and love writing SQL, Dapper is your best bet.

Of course, EF still has its place, especially when dealing with complex domain models. But for pure speed and control, Dapper wipes the floor with EF.

Give it a shot, and enjoy blazing-fast database queries without the overhead!

Key Ideas

Concept	Summary
Dapper	Lightweight, fast micro ORM for C#
History	Created by Stack Overflow for speed
Performance	Almost as fast as raw ADO.NET
SQL-Friendly	Works directly with SQL queries
Comparison	Faster than EF but less automated
Best Use Case	APIs, read-heavy apps, high performance

References

How we supported Multiple DB Engines in the 2000s

Tue, 21 Jul 2020 00:00:00 +0000

See Related Article here:
Enterprise Design Pattern: SQL CRUD Explained

How We Wrote C# Code to Support Multiple Database Backends in 2006

Back in 2006, before Entity Framework or even LINQ to SQL, writing C# applications that needed to support multiple database backends was a challenging but fun problem.

There were no modern ORMs, so we had to get creative with design patterns, stored procedures, and abstraction layers to make our applications database-agnostic.

Entity Framework, LINQ Etc… these things did not come into common use until late 2000s…

In this article, I’ll walk you through how we handled this using Factory Pattern, Repository Pattern, and CRUD stored procedures, and I’ll even show a code example that worked across Oracle, Microsoft SQL Server, and MySQL.

The Problem: No ORM, Only Raw ADO.NET

In 2000’s, when you wanted to interact with a database in C#, you used ADO.NET. This meant dealing with:

SqlConnection, OracleConnection, MySqlConnection (each DBMS had its own connection object).
SqlCommand, OracleCommand, MySqlCommand (different syntax for executing queries).
DataReaders, DataTables, and DataSets.
Raw SQL and stored procedures.

There was no clean way to switch databases without rewriting a ton of code. So, we had to abstract the database layer.

MySql Notes: We could not do this approch below with MySql until around 2005, since Stored Procedures didnt exist in MySql until then.

The Solution: Abstracting the Database Layer

To make our C# application work across different databases, we used a combination of design patterns:

Factory Pattern - To create the appropriate database objects dynamically.
Repository Pattern - To provide a common interface for data access.
Stored Procedures for CRUD Operations - To encapsulate logic inside the database and optimize performance.

Let’s break it down.

Step 1: The Factory Pattern for Database Independence

The Factory Pattern allowed us to instantiate the right database objects dynamically based on configuration settings.

C# Example: Database Factory

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


public interface IDatabase
{
 IDbConnection GetConnection();
 IDbCommand CreateCommand(string query, IDbConnection connection);
}

public class SqlServerDatabase : IDatabase
{
 public IDbConnection GetConnection() => new SqlConnection("your-sqlserver-connection-string");
 public IDbCommand CreateCommand(string query, IDbConnection connection) => new SqlCommand(query, (SqlConnection)connection);
}

public class MySqlDatabase : IDatabase
{
 public IDbConnection GetConnection() => new MySqlConnection("your-mysql-connection-string");
 public IDbCommand CreateCommand(string query, IDbConnection connection) => new MySqlCommand(query, (MySqlConnection)connection);
}

public class OracleDatabase : IDatabase
{
 public IDbConnection GetConnection() => new OracleConnection("your-oracle-connection-string");
 public IDbCommand CreateCommand(string query, IDbConnection connection) => new OracleCommand(query, (OracleConnection)connection);
}

public static class DatabaseFactory
{
 public static IDatabase GetDatabase(string dbType)
 {
 return dbType switch
 {
 "MSSQL" => new SqlServerDatabase(),
 "MySQL" => new MySqlDatabase(),
 "Oracle" => new OracleDatabase(),
 _ => throw new NotImplementedException($"Database type {dbType} is not supported")
 };
 }
}

Now, in our app, we could instantiate the correct database at runtime:

1
2
3


IDatabase database = DatabaseFactory.GetDatabase("MySQL");
using var connection = database.GetConnection();
connection.Open();

Step 2: The Repository Pattern for Data Access

The Repository Pattern provided a common interface for interacting with the database, independent of the actual backend.

C# Example: Repository for Users

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


public interface IUserRepository
{
 void AddUser(string username);
 List<string> GetAllUsers();
}

public class UserRepository : IUserRepository
{
 private readonly IDatabase _database;

 public UserRepository(IDatabase database)
 {
 _database = database;
 }

 public void AddUser(string username)
 {
 using var connection = _database.GetConnection();
 connection.Open();
 using var command = _database.CreateCommand("usp_AddUser", connection);
 command.CommandType = CommandType.StoredProcedure;
 command.Parameters.Add(new SqlParameter("@Username", username));
 command.ExecuteNonQuery();
 }

 public List<string> GetAllUsers()
 {
 var users = new List<string>();
 using var connection = _database.GetConnection();
 connection.Open();
 using var command = _database.CreateCommand("usp_GetAllUsers", connection);
 command.CommandType = CommandType.StoredProcedure;
 using var reader = command.ExecuteReader();
 while (reader.Read())
 {
 users.Add(reader.GetString(0));
 }
 return users;
 }
}

This ensured that our application code never had to change regardless of which database we used.

Step 3: CRUD Stored Procedures for Different Databases

Each database backend had different syntax, so we wrote custom stored procedures for Create, Read, Update, and Delete (CRUD) operations.

SQL Server Stored Procedure (MSSQL)

1
2
3
4
5


CREATE PROCEDURE usp_AddUser @Username NVARCHAR(50)
AS
BEGIN
 INSERT INTO Users (Username) VALUES (@Username);
END

MySQL Stored Procedure

1
2
3
4
5
6


DELIMITER $$
CREATE PROCEDURE usp_AddUser(IN p_Username VARCHAR(50))
BEGIN
 INSERT INTO Users (Username) VALUES (p_Username);
END $$
DELIMITER ;

Oracle Stored Procedure

1
2
3
4


CREATE PROCEDURE usp_AddUser(p_Username IN VARCHAR2) AS
BEGIN
 INSERT INTO Users (Username) VALUES (p_Username);
END;

By keeping the stored procedures consistent in naming, the C# code remained unchanged.

Conclusion

Before ORMs like Entity Framework, we rolled our own database abstraction using:

Factory Pattern to create database-specific objects.
Repository Pattern to abstract data access.
Stored Procedures to encapsulate database-specific logic.

This approach allowed our application to run on Oracle, Microsoft SQL Server, and MySQL without modifying the core business logic.

While modern ORMs have made things easier, sometimes you still need raw control over database operations, and this approach remains relevant today!

Key Ideas

Concept	Summary
Factory Pattern	Created database-specific connection objects dynamically
Repository Pattern	Provided a unified interface for data access
Stored Procedures	Standardized CRUD operations across databases
Multi-DB Support	Enabled switching between MSSQL, MySQL, and Oracle

This was how we built multi-database support in C# back in 2006!

SQL-Exploring CET Analytic(Window) Functions, Common Table Expressions (CTEs)

Tue, 21 Jul 2020 00:00:00 +0000

1. Analytic Functions in SQL

Analytic functions (also called window functions) perform calculations across a specific range of rows (a window) related to the current row. Unlike aggregate functions (which collapse multiple rows into one), analytic functions retain individual row results while still providing aggregated insights.

🔹 Key Features of Analytic Functions

They operate over a defined window of rows.
They do not group the result set into a single row.
They require an OVER() clause.

🔹 Common Analytic Functions

Function	Description
`ROW_NUMBER()`	Assigns a unique row number to each row in a partition.
`RANK()`	Assigns a rank to each row, allowing for ties (skips numbers for ties).
`DENSE_RANK()`	Similar to `RANK()`, but without skipping numbers for ties.
`NTILE(n)`	Distributes rows into `n` roughly equal buckets.
`LAG(column, n)`	Returns the value of the column from `n` rows before the current row.
`LEAD(column, n)`	Returns the value of the column from `n` rows after the current row.
`SUM() OVER()`	Calculates a running total.
`AVG() OVER()`	Computes a moving average.

🔹 Example: Using ROW_NUMBER()

Let’s say we have a sales table:

id	customer	amount
1	Alice	100
2	Bob	200
3	Alice	150
4	Bob	250
5	Charlie	300

To rank each customer’s purchases:

1
2
3
4
5


SELECT
 customer,
 amount,
 ROW_NUMBER() OVER(PARTITION BY customer ORDER BY amount DESC) AS row_num
FROM sales;

Breakdown:

PARTITION BY customer: Resets the row numbering for each customer.
ORDER BY amount DESC: Orders within each partition by highest amount.
ROW_NUMBER(): Assigns a unique row number per partition.

Result:

customer	amount	row_num
Alice	150	1
Alice	100	2
Bob	250	1
Bob	200	2
Charlie	300	1

2. Common Table Expressions (CTEs)

A Common Table Expression (CTE) is a temporary result set that exists only within the execution of a single query. It helps improve readability and modularity.

🔹 Why Use CTEs?

Makes complex queries easier to read.
Can be referenced multiple times within the same query.
Helps avoid subquery repetition.

🔹 Basic Syntax

1
2
3
4


WITH cte_name AS (
 -- Your query here
)
SELECT * FROM cte_name;

🔹 Example: Using a CTE

Consider a sales table where we want to calculate the total sales per customer, and then filter those with sales above $200.

1
2
3
4
5
6
7
8


WITH total_sales AS (
 SELECT customer, SUM(amount) AS total_amount
 FROM sales
 GROUP BY customer
)
SELECT *
FROM total_sales
WHERE total_amount > 200;

Breakdown:

The CTE (total_sales) first computes SUM(amount) per customer.
The main query filters results where total_amount > 200.

💡 Alternative (Without CTEs): We’d have to repeat the aggregation:

1
2
3
4
5
6


SELECT * FROM (
 SELECT customer, SUM(amount) AS total_amount
 FROM sales
 GROUP BY customer
) t
WHERE total_amount > 200;

CTEs make queries much cleaner! 😎

Combining Analytic Functions and CTEs

Sometimes, CTEs and analytic functions work well together. Let’s rank sales using a CTE:

1
2
3
4
5
6
7
8


WITH ranked_sales AS (
 SELECT
 customer,
 amount,
 ROW_NUMBER() OVER(PARTITION BY customer ORDER BY amount DESC) AS rank
 FROM sales
)
SELECT * FROM ranked_sales WHERE rank = 1;

🔹 Purpose: This finds the highest sale per customer.

3. Temporary Table

A Temporary Table is a physical table stored in tempdb (SQL Server) or a temporary schema (MySQL, PostgreSQL). It can store intermediate results and be referenced multiple times within a session.

Characteristics of Temporary Tables

Scope:
- #TempTable (local) exists only in the current session.
- ##GlobalTempTable (global) can be accessed by multiple sessions.
Performance: Stored in memory/disk, better for large data sets.
Reusability: Can be modified after creation (INSERT, UPDATE, DELETE).
Indexing: Can have indexes for performance optimization.

Syntax:

1
2
3
4
5
6
7
8


CREATE TABLE #temp_table (
 id INT,
 name VARCHAR(50)
);

INSERT INTO #temp_table VALUES (1, 'Alice');

SELECT * FROM #temp_table;

Example: Using a Temporary Table to Store Sales Data

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


-- Create a temporary table
CREATE TABLE #TempSales (
 customer VARCHAR(50),
 total_amount DECIMAL(10,2)
);

-- Insert aggregated data into temp table
INSERT INTO #TempSales
SELECT customer, SUM(amount)
FROM sales
GROUP BY customer;

-- Query from temp table multiple times
SELECT * FROM #TempSales WHERE total_amount > 500;
SELECT COUNT(*) FROM #TempSales;

-- Drop the temp table when done
DROP TABLE #TempSales;

🔹 What Happens?

#TempSales is physically created in memory (or disk if large).
The data persists until the session ends or the table is dropped.
You can run multiple queries against it, unlike a CTE.

Key Differences Between CTEs and Temp Tables

Feature	CTE	Temporary Table
Scope	Exists only for the duration of the query	Exists for the session or until explicitly dropped
Persistence	Not stored physically	Stored in `tempdb` (SQL Server) or temporary schema
Performance	Best for small, in-memory calculations	Better for large datasets that need indexing
Reusability	Cannot be reused outside the query	Can be queried multiple times
Modifiability	Read-only	Can be modified (INSERT, UPDATE, DELETE)
Indexing	No indexes	Can have indexes

When to Use What?

Scenario	Best Choice
Breaking down complex queries for better readability	✅ CTE
One-time use within a single query	✅ CTE
Need to reuse data in multiple queries	✅ Temp Table
Working with large datasets that need indexing	✅ Temp Table
Needing to modify data after creation	✅ Temp Table

4. Analytic Function Syntax in Different Databases

Oracle

Oracle has the most mature support for analytic functions, available since Oracle 8i.

Basic Example: Ranking Orders by Amount

1
2
3
4


SELECT
 customer_id, order_id, amount,
 RANK() OVER (PARTITION BY customer_id ORDER BY amount DESC) AS order_rank
FROM orders;

Running Total Example

1
2
3
4


SELECT
 customer_id, order_id, amount,
 SUM(amount) OVER (PARTITION BY customer_id ORDER BY order_id) AS running_total
FROM orders;

🔹 Oracle-Specific Features

Supports advanced functions like CUME_DIST() and PERCENT_RANK().
Performance-optimized window functions with Oracle’s query optimizer.
Can use RANGE and ROWS in the OVER() clause.

SQL Server (MSSQL)

SQL Server introduced analytic functions in SQL Server 2012, making it one of the later adopters.

Basic Example: Ranking Employees by Salary

1
2
3
4


SELECT
 employee_id, department_id, salary,
 RANK() OVER (PARTITION BY department_id ORDER BY salary DESC) AS rank_in_department
FROM employees;

Lag and Lead Functions Example

1
2
3
4
5


SELECT
 employee_id, salary,
 LAG(salary, 1, 0) OVER (ORDER BY employee_id) AS previous_salary,
 LEAD(salary, 1, 0) OVER (ORDER BY employee_id) AS next_salary
FROM employees;

🔹 SQL Server-Specific Features

Full support for analytic functions (since 2012).
Performance tuning required for large datasets.
Limited statistical functions (compared to Oracle/PostgreSQL).

PostgreSQL

PostgreSQL introduced full analytic function support in version 8.4 and provides more flexibility than SQL Server.

Basic Example: Ranking Products by Sales

1
2
3
4


SELECT
 product_id, category_id, sales,
 RANK() OVER (PARTITION BY category_id ORDER BY sales DESC) AS rank
FROM sales;

Running Sum Example

1
2
3
4


SELECT
 customer_id, amount,
 SUM(amount) OVER (PARTITION BY customer_id ORDER BY transaction_date) AS running_sum
FROM transactions;

🔹 PostgreSQL-Specific Features

Supports advanced statistical window functions (CUME_DIST(), PERCENT_RANK()).
Supports custom aggregate window functions (not available in Oracle or SQL Server).
Better performance for large datasets (compared to SQL Server).

MySQL (8.0+)

MySQL introduced window functions in MySQL 8.0 (before that, they were unsupported).

Basic Example: Ranking Customers

1
2
3
4


SELECT
 customer_id, order_id, amount,
 RANK() OVER (PARTITION BY customer_id ORDER BY amount DESC) AS rank
FROM orders;

Running Total Example

1
2
3
4


SELECT
 customer_id, order_id, amount,
 SUM(amount) OVER (PARTITION BY customer_id ORDER BY order_id) AS running_total
FROM orders;

🔹 MySQL-Specific Limitations

Lacks statistical functions (CUME_DIST(), PERCENT_RANK()).
Performance is not optimized for large datasets.
No custom aggregate window functions (unlike PostgreSQL).

🚀 Key Differences Across Databases

Feature	Oracle	SQL Server (MSSQL)	PostgreSQL	MySQL (8.0+)
First to support window functions?	✅ Yes (Oracle 8i)	❌ No (SQL Server 2012)	✅ Yes (PostgreSQL 8.4)	❌ No (MySQL 8.0)
Ranking functions (`RANK()`, `DENSE_RANK()`, `ROW_NUMBER()`)	✅ Yes	✅ Yes	✅ Yes	✅ Yes
Lag/Lead functions (`LAG()`, `LEAD()`)	✅ Yes	✅ Yes	✅ Yes	✅ Yes
Running totals (`SUM() OVER()`, `AVG() OVER()`)	✅ Yes	✅ Yes	✅ Yes	✅ Yes
Statistical functions (`CUME_DIST()`, `PERCENT_RANK()`)	✅ Yes	✅ Yes	✅ Yes	❌ No
Custom aggregate window functions	❌ No	❌ No	✅ Yes	❌ No

WebForms in a Nutshell

Tue, 15 Aug 2017 00:00:00 +0000

A Brief History (or “How Did We Get Here?”)

Back in the early 2000s, Microsoft decided that web development should be as easy as dragging and dropping buttons onto a form—just like in Visual Basic or WinForms. Enter ASP.NET WebForms, introduced with .NET Framework 1.0 in 2002. This was Microsoft’s answer to making web development “easier” (quotes very intentional).

The idea? Abstract away the horrors of HTTP, state management, and client-server interactions. The result? A system that pretended the web was a giant WinForms app. What could possibly go wrong?

Key Features (or “What Could Go Wrong?”)

ViewState: A magical hidden field that stored the entire page state between postbacks. The downside? Your pages could bloat faster than a WordPress site with 50 plugins.
Postbacks: Instead of sending small AJAX requests, WebForms sent the whole form back to the server. Every. Single. Time.
Server Controls: Want a button? Drag, drop, and boom—you have a <asp:Button> magically doing things for you.
Code-Behind: Separation of HTML and logic! (Kind of. Sort of. Not really.)
Event Model: Handle OnClick events in C# just like in desktop applications. What a time to be alive!

And yet, for all its quirks, WebForms powered thousands of enterprise apps for years. It was a beast, but it was our beast.

WebForms vs. Modern Web Development

Fast forward to today, and WebForms feels like a relic of a lost civilization. With the rise of MVC, SPA frameworks like React, and microservices, WebForms now sits in the “legacy” section of tech stacks, right next to COBOL and fax machines.

Why Did WebForms Fade Away?

Performance Issues: That lovely ViewState could sometimes be larger than the page itself.
Complexity: Underneath the simplicity, WebForms had a lot of magic happening, which made debugging a nightmare.
Poor Scalability: Every postback meant sending the entire page state to the server. Not ideal for a high-traffic website.
Lack of Frontend Flexibility: WebForms made it hard to integrate with modern JavaScript frameworks.

Microsoft finally saw the writing on the wall and introduced ASP.NET MVC, effectively putting WebForms on hospice care. And then came Blazor, but that’s another story for another day.

WebForms Code Examples

Alright, enough talk. Let’s look at some good old-fashioned WebForms code.

1. Basic WebForms Page (`Default.aspx`)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="WebFormsApp.Default" %>
<!DOCTYPE html>
<html>
<head>
 <title>WebForms Example</title>
</head>
<body>
 <form runat="server">
 <asp:Label ID="lblMessage" runat="server" Text="Hello, WebForms!"></asp:Label>
 <br />
 <asp:Button ID="btnClickMe" runat="server" Text="Click Me" OnClick="btnClickMe_Click" />
 </form>
</body>
</html>

2. Code-Behind (`Default.aspx.cs`)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


using System;

namespace WebFormsApp
{
 public partial class Default : System.Web.UI.Page
 {
 protected void Page_Load(object sender, EventArgs e)
 {
 if (!IsPostBack)
 {
 lblMessage.Text = "Welcome to WebForms!";
 }
 }

 protected void btnClickMe_Click(object sender, EventArgs e)
 {
 lblMessage.Text = "You clicked the button!";
 }
 }
}

3. WebForms with a GridView (Because Every Enterprise App Had One)

1

<asp:GridView ID="gvData" runat="server" AutoGenerateColumns="true"></asp:GridView>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


using System;
using System.Data;

namespace WebFormsApp
{
 public partial class GridViewExample : System.Web.UI.Page
 {
 protected void Page_Load(object sender, EventArgs e)
 {
 if (!IsPostBack)
 {
 LoadData();
 }
 }

 private void LoadData()
 {
 DataTable dt = new DataTable();
 dt.Columns.Add("ID");
 dt.Columns.Add("Name");
 dt.Rows.Add("1", "Alice");
 dt.Rows.Add("2", "Bob");

 gvData.DataSource = dt;
 gvData.DataBind();
 }
 }
}

Conclusion

WebForms was a weird but lovable (sort of) chapter in web development history. If you worked with it, you probably have some battle scars—but you also learned a lot.

Key Ideas

Concept	Summary
WebForms Origins	Introduced in 2002 as part of .NET Framework 1.0 to simplify web development
ViewState	Stored page state, but often led to performance issues due to bloated pages
Postbacks	Full-page refreshes for every interaction, limiting scalability
Server Controls	Abstracted HTML elements, making development feel like WinForms
Code-Behind	Separated UI from logic, but often led to tightly coupled code
Decline	Replaced by ASP.NET MVC, then further overshadowed by modern JS frameworks

Principle	C++	C#	Python
SRP	✅	✅	✅
OCP	✅	✅	✅
LSP	✅	✅	✅
ISP	✅	✅	✅
DIP	✅	✅	✅

Principle	C++	C#	Python
SRP	✅	✅	✅
OCP	✅	✅	✅
LSP	✅	✅	✅
ISP	✅	✅	✅
DIP	✅	✅	✅

C# on Brian Braatz Blog

Finite State Machines, Hierarchical State Machines, and SAGA

What is a Finite State Machine (FSM)? 🤖

Example: Order Processing FSM

Python Example

How FSMs Relate to SAGA 🌀

What is a Hierarchical State Machine (HSM)? 🏛️

Example: Expanding Order Processing with Substates

C# Example: HSM for Order Processing

Python Example: HSM for Order Processing

How HSMs Relate to SAGA 🏗️

Final Thoughts 💡

🔑 Key Ideas Table

📚 References

Multi-Threaded Lock-Free Programming in C#

What Is Lock-Free Programming?

Why Should You Care?

How to Do It in C# ?

1. Use Concurrent Collections

Example: Using ConcurrentDictionary

Example: Using ConcurrentQueue

Example: Using ConcurrentBag

Example: Using ConcurrentStack

2. Dive into Interlocked Operations

3. Embrace the Power of Volatile

4. Create Your Own Lock-Free Structures

Key Ideas

Further Reading

Building a Hybrid On-Prem Cloud App with a Secret API!

Introduction

What is a Hybrid Cloud?

How I Built a Hybrid Cloud Before Modern Cloud Services

The Hybrid Cloud Architecture

Architecture Diagram

Step 1: Write the Super-Secret Microservice (Python & C#)

Python Version (Runs On-Prem)

C# Version (Runs On-Prem)

Step 2: Deploy the Microservice in Docker (On-Prem)

Step 3: Build the Cloud Proxy Microservice

Cloud Proxy Service (Python Flask)

Step 4: Deploy the Proxy Service in AWS, Azure, and Google Cloud

AWS: Use Elastic Beanstalk or Lambda + API Gateway

Azure: Use Azure App Service + VPN Gateway

Google Cloud: Use Cloud Run + Hybrid Connectivity

Key Takeaways

References

Non-Blocking I/O- The Secret Sauce Behind Snappy Applications

What on Earth is Non-Blocking I/O?

The Good, the Bad, and the Ugly of Non-Blocking I/O

Pros:

Cons:

Non-Blocking I/O in the Wild: Node.js, C#, and Python

Node.js: The Non-Blocking Ninja

C#: The Asynchronous Ace

Python: The Coroutine Connoisseur

Wrapping Up

gRPC in a Nutshell

📜 A Quick History Lesson

🧠 What is gRPC Anyway?

🛠️ Code Examples

1. Python: Protobuf Definition

2. Python: gRPC Service Definition

3. Python: Server Implementation

4. Python: Client Code

5. C#: Protobuf Definition

6. C#: Server Implementation

7. C#: Client Code

8. Go: Protobuf Definition

9. Go: Server Code

10. Go: Client Code

🔑 Key Ideas

📚 References

WCF in a Nutshell

WCF in a Nutshell: A Wild Ride Through Windows Communication Foundation

A Brief History of WCF

How WCF Works (In Plain English)

Writing a Basic WCF Service

1. Define the Service Contract

2. Implement the Service

3. Configure the Service in Web.config

Example: Using `ConcurrentDictionary`

Example: Using `ConcurrentQueue`

Example: Using `ConcurrentBag`

Example: Using `ConcurrentStack`

3. Configure the Service in `Web.config`

Principle	C++	C#	Python
SRP	✅	✅	✅
OCP	✅	✅	✅
LSP	✅	✅	✅
ISP	✅	✅	✅
DIP	✅	✅	✅