Forem: Sajjad Ali

Building a Robust End of Service (EOS) Valuation System: Lessons from a Real-World Actuarial Project

Sajjad Ali — Wed, 31 Dec 2025 12:46:07 +0000

In actuarial and financial systems, correctness is necessary — but it is rarely sufficient.

I recently completed an End-of-Service (EOS) valuation system used in a regulated accounting environment. While the mathematics behind EOS is well understood, the real challenge lies elsewhere: data inconsistency, year-over-year drift, regulatory edge cases, and minimizing operational risk.

This post is a short case study on what actually mattered while building the system.

The Core Problem

The system needed to support:

EOS valuations under multiple actuarial approaches
IAS 19 compliance, including first-time adoption cases
Different valuation frequencies (monthly, quarterly, rolling periods)
Automated disclosures and reports
Strong data integrity checks to catch upstream HR data issues

Most importantly, it needed to work reliably with real client data, not ideal datasets.

Model Design: Supporting Variations Without Duplication

Instead of building a single monolithic model, the system was designed around explicit model variants, including:

Age-based mortality models
Age–service-based mortality models
Current year, previous year, and adjusted models
Additional analytical views (Financial Assumptions, Salary Assumptions, Demographic Assumptions, Date of Birth, and Date of Joining based models)

Each model shared a common structural core but had clearly separated assumptions and inputs. This avoided the common trap of “one model with many flags,” which quickly becomes unmaintainable.

IAS 19 First-Time Adoption: A Hidden Complexity

First-time IAS 19 adoption is not just a switch — it changes how historical data is interpreted.

The system explicitly supports:

Transition-specific logic paths
Separate handling for prior-period comparisons
Clear segregation between adopted and non-adopted valuation outputs

This made the system easier to audit and reason about, especially during reviews.

Valuation Periods: Time Is a First-Class Input

Instead of treating time as an afterthought, valuation periods were modeled as first-class inputs:

Monthly
Bi-monthly
Quarterly
Rolling monthly-to-year valuations

This allowed consistent outputs without duplicating logic for each reporting frequency, a surprisingly common source of errors in financial systems.

Data Integrity Checks: Where Most Real Issues Appear

One of the most valuable parts of the system had nothing to do with calculations.

We implemented employee movement and consistency checks, such as:

Employees present in last year’s data but missing in the current year
Employees missing from both the current data and the exit data
Unexpected movements that often signal upstream HR issues

These checks turn silent data problems into explicit, reviewable queries, reducing downstream valuation risk.

In practice, this saved far more time than optimizing calculations.

Automation with a Human-in-the-Loop

Disclosures and reports are auto-generated to minimize manual work, but the system is intentionally designed for a final human review step.

This balance matters:

Fully manual → slow and error-prone
Fully automated → brittle in regulated environments

The goal was review, not rework.

Key Takeaways

A few lessons that stood out:

In regulated domains, data reliability often matters more than model sophistication
Explicit model separation beats “configuration-heavy” designs
Most production issues come from what’s missing, not what’s present
Good systems assume imperfect inputs and make problems visible early

Final Thoughts

This project reinforced something I’ve seen repeatedly while working with financial and actuarial systems:

Accurate results are important — but trustworthy systems are what survive audits, reviews, and real clients.

If you’re working at the intersection of engineering, finance, or regulation, I’d be happy to exchange notes.

Understanding CORS: Why It Matters and How to Implement It in Node.js and FastAPI

Sajjad Ali — Thu, 10 Apr 2025 18:01:04 +0000

Hey devs 👋! Have you ever built a frontend that talks to a backend API, and everything works locally... but suddenly, when deployed, the browser screams at you with:

Access to fetch at 'https://yourapi.com' from origin 'https://yourfrontend.com' has been blocked by CORS policy 😱

Yep. That’s CORS in action.

Let’s break it down.

🧠 What is CORS?

CORS stands for Cross-Origin Resource Sharing. It’s a browser security feature that restricts how web pages loaded from one origin can request resources from another origin.

🧪 Example:

Your frontend is hosted at https://myfrontend.com and your backend API is at https://myapi.com. Even though they both belong to you, the browser considers this a cross-origin request.

CORS helps prevent malicious sites from making unauthorized requests on behalf of users to other origins (a.k.a. CSRF attacks).

🔒 Why CORS is Important

Without CORS, any website could make requests to your API using a logged-in user's credentials. That would be a major security issue.

CORS gives you control over which origins can interact with your API. It's like putting a guest list at the door to your backend party 🎉.

⚙️ How CORS Works

When a browser detects a cross-origin request, it sends a preflight request (an HTTP OPTIONS request) to the server. The server must respond with headers like:

Access-Control-Allow-Origin: https://myfrontend.com
Access-Control-Allow-Methods: GET, POST
Access-Control-Allow-Headers: Content-Type

If the response looks good, the browser proceeds. If not, it blocks the request.

🚀 Implementing CORS in Node.js (with Express)

Node.js + Express makes it super easy using the cors middleware.

✅ Basic Setup:

npm install cors

const express = require('express');
const cors = require('cors');

const app = express();

// Allow all origins (not recommended for production)
app.use(cors());

// OR allow specific origins
app.use(cors({
  origin: 'https://myfrontend.com',
  methods: ['GET', 'POST'],
  allowedHeaders: ['Content-Type'],
}));

app.get('/api/data', (req, res) => {
  res.json({ message: 'CORS works!' });
});

app.listen(3000, () => console.log('Server running on port 3000'));

🐍 Implementing CORS in FastAPI (Python)

FastAPI has first-class support for CORS via the fastapi.middleware.cors module.

✅ Basic Setup:

pip install fastapi uvicorn

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

# Allow specific origin
app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://myfrontend.com"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"]
)

@app.get("/api/data")
def read_data():
    return {"message": "CORS works!"}

🔧 Best Practices

✅ Always specify exact origins in production instead of using *
✅ Restrict methods and headers to what’s needed
🚫 Never allow credentials with wildcard origins
🔒 Test with real frontend domains before going live

🧵 TL;DR

CORS is a security feature that prevents unauthorized cross-origin requests.
Browsers enforce it, not your backend by default.
You need to explicitly allow origins that can access your APIs.
Node.js (Express) and FastAPI both make it easy to configure CORS.

If you’ve ever hit that scary CORS error, you now know it’s not a bug — it’s your browser trying to protect users. Respect it. Configure it. And ship securely 💪

Got questions or a CORS horror story? Drop them in the comments 👇

Happy coding, friends! ✌️

Git Tags: The Unsung Hero of Version Control

Sajjad Ali — Tue, 08 Apr 2025 11:54:36 +0000

Hey devs 👋! Ever been in a situation where someone on your team (maybe even you 👀) asks:

"Hey... which commit did we deploy to production last week?"

And suddenly everyone's scrolling through the Git history, trying to decipher commit messages like "final-final-really-final-fix" or "hotfix2attempt3"? Yeah. We’ve all been there. It's like trying to find a needle in a haystack—except the haystack is on fire and you’re out of coffee.

But what if I told you there’s a super simple way to avoid all that? Let me introduce you to one of the most underused but incredibly powerful features of Git: tags.

The Problem: "What Commit Did We Ship?"

Let’s set the scene.
You’re working on a product. Releases are flying out the door. The PM pings you:

"The client says version 2.1.0 had a bug. Can we roll back to it?"

Panic sets in. Your Git history is a mess. There’s no clear signpost telling you what commit represented version 2.1.0.

You wish you could just mark important commits.

Well... you can. That’s exactly what Git tags are for.

So What Exactly Are Git Tags?

Think of tags like bookmarks or sticky notes on your Git timeline. They let you say: “Hey, this commit right here? This is version 1.0.”

Once a tag is created, it’s permanently attached to a specific commit. It won’t move or change even as new commits get added. This makes it perfect for marking release points.

Quick Example: Tagging a Release

Let’s say you just finished testing and everything’s good to go for version 2.1.0. Here's how you tag it:

git tag -a v2.1.0 -m "Release version 2.1.0"
git push origin v2.1.0

Now, any time someone wants to check out that version:

git checkout v2.1.0

Boom. You’re in the exact state the code was when it shipped.

Lightweight vs Annotated Tags

There are two types of tags in Git:

1. Lightweight Tags

Just a name pointing to a commit.
No extra info.
Example:

git tag v2.2.0

2. Annotated Tags

Full metadata: tagger name, date, message.
Stored as full Git objects.
Recommended for releases.

git tag -a v2.2.0 -m "Added dark mode support"

Pro Moves: Tags + CI/CD

Tags are amazing when combined with continuous deployment.

Want to deploy only when a new version is tagged? Easy.
Many CI/CD tools let you set triggers like:

"Deploy when a new tag matching v* is pushed."

That means your pipeline only fires when a proper version tag goes out. Clean, intentional, and no surprises.

Git Tag Cheat Sheet 🧠

Command	What It Does
`git tag`	List all tags
`git tag -a v1.0 -m "Message"`	Create annotated tag
`git tag v1.0`	Create lightweight tag
`git push origin v1.0`	Push a single tag
`git push origin --tags`	Push all tags
`git show v1.0`	Show tag details
`git tag -d v1.0`	Delete local tag
`git push origin :refs/tags/v1.0`	Delete remote tag

Friendly Reminder: Semantic Versioning Exists for a Reason

Stick to semantic versioning when tagging:

vMAJOR.MINOR.PATCH

Examples:

v1.0.0: First release
v2.1.0: Minor update (new features)
v2.1.1: Patch fix

This helps your team (and your future self) understand what changed at a glance.

TL;DR — Why You Should Care

Git tags:

✅ Mark important commits like releases
✅ Help you roll back or reproduce past states
✅ Play nicely with CI/CD
✅ Keep you sane when debugging or tracing

If you're not tagging your releases yet, give it a shot. Start small. Next time you ship something, tag it. You’ll thank yourself later.

Got a tagging tip? A tagging horror story? Or just a question? Hit me up in the comments 💬

Happy tagging, folks!

✌️

Supercharge Your Prototyping with Streamlit: A Quick and Powerful Web Framework 🚀

Sajjad Ali — Wed, 12 Mar 2025 10:57:31 +0000

Have you ever had an amazing app idea but hesitated to start development due to time and cost constraints? Or are you a data scientist or machine learning engineer looking for a quick way to showcase your AI models with a simple interactive interface? If so, Streamlit might be the perfect tool for you!

Why Streamlit?

Traditional web development can be complex and time-consuming. Frameworks like React and Flask require setting up front-end and back-end components, writing extensive boilerplate code, and managing UI elements separately. Streamlit, on the other hand, simplifies the process by allowing you to build interactive web apps directly from Python scripts—without any prior web development experience!

🚀 Benefits of Streamlit:

✅ Fast & Easy – Build a working prototype in minutes, not days!

✅ Python-Based – No need to learn HTML, CSS, or JavaScript.

✅ Interactive Widgets – Add buttons, sliders, and text inputs effortlessly.

✅ Data Visualization – Seamlessly integrate Matplotlib, Seaborn, and Plotly.

✅ Live Updates – Auto-refreshes the UI when the script is modified.

✅ Deployment Ready – Share your app with a single command using Streamlit Cloud.

Getting Started with Streamlit

📌 Installation

First, install Streamlit using pip:

pip install streamlit

🔥 Creating Your First App

Create a Python script (e.g., app.py) and add the following code:

import streamlit as st

st.title("Hello, Streamlit!")
st.write("This is your first Streamlit app!")

number = st.slider("Pick a number", 0, 100, 50)
st.write(f"You selected: {number}")

Now, run your app:

streamlit run app.py

And voilà! 🎉 Your web app is up and running in your browser.

Building an AI-Powered Web App

Let's say you have a machine learning model and you want users to test it with their own inputs. With Streamlit, it's easy!

import streamlit as st
import joblib  # For loading ML models

# Load pre-trained model
model = joblib.load("model.pkl")

st.title("AI Model Predictor")
user_input = st.text_input("Enter input data:")
if st.button("Predict"):
    prediction = model.predict([[float(user_input)]])
    st.write(f"Prediction: {prediction}")

This simple script allows users to enter a value, click a button, and get a prediction from your trained model—all in just a few lines of code!

Deploying Your Streamlit App 🌍

Once your app is ready, you can deploy it using Streamlit Cloud, Heroku, or AWS. The easiest way is:

git init
streamlit cloud deploy

This makes your app accessible to anyone via a shareable link!

Final Thoughts 💡

Streamlit is a game-changer for quick prototyping, especially for data scientists, AI developers, and analysts who need a simple and interactive way to showcase their work. Whether you’re testing an idea, building an MVP, or deploying a full-fledged data app, Streamlit saves time and effort.

So, why not give it a try? Let me know your experience with Streamlit in the comments! 🚀🔥

Why You Should Use Prisma ORM in Your Next Project 🚀

Sajjad Ali — Thu, 27 Feb 2025 10:34:59 +0000

Hey everyone! 👋 If you've ever built an application—whether it's a web app, Android app, or desktop app—you've likely needed a database. Gone are the days when developers wrote raw SQL queries manually and worked directly with database connectors. Instead, Object-Relational Mappers (ORMs) and Object-Document Mappers (ODMs) have taken over, making database interactions much more efficient and maintainable.

In my search for the best ORM, I came across Prisma, and I must say—it’s one of the best! Before choosing Prisma, I explored SQLAlchemy and a few others, but they weren’t as flexible. One major downside of SQLAlchemy is that you need to define data models and data classes manually. Plus, dynamically adding new fields at runtime isn’t straightforward. That’s where Prisma shines! 💡

Why Choose Prisma? 🤔

✅ Automatic Model Generation – Define your schema once, and Prisma takes care of the rest. No need to manually create model classes.
✅ Multi-Language Support – Works seamlessly with Node.js, Next.js, Python (FastAPI, Django, Flask), and more.
✅ Type Safety – Provides full TypeScript support for safer queries.
✅ Flexible and Scalable – Prisma is not just an ORM; it acts as a database toolkit supporting migrations, queries, and relations.
✅ Great Performance – Optimized for modern databases like PostgreSQL, MySQL, SQLite, and MongoDB.

I’ve personally used Prisma with Python (FastAPI backend) and Next.js backend, and it was an amazing experience! 🚀

Setting Up Prisma with Next.js 🌐

Let's go through the basic setup for a Next.js + Prisma + PostgreSQL project.

Step 1: Install Dependencies

npm install @prisma/client
npm install --save-dev prisma

Step 2: Initialize Prisma

npx prisma init

This will create a prisma/schema.prisma file where you can define your database schema.

Step 3: Define Your Schema

Edit the prisma/schema.prisma file to define your models:

model User {
  id    Int     @id @default(autoincrement())
  name  String
  email String  @unique
  posts Post[]
}

model Post {
  id        Int     @id @default(autoincrement())
  title     String
  content   String?
  author    User    @relation(fields: [authorId], references: [id])
  authorId  Int
}

Step 4: Run Migrations

npx prisma migrate dev --name init

Step 5: Use Prisma in Your API

Create a file lib/prisma.ts:

import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();
export default prisma;

Use it in an API route:

import prisma from '../../lib/prisma';

export default async function handler(req, res) {
  const users = await prisma.user.findMany();
  res.json(users);
}

Setting Up Prisma with FastAPI ⚡

Step 1: Install Prisma for Python

pip install prisma

Step 2: Initialize Prisma in Your FastAPI Project

prisma init

Step 3: Define Your Schema (`prisma/schema.prisma`)

model User {
  id    Int    @id @default(autoincrement())
  name  String
  email String @unique
}

Step 4: Generate Prisma Client

prisma generate

Step 5: Use Prisma in FastAPI

from prisma import Client
from fastapi import FastAPI

app = FastAPI()
prisma = Client()

@app.get("/users")
async def get_users():
    if not db.is_connected():
        await db.connect()

    users = await prisma.user.find_many()
    return users

Conclusion 🎯

If you're looking for an ORM that is flexible, efficient, and easy to use, Prisma is a fantastic choice! It works seamlessly with both JavaScript/TypeScript and Python, making it a great fit for full-stack applications.

Give Prisma a try in your next project and let me know your thoughts! Have you used any other ORMs that you liked? Drop a comment below! 👇🔥

Choosing the Right Charting Library for Your React Dashboard

Sajjad Ali — Thu, 27 Feb 2025 09:34:57 +0000

If you've ever built a React dashboard, you know how essential data visualization is. Whether you’re displaying user analytics, sales trends, or financial reports, charts make your data easy to understand. But with so many charting libraries available, how do you choose the right one? 🤔

Recently, I needed to integrate charts into one of my React projects. After researching, I found three powerful libraries worth considering:

✅ React-ApexCharts

A highly customizable, configuration-based library that provides interactive charts with ease.

Great for dashboard visualizations
Supports real-time updates
Multiple chart types: Line, Bar, Area, Pie, and more!
Lightweight & responsive

Example Usage:

import Chart from 'react-apexcharts';

const options = {
  chart: { id: 'basic-bar' },
  xaxis: { categories: [1991, 1992, 1993, 1994, 1995] }
};
const series = [{ name: 'series-1', data: [30, 40, 35, 50, 49] }];

export default function BarChart() {
  return <Chart options={options} series={series} type="bar" height={350} />;
}

✅ React-Plotly

If you need scientific, analytical, or financial charting, Plotly is a strong contender.

Great for data-heavy applications
Supports 3D plots, heatmaps, and financial charts
Interactive by default
Works with large datasets

Example Usage:

import Plot from 'react-plotly.js';

export default function LineChart() {
  return (
    <Plot
      data={[
        {
          x: [1, 2, 3, 4, 5],
          y: [2, 6, 3, 8, 5],
          type: 'scatter',
          mode: 'lines+markers',
          marker: { color: 'blue' }
        }
      ]}
      layout={{ title: 'Line Chart Example' }}
    />
  );
}

✅ Recharts

A component-based approach to charting that aligns well with React’s philosophy.

Uses React components instead of configuration objects
Better integration with React’s state management
Highly customizable with SVG rendering
Supports tooltips, legends, and animations

Example Usage:

import { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, Legend } from 'recharts';

const data = [
  { name: 'Jan', value: 400 },
  { name: 'Feb', value: 300 },
  { name: 'Mar', value: 500 }
];

export default function RechartsExample() {
  return (
    <LineChart width={400} height={300} data={data}>
      <XAxis dataKey="name" />
      <YAxis />
      <CartesianGrid strokeDasharray="3 3" />
      <Tooltip />
      <Legend />
      <Line type="monotone" dataKey="value" stroke="#8884d8" />
    </LineChart>
  );
}

🔥 Which Charting Library Should You Choose?

Feature	React-ApexCharts	React-Plotly	Recharts
Best For	Dashboards, real-time data	Scientific & financial analysis	General React-friendly charts
Customization	High	Very High	Moderate
Ease of Use	Easy	Moderate	Easy
Performance	High	Moderate	High
Interactivity	Good	Excellent	Good

🚀 Other Alternatives

While these three are great, there are other alternatives like:

Chart.js – Lightweight and simple
D3.js – Highly customizable but has a steep learning curve
Visx – A low-level visualization library built for React

💡 Conclusion

So far, I’ve worked with React-ApexCharts and React-Plotly, but I’m also excited to try Recharts! If you’re working on a dashboard, choosing the right charting library depends on your project’s needs.

👉 What’s your favorite charting library for React? Have you tried any other alternatives? Let’s discuss in the comments! 🔥👇

Why You Should Avoid Pandas in Production Applications

Sajjad Ali — Thu, 13 Feb 2025 18:30:58 +0000

If you're coming from a Data Science or Machine Learning background, chances are you've used pandas extensively. It's one of the first libraries taught in universities and widely adopted in data science projects. There's no issue with that— pandas is a fantastic tool for exploratory data analysis, data manipulation, an
d visualization.

However, should you use pandas in production applications? Absolutely not! Let me explain why.

The Problem with Using Pandas in Production

I recently came across a Python desktop application developed with PySide6 that handled financial computations involving gigabytes of data. The developer used pandas for data processing, and while it worked initially, the app became sluggish, unresponsive, and inefficient as the data grew.

So why is pandas not a good choice for production apps?

Pandas is Slow for Large Datasets

Pandas is optimized for small to medium-sized datasets. It is single-threaded and operates in memory, making it inefficient for large-scale data processing. If you're dealing with gigabytes of data, pandas will likely slow down your application.

Lack of Asynchronous Processing

Many production applications, especially those handling real-time data, require asynchronous operations. Pandas does not provide native support for async processing, which means it can block the main thread, leading to performance bottlenecks in event-driven applications.

High Memory Usage

Pandas loads the entire dataset into memory, making it impractical for handling large-scale data. This can lead to excessive memory consumption, slow processing, and even crashes in extreme cases.

What Are the Better Alternatives?

If pandas isn’t the best choice for production applications, what should you use instead? Here are some powerful alternatives:

Polars (Best for Performance)

Polars is a high-performance DataFrame library built for speed. It utilizes Apache Arrow under the hood and supports multi-threading, making it significantly faster than pandas for large datasets.

Example: Pandas vs. Polars Performance Test

import pandas as pd
import polars as pl
import time

# Create a large dataset
data = {
    "col1": range(1, 10_000_000),
    "col2": range(10_000_000, 1, -1)
}

# Using Pandas
t1 = time.time()
df_pandas = pd.DataFrame(data)
df_pandas["sum"] = df_pandas["col1"] + df_pandas["col2"]
t2 = time.time()
print(f"Pandas execution time: {t2 - t1} seconds")

# Using Polars
t3 = time.time()
df_polars = pl.DataFrame(data)
df_polars = df_polars.with_columns((df_polars["col1"] + df_polars["col2"]).alias("sum"))
t4 = time.time()
print(f"Polars execution time: {t4 - t3} seconds")

In most cases, Polars is 5x–10x faster than pandas while consuming significantly less memory!

PyArrow (Best for Efficient Memory Management)

Apache PyArrow is another excellent alternative, especially for working with columnar data formats like Parquet and Feather.

import pyarrow as pa
import pyarrow.parquet as pq

# Creating an Arrow table
data = pa.table({
    "col1": range(1, 10_000_000),
    "col2": range(10_000_000, 1, -1)
})

# Save as a Parquet file
pq.write_table(data, "data.parquet")

PyArrow is lightweight and highly optimized for reading/writing large datasets efficiently.

Apache Spark (PySpark) (Best for Distributed Computing)

If you need to handle massive datasets in production, Apache Spark (PySpark) is the way to go. Unlike pandas, Spark runs computations in parallel across multiple nodes, making it highly scalable.

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("Example").getOrCreate()

# Load a dataset
df = spark.read.csv("large_dataset.csv", header=True, inferSchema=True)

# Perform operations
df = df.withColumn("sum", df["col1"] + df["col2"])
df.show()

For enterprise-level applications dealing with terabytes of data, Spark is the most reliable solution.

Conclusion

Pandas is great for data science, prototyping, and small datasets, but when it comes to production applications, it can be a major bottleneck.

What should you use instead?

Polars → Best for speed and low memory consumption.

PyArrow → Best for efficient memory management and Parquet/Feather data handling.

PySpark → Best for distributed computing and large-scale data processing.

If you're working on a production-level application, choosing the right tool can significantly improve performance and scalability.

What do you think?

Have you faced performance issues with pandas in production? What alternative tools do you use? Let me know in the comments!

State Pattern | Design Patterns

Sajjad Ali — Fri, 15 Mar 2024 11:41:16 +0000

In software engineering, crafting robust and maintainable code is akin to an artist painting a masterpiece. It requires finesse, foresight, and a deep understanding of the tools. Among the arsenal of design patterns lies one gem that stands out for its elegance and versatility: the State Pattern.

Unveiling the State Pattern

Imagine you're tasked with building a canvas application capable of creating various shapes. At first glance, it seems straightforward—define tools like selection, brush, and eraser using enums, and let the Canvas class handle the rest. However, as the codebase grows, cracks begin to appear.

public enum ToolType {
    SELECTION,
    BRUSH,
    ERASER
}

public class Canvas{
    private ToolType tool;

    public void mouseDown() {
        if(tool == ToolType.SELECTION)
            // Code for SELECTION Tool
        else if(tool == ToolType.BRUSH)
            // Code for Brush Tool
        else if(tool == ToolType.Eraser)
            // Code for Eraser Tool
    }

    public void mouseUp() {
        if(tool == ToolType.SELECTION)
            // Code for SELECTION Tool
        else if(tool == ToolType.BRUSH)
            // Code for Brush Tool
        else if(tool == ToolType.Eraser)
            // Code for Eraser Tool
    }

    public void setTool(ToolType tool){
        this.toot = tool;
    }
}

The initial implementation, although functional, lacks scalability and violates the Open-Closed Principle. Adding new tools necessitates modifying existing code, leading to a tangled mess of if-else statements. Enter the State Pattern—a beacon of clarity in the fog of complexity.

The Pitfalls of Tradition

Before diving into the solution, let's dissect the shortcomings of the traditional approach. Maintenance becomes a Herculean task as the codebase sprawls with conditional statements. Each addition or modification sends ripples of change across the code, defying the principle of encapsulation.

Embracing Abstraction

The State Pattern offers a lifeline amidst the chaos. By abstracting tool behavior into a common interface, we decouple the Canvas class from specific tool implementations. This not only streamlines the code but also fosters extensibility without sacrificing stability.

With a simple interface defining mouse actions, the Canvas class becomes a blank canvas awaiting the brush strokes of creativity. New tools can be seamlessly integrated by implementing the interface, keeping the codebase pristine and adaptable.

public interface Tool {

    void mouseDown();

    void mouseUp();
}

public class Canvas {
    private Tool currentTool;

    public void mouseDown() {
        currentTool.mouseDown();
    }

    public void mouseUp() {
        currentTool.mouseUp();
    }

    public Tool getCurrentTool() {
        return currentTool;
    }

    public void setCurrentTool(Tool currentTool) {
        this.currentTool = currentTool;
    }

}

public class BrushTool implements Tool {

    @Override
    public void mouseDown() {
        System.out.println("Brush icon");
    }

    @Override
    public void mouseUp() {
        System.out.println("Draw a line");
    }

}

public class EraserTool implements Tool {

    @Override
    public void mouseDown() {
        System.out.println("Eraser icon");
    }

    @Override
    public void mouseUp() {
        System.out.println("Erase something");
    }

}


public class SelectionTool implements Tool {

    @Override
    public void mouseDown() {
        System.out.println("Selection icon");
    }

    @Override
    public void mouseUp() {
        System.out.println("Draw dashed rectangle");
    }

}

public class Main {
    public static void main() {
        var canvas = new Canvas();
        canvas.setCurrentTool(new SelectionTool());
        canvas.mouseDown();
        canvas.mouseUp();

        canvas.setCurrentTool(new BrushTool());
        canvas.mouseDown();
        canvas.mouseUp();

        canvas.setCurrentTool(new EraserTool());
        canvas.mouseDown();
        canvas.mouseUp();
    }
}

Harnessing the Power

Armed with this newfound clarity, crafting tools becomes a breeze. Each tool class encapsulates its behavior, adhering to the Single Responsibility Principle. Whether it's a brush, eraser, or selection tool, the State Pattern empowers developers to express their intentions concisely and elegantly.

State Pattern in Practice

Beyond the realm of canvas applications, the State Pattern finds its place in diverse domains. Consider a navigation app offering various modes of transportation—bicycling, driving, transit, and walking. By encapsulating each mode's behavior within a common interface, the application achieves flexibility without sacrificing cohesion.

public interface Travel {
    Object getEta();
}


public class DirectionService {
    private Travel travel;

    public void setTravel(Travel travel) {
        this.travel = travel;
    }

    public Travel getTravel() {
        return travel;
    }

    public Object getEta() {
        return travel.getEta();
    }

}


public class Bicycling implements Travel {
    @Override
    public Object getEta() {
        System.out.println("Calculating ETA (bicycling)");
        return 2;
    }

}

public class Driving implements Travel {
    @Override
    public Object getEta() {
        System.out.println("Calculating ETA (driving)");
        return 1;
    }

}

public class Transit implements Travel {
    @Override
    public Object getEta() {
        System.out.println("Calculating ETA (transit)");
        return 3;
    }

}

public class Walking implements Travel {

    @Override
    public Object getEta() {
        System.out.println("Calculating ETA (walking)");
        return 4;
    }
}

Conclusion: Elevating Design to Artistry

In conclusion, the State Pattern transcends mere code—it embodies a paradigm shift in design philosophy. By embracing abstraction and encapsulation, developers can sculpt intricate systems with ease, fostering resilience in the face of change. So, the next time you embark on a coding odyssey, remember the State Pattern—a brushstroke of genius in the tapestry of software design.

Memento Design Pattern

Sajjad Ali — Thu, 14 Mar 2024 22:40:50 +0000

As software engineers, we often grapple with the challenge of managing an object’s state. Whether it’s undoing user actions, implementing version control, or creating snapshots, the Memento Pattern comes to our rescue. In this article, we’ll delve into the intricacies of this design pattern, explore its real-world applications, and understand how it can elevate your code to new heights.

What Is the Memento Pattern?

The Memento Pattern is like a time-travel machine for your objects. It allows you to capture an object’s internal state without exposing its nitty-gritty details. Imagine being able to save and restore an object’s past states effortlessly—like rolling back to a previous checkpoint in a video game.

How Does It Work?

The Players: Originator: Our main character—the object with an internal state.
Caretaker: The curious observer who wants to manipulate the originator but also needs an escape route. Memento: The magical capsule that holds the originator’s state.
The Plot Unfolds: The caretaker requests a memento from the originator (to save its internal state). The caretaker performs some operations on the originator. If things go awry, the caretaker hands back the memento to the originator (to restore the previous state).

Real-World Scenarios

Undo/Redo Functionality

Imagine building a text editor. Users make changes, delete paragraphs, and insert emojis. With the Memento Pattern, you can save snapshots of the document’s state. When they hit “Undo,” voilà! The editor reverts to a previous version.

Version Control

Git, anyone? The Memento Pattern aligns beautifully with versioning. Each commit is a memento—a snapshot of your codebase. Rollback to a specific commit, and you’re back in time, debugging like a pro.

Custom Serialization

Ever needed to serialize an object in a specific way? Memento’s got your back. Save the internal state, transform it into a format of your choice, and restore it when needed.

Benefits of Using the Memento Pattern

Encapsulation Intact: The originator’s secrets remain hidden. No one messes with its private state.
Flexible Undo/Redo: Implementing undo/redo becomes a breeze.
Snapshot Magic: Capture moments in your application’s life cycle.

Implement Undo/Redo Features using Memento Design Pattern

UML Diagram for Memento Design Pattern

Code

import java.util.Stack;
public class EditorState {
    private final String content;
    private final String fontName;
    private final int fontSize;

    public String getContent() {
        return content;
    }

    public String getFontName() {
        return fontName;
    }

    public int getFontSize() {
        return fontSize;
    }

    public EditorState(String content, String fontName, int fontSize) {
        this.content = content;
        this.fontName = fontName;
        this.fontSize = fontSize;
    }

}

public class Editor {
    private String content;
    private String fontName;
    private int fontSize;

    public int getFontSize() {
        return fontSize;
    }

    public void setFontSize(int fontSize) {
        this.fontSize = fontSize;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getFontName() {
        return fontName;
    }

    public void setFontName(String fontName) {
        this.fontName = fontName;
    }

    public EditorState createState() {
        return new EditorState(content, fontName, fontSize);
    }

    public void restore(EditorState state) {
        content = state.getContent();
    }
}

public class History {
    private Stack<EditorState> states = new Stack<>();

    public void push(EditorState state) {
        states.push(state);
    }

    public EditorState pop() {
        return states.pop();
    }

}

public class Main {

    public static void main(String[] args) {
        Editor editor = new Editor();
        History history = new History();

        editor.setContent("a");
        history.push(editor.createState());

        editor.setContent("b");
        history.push(editor.createState());

        editor.setContent("c");
        editor.restore(history.pop());

        editor.restore(history.pop());

        System.out.println(editor.getContent());
    }

}

Conclusion

The Memento Pattern isn’t just a design pattern; it’s a time-traveling companion. So next time you need to save and restore states, channel your inner caretaker and embrace the magic of mementos.

Remember, every object has a story to tell—let the Memento Pattern be your ink and parchment.

Palindromes in C++

Sajjad Ali — Fri, 20 Jan 2023 07:10:34 +0000

What is Palindrome?

A palindrome is a word, phrase, number, or other sequence of characters which reads the same backward as forward, such as "madam" or "racecar". It is often used in literature and word play.

Palindromic numbers are numbers that remain the same when their digits are reversed, such as 121 or 73837.

Palindromic dates, such as 02/02/2020 or 11/11/1111, are also a popular example of palindromes.

Palindrome can be applied on sentences, numbers, phrases or even in programming languages.

Define a function in C++ that checks whether the input string is palindrome or not?

#include <iostream>
using namespace std;

bool isPalindrome(string text){
  int start = 0, end = text.length() - 1;
  while(start < end)
    if(text[start++] != text[end--])
        return false;
  return true;
}

int main() {
    std::cout << isPalindrome("madam");
    return 0;
}

We are comparing each ith character to ith last character. If they are equal then we proceed forward else we return false.

MVVM Architecture in Android development

Sajjad Ali — Fri, 20 Jan 2023 06:47:53 +0000

MVVM (Model-View-ViewModel) is a design pattern that is commonly used in Android app development. It is a variation of the MVC (Model-View-Controller) pattern and is designed to help developers separate the concerns of the app's user interface from the underlying data and business logic.

The Model represents the data and business logic of the app. It is responsible for handling data operations, such as retrieving and storing information.

The View is the user interface of the app and is responsible for displaying the data to the user. It communicates with the ViewModel to get the data it needs to display.

The ViewModel is an intermediary between the Model and the View. It acts as a link between the two, providing the data that the View needs to display and handling user input. It also implements the app's business logic and communicates with the Model to perform data operations.

MVVM is often used with the Android Data Binding Library, which allows developers to bind the ViewModel's data to the View, eliminating the need for explicit data passing between the ViewModel and the View.

Overall, the MVVM pattern makes it easier to write maintainable, testable, and scalable code for Android apps by separating the concerns of the user interface and data handling.

Android Networking with Volley

Sajjad Ali — Wed, 07 Dec 2022 12:33:45 +0000

Volley is an HTTP library that makes networking for Android apps easier and most importantly, faster. It is available on GitHub.

Code

In this article, We will be creating a small Android project using Kotlin. I have chosen Kotlin as it provides faster development compared to Java. You can choose Java if you want to. The source code is available at GitHub

Step 01

Create an Android studio project, and name it whatever you like.

Step 02

Add the following permission in the manifest file since we would be fetching data from the internet:

<uses-permission android:name="android.permission.INTERNET"/>

Step 03

Add the following dependency to your grade file. You may update the version number based on the version of your tool set.

implementation 'com.android.volley:volley:1.2.1'

Step 04

Create a queue that will manage our volley requests. The following line of code would do it for us:

val queue = Volley.newRequestQueue(this)

here, this refers to the current application context. You may include it anywhere in your code. For simplicity add it in onCreate method of your activity.

Step 05

Create a request object. There are four types of requests available in Volley:

JsonObjectRequest
JsonArrayRequest
ImageRequest
StringRequest

We would be working with StringRequest. It requires four things from us:

Method: GET, POST, etc.
Source link
Listener for success
Listener for failure

Here's the code

 val request = StringRequest(
            Request.Method.GET,
            "https://jsonplaceholder.typicode.com/users",
            Response.Listener<String> {
                findViewById<TextView>(R.id.textview).text = it
            },
            Response.ErrorListener {Log.d("error",it.toString())}
 )

Step 06

Add the request to the queue object:

 queue.add(request)

Final code

Main Activity

package com.example.volleydemo

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.widget.TextView
import com.android.volley.Request
import com.android.volley.Response
import com.android.volley.toolbox.StringRequest
import com.android.volley.toolbox.Volley

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val queue = Volley.newRequestQueue(this)
        val request = StringRequest(
            Request.Method.GET,
            "https://jsonplaceholder.typicode.com/users",
            Response.Listener<String> {
                findViewById<TextView>(R.id.textview).text = it
            },
            Response.ErrorListener {Log.d("error", it.toString())}
        )

        queue.add(request)
    }
}

UI

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <ScrollView
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        >
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Hello World!"
            android:id="@+id/textview"
            />
    </ScrollView>

</LinearLayout>

Thanks!

Forem: Sajjad Ali

Building a Robust End of Service (EOS) Valuation System: Lessons from a Real-World Actuarial Project

The Core Problem

Model Design: Supporting Variations Without Duplication

IAS 19 First-Time Adoption: A Hidden Complexity

Valuation Periods: Time Is a First-Class Input

Data Integrity Checks: Where Most Real Issues Appear

Automation with a Human-in-the-Loop

Key Takeaways

Final Thoughts

Understanding CORS: Why It Matters and How to Implement It in Node.js and FastAPI

🧠 What is CORS?

🧪 Example:

🔒 Why CORS is Important

⚙️ How CORS Works

🚀 Implementing CORS in Node.js (with Express)

✅ Basic Setup:

🐍 Implementing CORS in FastAPI (Python)

✅ Basic Setup:

🔧 Best Practices

🧵 TL;DR

Git Tags: The Unsung Hero of Version Control

The Problem: "What Commit Did We Ship?"

So What Exactly Are Git Tags?

Quick Example: Tagging a Release

Lightweight vs Annotated Tags

1. Lightweight Tags

2. Annotated Tags

Pro Moves: Tags + CI/CD

Git Tag Cheat Sheet 🧠

Friendly Reminder: Semantic Versioning Exists for a Reason

TL;DR — Why You Should Care

Supercharge Your Prototyping with Streamlit: A Quick and Powerful Web Framework 🚀

Why Streamlit?

🚀 Benefits of Streamlit:

Getting Started with Streamlit

📌 Installation

🔥 Creating Your First App

Building an AI-Powered Web App

Deploying Your Streamlit App 🌍

Final Thoughts 💡

Why You Should Use Prisma ORM in Your Next Project 🚀

Why Choose Prisma? 🤔

Setting Up Prisma with Next.js 🌐

Step 1: Install Dependencies

Step 2: Initialize Prisma

Step 3: Define Your Schema

Step 4: Run Migrations

Step 5: Use Prisma in Your API

Setting Up Prisma with FastAPI ⚡

Step 1: Install Prisma for Python

Step 2: Initialize Prisma in Your FastAPI Project

Step 3: Define Your Schema (prisma/schema.prisma)

Step 4: Generate Prisma Client

Step 5: Use Prisma in FastAPI

Conclusion 🎯

Choosing the Right Charting Library for Your React Dashboard

✅ React-ApexCharts

✅ React-Plotly

✅ Recharts

🔥 Which Charting Library Should You Choose?

🚀 Other Alternatives

💡 Conclusion

Why You Should Avoid Pandas in Production Applications

The Problem with Using Pandas in Production

What Are the Better Alternatives?

Conclusion

What should you use instead?

What do you think?

State Pattern | Design Patterns

Unveiling the State Pattern

The Pitfalls of Tradition

Embracing Abstraction

Harnessing the Power

State Pattern in Practice

Conclusion: Elevating Design to Artistry

Memento Design Pattern

What Is the Memento Pattern?

How Does It Work?

Real-World Scenarios

Step 3: Define Your Schema (`prisma/schema.prisma`)