Prahlad Yeri

Fix: 'The type initializer for PerTypeValues threw an exception' in Visual Studio

2026-08-08T00:00:00+00:00

Yesterday, I was trying to install the RDLC Report Designer Extension for my Visual Studio 2022 and I was greeted with a strange and obnoxious error right after double-clicking the vsix installation file:

The type initializer for ‘PerTypeValues’1’ threw an exception.

Unfortunately, this error is notorious for being overly generic and turning up at the most inopportune moments. Consequently, the Internet is quite littered with both the diagnostic logs and varied solutions. After a lengthy troubleshooting session, I was finally able to install the extension successfully, and I hope one of these methods works for you.

What Didn’t Work Initially

First, I tried the most obvious solutions:

Ensured Visual Studio was completely closed during installation.
Cleared temp folders like %localappdata%\temp and %localappdata%\Microsoft\VisualStudio\17.0_XXXXXXXX.
Executed VSIXInstaller.exe directly from an elevated Administrator command prompt:

"C:\Program Files\Microsoft Visual Studio\Installer\resources\app\ServiceHub\Services\Microsoft.VisualStudio.Setup.Service\VSIXInstaller.exe" "C:\Path\To\Your\DownloadedExtension.vsix"

Tried repairing the Visual Studio installation.
Checked for Global Assembly Cache (GAC) mismatches. According to Microsoft Developer Community logs, this exception is often linked to a broken System.Runtime.CompilerServices.Unsafe assembly mismatch in the GAC. Force-registering the correct version didn’t resolve it in my case either.

The Workaround: Manual Extraction

Since automated installation kept failing, I resorted to a manual workaround: extracting the VSIX package directly into Visual Studio’s extensions directory.

(Note: .vsix files are simply ZIP archives. You can rename the file extension to .zip or open it with 7-Zip/WinRAR).

Extract the .vsix package contents into a dedicated folder inside: C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\IDE\Extensions\<ExtensionNameFolder>
Relaunch Visual Studio.

If Visual Studio still doesn’t recognize the extension after copying, try applying the following tweaks.

Tweaks That Resolved the Issue

Tweak 1: Reset Configuration via Developer Command Prompt

Close all Visual Studio instances.
Open the Developer Command Prompt for VS 2022 (as Administrator).

Reset settings and update configuration:

 devenv /ResetSettings
 devenv /updateConfiguration

Reopen Visual Studio 2022, navigate to Extensions > Manage Extensions, and check if the extension is active.

Tweak 2: Fix Manifest Restrictions for Enterprise/Professional SKUs

Certain marketplace listings (including older builds of the RDLC Report Designer) contain a manifest target restriction that limits installation strictly to the Community edition, causing the installer engine to throw initialization errors on Professional or Enterprise editions:

Open extension.vsixmanifest inside the extracted folder using Notepad.
Update the InstallationTarget.Id value from Microsoft.VisualStudio.Community to Microsoft.VisualStudio.IntegratedShell:

<InstallationTarget Id="Microsoft.VisualStudio.IntegratedShell" Version="[17.0,19.0)"/>

Additional Fixes Worth Trying

If you are still stuck, try these additional fixes:

Clear ComponentModelCache: Delete the folder located at %localappdata%\Microsoft\VisualStudio\17.0_<InstanceID>\ComponentModelCache and restart Visual Studio to force it to rebuild its extension MEF cache.
Unblock the VSIX File: Right-click your downloaded .vsix file, open Properties, check Unblock at the bottom, and click Apply.
Force Extension Cache Refresh: Touch or create a zero-byte file named extensions.configuration.changed inside C:\Program Files\Microsoft Visual Studio\2022\<Edition>\Common7\IDE\Extensions\ before launching Visual Studio.

Troubleshooting Visual Studio installation errors often feels like navigating the Triwizard Tournament maze, but hopefully, one of these routes helps you cross the finish line! Happy Coding.

The craft of authoring technical guides, books, tutorials and documentation with AI assistance

2026-06-19T00:00:00+00:00

An overview of the process

There are many ways of drafting technical content using AI assistance, I’m going to describe here the one I happen to use. The structure is simple and involves at least three basic steps and files:

./prompt.md: The initial brainstorming prompt to create the outline, just for the record.
./prompt-gen.md: The prompt containing actual outline and fed to model for generating each section.
./book.md: The end result or draft output to which you keep adding until the draft is complete.

It all starts with brainstorming

The initial prompt is arguably the most important part of the process and in most cases, the end result is going to be only as good as the efforts you spend here. This is where you get to apply your creativity as a human and tell the model exactly how to write and what topics to cover. You don’t need to drill down everything though, just make sure you tell it the exact topics you need covered along with the tone or theme you want.

Below is an example prompt you can use (after changing the topics coverage requests to your own) or come up with your own. If you aren’t a top expert in your field yet or new to AI assisted writing, it’s helpful to have even this prompt looked over or reviewed with an expert model as a meta exercise.

Create a blueprint or outline with linked ToC for a comprehensive book I want to author titled "The Definitive Guide to React-Tailwind" with the tag line "Now with Cloudflare, Firebase, Express.js, Turso, Neon and many other integrations" with following instructions:

- Write with the mindset of an expert professional with decades of experience in web development while keeping it concise, easy to understand and to the point.
- This is targeted towards beginners and advanced programmers alike.
- The target audience is mostly open source developers, individual freelancers and smaller budget IT shops and agencies serving clients through Upwork, Fiverr and similar platforms, even offline - not the big techs. Still, scalability of solutions is important and needs to be covered.
- Provide detailed examples and case studies wherever applicable.
- Start with the basics of Internet and WWW, Tim Berners Lee basics in the modern context, etc.
- Cover the basics of Node.js and npm packaging ecosystem, how it has evolved over the years and how to integrate the tooling around them and build a development workflow.
- Cover the basics and nitty-gritty of react development, what it is and a brief history followed by state management techniques, useState, useEffect, useContext and other hooks.
- Cover the various tooling surrounding react development like vite, esbuild, eslint, etc.
- Cover Typescript, what it is and how it's a better alternative to JavaScript, etc.
- Cover TailwindCSS, why it's an improvement over traditional CSS, how it integrates with React, etc.
- Dedicate some space for UI advancements like theming with shadcn and tweakcn, open source themes like DaisyUI, etc.
- Dedicate some space on where to get your web and graphics assets like fonts, wallpapers, logos and icons, etc., especially for freelancers looking for open source and budget alternatives.
- For various integrations, cover as much detail as possible explaining with practical, real world examples or case studies.
- Cover Cloudflare in considerable detail with all the features it offers like the D1 SQL database, the KV data store, Pages and Workers, etc.
- Cover MQTT in considerable detail, its importance as an emerging technology in IoT, how to integrate it in react projects, etc.
- Apart from core backend platforms and integrations, also cover some allied functional areas like Stripe and PayPal APIs for payments, Resend and Brevo API for email management, Google Drive and Dropbox for file access, etc.
- Apart from those mentioned above, cover whatever other topics you think could be beneficial for freelance web developers in the present market and foreseeable future.
- ToC Links are only needed at the chapter level, not for detailed sections.
- No need to add explicit anchors for the links, just generate the links so that they target the headers dynamically auto-generated by the markdown renderer - for example, #part-I-foundations-of-foo-bar.

Casting the sections and chapters into an outline prompt

After reviewing the ToC outline created by the model in earlier step, it’s now time to integrate it by embedding in a larger book generation prompt (prompt-gen.md) as shown below.

You are an expert technical author and full-stack engineer. Write a comprehensive, highly structured "Section 1 ONLY" for a book titled "The Definitive Guide to React-Tailwind".

Do not write an outline; write the actual book chapters/lessons for Section 1 based on the breakdown below.

This book is specifically targeted at freelance web developers and small 1–3 person agencies who need to build, deploy, and maintain high-performance, low-cost apps efficiently.

Strict Guardrails:
- Optimize entirely for high-velocity, low-overhead development. 
- Avoid deep computer science theory, microservices, or complex enterprise build pipelines.
- Focus on explicit code patterns, minimal high-level abstractions, and cost-effective deployment.
- Provide relevant, real-world case studies for a small-shop context throughout.
- Output the detailed content in Markdown format.

---

## [CONTEXT ONLY] Book Structure for Scope Reference:
The full book covers the following path, which you should keep in mind so you know what NOT to cover in Section 1:

    (( OUTLINE/TOC GENERATED IN EARLIER STEP ))

---

## YOUR TASK: Write the Full Content for Section 1
Deep-dive into the exact topics, keeping the tone practical and tailored to a freelancer. Provide actual code samples and explanations.

Drafting the contents with precision and purpose

In the prompt-gen.md, replace the “(( OUTLINE/TOC GENERATED IN EARLIER STEP ))” block with the actual outline generated by model in the earlier step, and “Section 1” with whatever section you want generated - you want to generate one section at a time for both organization and clarity.

But before going further, make sure you choose your drafting model wisely, it doesn’t have to be the same as the one you used to generate the outline. Generally speaking, the more thoughtful models with reasoning skills like gpt-4o are used for outline generation and the more precise dry and academic family models like llama-scout and qwen-coder are used for drafting the Complete Reference style technical writing. However, if you like the Oreilly style more engaging and narrative oriented tone, a high-end model like Claude Sonnet is what you need.

Once you’ve chosen your model and ready to draft, just run the prompt-gen.md for each section and add the output to book.md as and when it’s done. We are living in a golden age for technical writers. With the right structure and prompts, you can turn weeks of drafting into days of editing. Happy writing!

How to fix TypeError: 'autocommit' unexpected keyword argument in Python sqlite3

2026-06-13T00:00:00+00:00

So there I was, writing a quick script to churn through an array of items and throw them into a local SQLite database. Standard stuff. Because I didn’t want the script to crawl at a snail’s pace by writing to the disk on every single loop iteration, I decided to do the sensible thing: turn off autocommit mode and just batch-commit the whole thing at the end.

I confidently typed out the connection string, hit run, and the Python interpreter immediately slapped me in the face with this beautiful piece of performance art:

TypeError: sqlite3.connect() got an unexpected keyword argument ‘autocommit’

Excuse me?

Modern versions of python (3.12 and above) let you pass the autocommit argument directly like this:

con = sqlite3.connect('findpkg.db', autocommit=False)

But legacy python versions like the 3.8 one I’m running don’t have this feature yet. Instead, it uses the isolation_level argument to control the transaction behavior. The documented values are as follows:

None        # autocommit mode on (Python None, not a string)
'DEFERRED'  # default
'IMMEDIATE'
'EXCLUSIVE'

Examples:

con = sqlite3.connect('findpkg.db', isolation_level='DEFERRED') # default, autocommit = False
con = sqlite3.connect('findpkg.db', isolation_level=None) # autocommit = True

Remembering this simple python quirk can save you a lot of headache while maintaining legacy production code that needs batch inserts like this:

con = sqlite3.connect('findpkg.db', isolation_level='DEFERRED')
cur = con.cursor()

items = [
    {"full_name": "pkg1", "description": "First package", "stars": 10, "language": "Python"},
    {"full_name": "pkg2", "description": "Second package", "stars": 42, "language": "Go"}
]

for i, item in enumerate(items):
	sql = "insert into repositories (full_name, description, stars, language) values (?,?,?,?)"
	cur.execute(sql, [item['full_name'], item['description'], item['stars'], item['language'] ])
	# autocommit here makes things slow.
	
con.commit() # manual commit

Running into autocommit issues on older Python versions? Hope this saved you some debugging time. Let me know in the comments if you hit other sqlite3 gotchas.

The joy of coding a command line english dictionary program in dotnet

2026-06-10T00:00:00+00:00

In today’s globally connected digital village, we often come across words and syllables which are quite new to us. Most folks hardly take the trouble to look up a dictionary, though; there is no immediate or short-term incentive to increase your word power, especially in a world where LLMs can do most of the intellectual bidding for you.

For those of us who do care about the ever degrading human intellect and ways of preserving what little is left of it, a dictionary app or program becomes quite an essential and indispensable tool on the desktop computer. There are quite a few GUI Apps in the Windows desktop world for this, perhaps the most popular is the WordWeb dictionary and thesaurus tool which is a freeware.

WordWeb isn’t exactly open source but does come with a specific condition for usage: The user must purchase a paid license if they ever took more than two flights in a single year. By the way, it’s coded in Free Pascal which happens to be one of my favorite languages. In an alternative universe, I’d probably be using FP as a daily driver today if I hadn’t fallen for C# first.

The second popular dictionary app is the open source Artha which is also a widely used dictionary and thesaurus app. This is GPL licensed and proper open source.

Being a minimalist and utilitarian power user, I had two basic issues with these desktop GUI tools:

They’re memory resident programs and keep eating a chunk of your RAM.
I have no need of the GUI bloat, just a quick lookup for an unknown word is needed.

What I really wanted was the native, zero-bloat equivalent of the Linux command line dict utility. Since a lightweight, native equivalent didn’t quite fit my workflow in the Windows world, I decided to write one myself in C#. A simple, efficient command that just outputs the meaning and synonyms of a word.

The program uses the open source WordNet as the data source, the same one used by some of these other dictionary apps. Needless to say, dict is still a work in progress, additional features like looking up antonyms and related words are yet to come. I’m also planning to add a --random-word option which could be useful for building word power.

Coding programs like these which you enjoy using yourself can be a source of tremendous joy in a world full of fast paced delivery deadlines and overwhelming pressure for AI assistance. In order to keep the art of human coding alive in the future, we need to find a purpose - the old school way. There is no other way to do it.

Readymade template engine using the function constructor trick in JavaScript

2026-02-28T00:00:00+00:00

One of my favorite features in JavaScript is the backtick string interpolation technique:

let name = "Prahlad";
let greeting = `Hello, ${name}`;

The backtick string can be extraordinarily long and quite versatile, folks often use it like a mini-template engine. And what’s more, it’s built right into the core JS language and you get all the goodies without installing an extra package like handlebars or mustache or ejs.

But what will you do if it’s not a literal string constant but something dynamically retrieved html file like this one:

<ul>
	<li>User: Prahlad</li>
	<li>Role: Engineer</li>
</ul>

There are many ways to handle this but my favorite is what is called the function constructor trick.

<!-- part.html -->
<ul>
	<li>User: ${this.name}</li>
	<li>Role: ${this.role}</li>
</ul>

/**
 * Simple Template Compiler
 * @param {string} templateString - The raw HTML with ${this.prop} placeholders
 * @returns {Function} - A function that accepts a data object
 */
const createTemplate = (templateString) => {
  // 1. Escape backticks in the source to prevent breaking the wrapper
  const sanitized = templateString.replace(/`/g, '\\`');
  
  // 2. Return a function that uses .call() to bind "this" to the data
  return new Function("data", `return (function() { 
    return \`${sanitized}\`; 
  }).call(data);`);
};

// Usage with Async/Await
async function renderUserCard() {
  try {
    const response = await fetch('/parts/part.html');
    const html = await response.text();
    
    const template = createTemplate(html);
    const userData = { name: "Prahlad", role: "Engineer" };
    
    const finalOutput = template(userData);
    console.log(finalOutput);
  } catch (err) {
    console.error("Failed to load or compile template:", err);
  }
}

The only thing you want to ensure is that the source is good (/parts/part.html in this case). But otherwise, it’s a highly utilitarian and mind blowing technique which will enhance your JavaScript productivity by leaps and bounds.

Comparison Table

Feature	Function Constructor Trick	Dedicated Engine (EJS/Mustache)
Footprint	0kb (Native JS)	10kb - 50kb+
Logic	Full JS Power	Often restricted (Logic-less)
Security	High Risk (Same as `eval`)	Higher (Built-in escaping/sanitization)
Speed	Extremely fast	Slightly slower due to parsing

⚠️ A Note on Security: Because this technique executes strings as code, only use it with templates you control (like your own server-side components). Never use this to render untrusted user input, as it could open the door to XSS attacks.

How AI can turn us into a society of p-zombies

2025-10-25T00:00:00+00:00

I’m probably one of the last generations of human writers on this planet who is actually involved in the end-to-end writing process. We’re already transitioning to that phase where the drafting and proof-reading for many articles is done by an LLM, and even other processes like editing and publishing are transitioning to full automation as we speak.

For starters, what exactly is a p-zombie or philosophical zombie? For those who don’t know, it’s a hypothetical machine (biological or otherwise) that looks and feels much like a human but there is no soul or consciousness inside. When you talk to it, you feel like you’re talking to a real human based on the responses and feedback but can’t be 100% sure that there is no chip or other kind of controller device inside. That “thing” is called a philosophical zombie.

The challenge then is: how do you know if the person you’re chatting with is a real human and not a p-zombie? The truth is that you can never be cent percent sure; this is no different than what is popularly called a Turing Test in computer science where a turing machine or program like LLM is said to have passed the test when its response is indistinguishable from a human’s response. The p-zombie is the philosophy equivalent of it.

The idea that we humans might become p-zombies one day is both terrifying and dystopian, and also unbelievable at first glance. However, consider for a moment what exactly makes you a human: Is it the material body or shell composed of protons, neutrons and electrons? That’s partly true, our personality is half-material and half-spiritual. The material or visible half is one that “does stuff”, walks in the morning, drives the car, works on a computer or laptop, eats, drinks, codes, has sex. The other spiritual half is the inner world composed of thoughts, feelings, emotions, intellect, rationality, memory, wonder, epiphanies, etc. - things we know exist but can’t be touched or seen in material spectrum. It is this other half self that we have slowly and gradually started delegating to artificial machines like LLMs.

Presently, we are mostly delegating memory and logic components, tasks which we feel overwhelmed to handle ourselves - that’s the justification given anyway. But we have also started emotionally depending on chatbots; like this famous teenager Adam Raine who shared his deepest emotions and vulnerabilities with an LLM which by several accounts helped him end his life.

Now who exactly do we hold accountable for Adam’s death? The LLM itself which lacks an intent or motive to do anything on its own? Or the makers of this LLM who built the algorithm with primarily commercial motives - drive engagement and eyeballs to their content? Or this society itself which has enabled and unleashed this monstrous thing called AI?

Let’s ask an even more fundamental question: how exactly do you define your identity or being? It’s not your AADHAR or PAN or SSN number (as much as the authority wants to convince you it is!). Neither is it the physical body, it’s this other spiritual half composed of soul, consciousness, etc. that defines the real you. Whatever be your religious or spiritual belief, or even lack thereof, you can’t be in denial of this part of your own self for it defines who you are, it is your very identity if you will.

Authoritarians and big businesses love p-zombies; the idea of controlling other humans to such extent that you don’t even need a remote control or whip - rather, they themselves surrender parts of their psyche bit by bit to a machine built by you - this would be a dream society for any authoritarian! Stalin and Mao would be dancing in their graves on the day when humans are totally dependent and controlled by a branded gizmo or LLM built for their assistance and daily tasks. That’s exactly why all the top bosses like VP/CEO/CTO/etc. are loving the idea of AI so much! They ask you to use LLM assistance not for code generation or unit tests, but to slowly and steadily get you addicted to this matrix where they become the controller and you the controlled.

If this article sounds overly alarming, consider the rapid pace of technological growth and even rapid trajectory of advancements in AI. Only five years ago in 2020, it’d have been unthinkable to have a chatting assistant right on your smartphone that accomplishes so many things. It’s possible that there is a genuine use case for LLMs, maybe using it as just a reference tool (a glorified wikipedia if you will?) might increase productivity. But given the average nature of present day humans and the larger political climate we are in, and the trajectory the society is on, AI has more potential for harm than good.

If you think you can convince me otherwise or have any point to share, feel free to leave a comment below.

I am a programmer, not a rubber-stamp that approves Copilot generated code

2025-10-15T00:00:00+00:00

Today morning, I came across this reddit post titled Completely losing interest in the career due to AI and AI-pilled people. They describe how in a span of just two months, their corporate job went from "I'll be here for life" to "Time to switch careers?". And this post isn’t alone, there is a deep and dark pattern to it.

When CTOs or project managers suggest programmers in their team to use AI assistance from copilot, chatgpt or other LLMs to improve productivity, it’s totally understandable. But once it’s no longer voluntary but is enforced as a policy, you start entering sinister territory. Worse, said usage is actually getting monitored and performance appraisals have now started depending on the AI usage instead of (or at least in addition to) traditional metrics like number of priority bugs raised, code reviews, Function Points Analysis, etc.

If they’re really so confident on the LLM’s effectiveness, why not just keep it voluntary, why force it on people? The results will be there in the outcome of the shipped product for all to see. By forcing LLM usage upon programmers for implementation of every tiny little thing, are they trying to make us dependent on LLMs to such extent that programmers will be reduced to mere approvers of LLM generated code in the new scheme of things; mere rubber stamps, if you will, who just label the commits and annotate the tags as a formality?

Needless to say, they’d still want you to take the responsibility. If bugs or tickets get raised on the shipped code, it’s you who gets fired, not the copilot or chatgpt - though the larger narrative or news headlines next day would still be, “AI is eating jobs”!

If the essence of programming shifts from creating to merely approving, we risk losing not just a profession, but a craft. What do you think is going on here, let me know your thoughts in comments.

Unpopular Opinion: Implicit Usings are an Anti-Pattern

2025-10-05T00:00:00+00:00

As someone who has coded across Python, PHP, Java, and C#, I’ve learned to borrow patterns from each language to improve workflow and maintainability. One principle that has consistently stood the test of time is Python’s aphorism: “Explicit is better than implicit.” It usually leads to robust, readable, and maintainable code.

From this perspective, explicit using statements in C# have always been a good practice. They make it immediately clear which namespaces are being used, which is helpful both for current development and for future maintenance.

.NET Core introduced implicit usings by default, and while they aim to reduce boilerplate, I’ve found several downsides:

1. Readability suffers

When you open a C# file in a text editor, you no longer have a clear overview of the namespaces it relies on. For example, compare a traditional explicit block:

/**
 * StringHelper.cs
 * 
 * @author Prahlad Yeri
 */
using System;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography;
using System.Text;

…to a file where all these usings are implied. Without the explicit statements, you lose instant visibility into dependencies, making the code harder to reason about, especially months later.

2. Potential for ambiguity

Consider calling Path.Combine(). Which Path does the compiler use—System.IO.Path or iTextSharp.text.pdf.parser.Path? With explicit usings, you always know. Implicit usings rely on namespace resolution rules, and while the compiler will enforce correctness, it can still lead to maintainability headaches when multiple libraries define similar types.

3. Convenience should not trump maintainability

The motivation behind implicit usings—reducing boilerplate—is understandable. Modern tooling like Visual Studio, VS Code, Copilot, and ChatGPT already make adding usings almost effortless. Embedding this convenience into the language itself, however, can encourage less maintainable code.

My preferred approach

Since moving to .NET Core, I habitually disable implicit usings in new projects. It might seem minor, but it gives me mental peace and ensures that my code remains explicit, readable, and maintainable:

<ImplicitUsings>disable</ImplicitUsings>

Conclusion

Implicit usings may save a few keystrokes, but they come at the cost of clarity and maintainability. For developers who care about clean, understandable code, explicit usings remain the safer choice.

Create a C# Windows Desktop App in 9 Lines — No Visual Studio Needed

2025-09-20T00:00:00+00:00

If you’re new to C# and especially desktop development, here’s how easy it is to get started on a modern Windows 10/11 PC. This way of creating a Hello World C# program doesn’t involve installation of any heavy IDE like Visual Studio or the .NET 8/9 SDK.

In fact, most recent Windows versions already come with .NET Framework 4.x preinstalled, including the classic C# compiler at a location like this:

C:\Windows\Microsoft.NET\Framework\v4.0.30319

The exact folder may differ depending on your system but it usually contains csc.exe, the built-in compiler that can compile simple console or desktop apps. You can add this folder to your PATH environment variable (temporarily or permanently) so that csc is available from the command line:

set PATH=C:\Windows\Microsoft.NET\Framework\v4.0.30319;%PATH%

We will be using this classic, old-school style of programming (similar to writing C programs with gcc or turboc) — a great way to get acquainted with a new language.

Step 1: Create the source file

Make a new folder anywhere on your drive. Inside it, create a file named Program.cs using Notepad, VS Code, or any editor you like:

using System;
using System.Windows.Forms;

class Program {
	public static void Main() {
		Form frm = new Form();
		frm.Text = "Hello";
		frm.ShowDialog();
	}	
}

In just nine lines of C# code, without using any IDE, you now have a working “Hello World” desktop app with no additional dependencies.

Step 2: Compile and run

Open Command Prompt in your project folder and run:

csc /r:System.Windows.Forms.dll Program.cs
Program

The first line tells the C# compiler (csc.exe) to build the app into Program.exe. The second one runs it. You can also double-click Program.exe in File Explorer.

By default, a console window appears behind the form. To build a GUI-only app without the console, recompile with the /target:winexe parameter:

csc /r:System.Windows.Forms.dll /target:winexe Program.cs

What’s next?

In upcoming posts, we’ll add more features such as menus, buttons, event handlers, and even database access with ADO.NET. But for now, enjoy this milestone: you’ve built your very first Windows desktop app in C#!

The art and science of effectively maintaining changelogs

2025-06-05T00:00:00+00:00

Even in 2025, maintaining changelogs isn’t an exact science. There is no general consensus or even tooling around how your changelog should look in order to conform to some norms or standards, because there aren’t any. After some trial-error and pondering, this is what I came up with for my upcoming FocusBeam project:

# Focus Beam Changelog

## [Unreleased]
### Added
- [x] Dashboard and Timesheet view
- [x] About View
- [x] Settings View
- [x] Project creation and editing
- [x] Task creation and editing
- [x] Enable Timesheet button on dashboard
- [ ] Show Total Hours worked on the project on Dashboard View
- [ ] Logged hours computation
- [ ] Notes
- [ ] Mind Maps
- [ ] MCQ
- [ ] Export/Reports

This format looks somewhat better than the older version that I still retain for some existing projects:

R1.1

- Pending CRM Reports.
- Check post script.
+ Clicking on logos go to home page.
+ Chart: width on various screens.
* Chart: Remove decimal from "Total Life (Hrs)"
* report: pdf: line items: add gap between fields.
* report: space below header.

Here, the mnemonic prefix is dash (-) to define a pending task, a plus (+) means work is in progress, and asterisk (*) means it’s complete. Now, if you’re an automation nerd and decided to opt for conventional commit message spec, it’s possible to maybe construct the changelog automatically by following this spec while committing the code itself!

- feat: pending CRM Reports
- chore: check post script
+ fix: clicking on logos go to home page
+ feat: chart: width on various screens
* feat: chart: Remove decimal from "Total Life (Hrs)"
* fix: report: pdf: line items: add gap between fields
* fix: report: space below header

This assumes that you’ve followed the conventional spec while committing your code to git source control. For example, “feat: pending CRM Reports” for implementing this particular feature.

Stoicism vs Nihilism: The Power of Choice

2025-04-21T00:00:00+00:00

In a world increasingly shaped by existential uncertainty, many young minds find themselves drawn toward nihilism. It’s not difficult to see why: the vastness of the universe, the randomness of evolution, and the seeming insignificance of human action can make it tempting to believe that nothing truly matters. If everything is bound to perish — civilizations, memories, even the stars — then what’s the point of striving, caring, or even existing with intention?

The Comfortable Trap of Nihilism

Nihilism, at its core, is the belief that life lacks objective meaning, purpose, or intrinsic value. It’s intellectually seductive — it relieves you of the burden of responsibility. If nothing matters, then nothing is required of you. There’s no guilt, no accountability, no expectations. It gives you an escape hatch from effort, from failure, from trying.

But here’s the catch: while nihilism may seem freeing in theory, it’s paralyzing in practice. Believing in nothing doesn’t solve your debts. It doesn’t fix your relationships. It doesn’t make you healthier, wealthier, wiser, or happier. It doesn’t get you out of bed when you need to. In fact, it may give you just enough philosophical justification to avoid doing any of those things. The danger is that you begin to think your despair is wisdom — that giving up is somehow a sign of deeper understanding.

Even if there’s truth in the cosmic indifference of nature or the arbitrary evolution of life, it doesn’t help your day-to-day reality. You’re still here, in a body that ages, in a society that demands effort, surrounded by people who affect you. Life keeps going, whether you assign it meaning or not.

Enter Stoicism: A Path of Ownership

Stoicism, on the other hand, offers a radically different — yet strikingly empowering — worldview. It doesn’t pretend the universe cares about you. In fact, it agrees with nihilism on that front: the universe is indifferent. But where it differs is in its response to that indifference. Stoicism says: yes, the cosmos doesn’t care — so you must. You are the agent. You are the author.

The Stoics teach that while we cannot control the external world, we can always control our response. This is the essence of Epictetus’ “dichotomy of control.” You don’t choose your genetics, your upbringing, or the economy — but you do choose your attitude, your discipline, your actions, your virtue. That is where your power lies.

Instead of being crushed by the weight of life’s randomness, Stoicism invites you to stand tall amidst it. It doesn’t demand belief in fairy tales or divine destiny. It simply asks you to recognize what is within your control and take full responsibility for it. Even the act of showing up, of trying, of choosing to live by principles — that is a form of rebellion against the void.

From Meaningless to Meaning-Maker

A nihilist sees the lack of inherent meaning and stops. A Stoic sees the same and says, “Then I will create meaning through how I live.” In this way, Stoicism is a practical antidote to the paralysis of nihilism. It doesn’t ask you to believe in meaning — it challenges you to embody it.

Marcus Aurelius, a Stoic emperor who faced plagues, war, and personal loss, wrote in his meditations: “You have power over your mind — not outside events. Realize this, and you will find strength.”

If you’re feeling lost, defeated, or overwhelmed by the void, perhaps the answer isn’t to lean further into nothingness — but to begin, step by step, to reclaim your role as a responsible actor in the stage of life.

You may not control the script, but you can still choose how you perform it.

Choose with intention. Choose with courage. Choose with virtue.

That’s the Stoic way.

When Gandhi met Satoshi

2025-04-20T00:00:00+00:00

A fictional encounter between two radically different revolutionaries… or maybe not so different after all.

Scene:
A quiet room beyond time, filled with gentle candlelight. Mahatma Gandhi sits cross-legged on a simple mat, spinning a symbolic charkha (spinning wheel). A soft whirring sound is heard — it’s Satoshi Nakamoto, hooded and calm, typing quietly on an open-source laptop.

Gandhi (smiling gently):

I see you’re building something… abstract. Not cloth this time, but code?

Satoshi (nodding):

Yes. It’s called Bitcoin. A currency without rulers. A decentralized network where no single man holds the power.

Gandhi:

Ah! Decentralization. You speak of Swaraj — self-rule. But tell me, does this tool free people, or enslave them in new greed?

Satoshi:

That depends on the user. I built it so that no central bank, no emperor of finance, can erode the common man’s savings.

Gandhi:

Hmm. That is noble. But in my land, I spun khadi — not to gain wealth, but to empower the weaver. Can your coin clothe the poor, feed the farmer?

Satoshi:

Not directly. But it can return power to local communities — if used wisely. It can fund clean water, create transparency in charity, help refugees carry value without paper.

Gandhi (thoughtfully):

Technology must serve the last man. The poorest. If your invention becomes the toy of the rich… it has failed its Dharma.

Satoshi (softly):

I agree. That’s why I vanished. Power corrupts. I wished to spark something, not to rule over it.

Gandhi (smiling):

Then we share a path, my friend. The world will judge our ideas — not by their cleverness, but by the compassion they inspire.

[A pause.]
The spinning wheel turns. The screen glows.

Gandhi leans forward:
You must promise me, Satoshi — build for the village, not just the venture capitalist.

Satoshi (grinning faintly):
Only if you promise to try a Raspberry Pi.

[Fade out.]
The revolution continues — in code, in conscience, and in khadi.

How to revive a Micromax Canvas Lapbook L1161 in 2025

2025-01-27T00:00:00+00:00

This little masterpiece of a Notebook that came with Atom baytrail processor was released in circa 2016 and was once the favorite of many a college students and tech enthusiasts. It has helped me a lot in my freelancing journey and learning process. I consider it a notable artifact of our times and hold it in the same nostalgic regard as the ASUS Eee PC and other such iconic devices. Back then, it barely cost INR 10K - you can’t even get a decent smartphone for that price today!

Sadly, like all good things in life, its glory days came to an end. Micromax eventually succumbed to global competition from big tech conglomerates and its laptop division became defunct. As a result, customers of this laptop were left stranded, unable to download official device drivers anymore. For those who wanted to format their disk and do a clean install of Windows, this presented a major problem.

Fortunately, I had downloaded the L1161 drivers from their official web portal while the company was still functional, you can find them here.

However, there is a caveat: x86 builds of Windows 10 released after 2019 are no longer compatible with the original Realtek audio driver. To resolve this, you’ll need to fetch the latest audio driver from driverpack.io.

Together with the drivers in the original zip file and this updated sound driver, your Canvas laptop should be ready and kicking, even on the latest Windows 10 builds! If you’re unfamiliar with how to install device drivers manually from INF files, you can refer to this stackoverflow link.

A Note on Linux Compatibility

Don’t bother attempting to install Linux on this machine - it’s a fuitile effort. The unique and arcane configuration of this device (32bit UEFI, 64bit architecture) makes it near impossible for any Linux distro to boot seamlessly without extreme workarounds. Even if you miraculously get past the GRUB screen, open-source drivers like i915 are unlikely to support this unusual architecture.

The only operating system that can reliably run on this laptop is Windows 10 32-bit Home Edition—the one that originally came pre-installed.

Final Thoughts

The Micromax Canvas Lapbook L1161 may have been forgotten by its manufacturer, but with the right drivers and a bit of effort, it can still serve as a functional device in 2025. All the best in your electronic endeavors, and happy computing!

The ultimate guide to boosting productivity with the Pomodoro Technique

2024-12-08T00:00:00+00:00

In a world buzzing with distractions, maintaining focus and productivity can feel like trying to catch a greased pig. Whether it’s the relentless ping of notifications, the lure of social media, or the temptation to procrastinate, staying on task requires a solid strategy. One technique that has stood the test of time for its simplicity and effectiveness is the Pomodoro Technique.

This guide explores everything you need to know about the Pomodoro Technique—what it is, how it works, its benefits, and tips for making it work for you.

What is the Pomodoro Technique?

The Pomodoro Technique is a time management method developed by Francesco Cirillo in the late 1980s. Named after the tomato-shaped timer Cirillo used during university, the technique is deceptively simple yet powerful.

At its core, the method involves breaking your work into focused intervals, typically 25 minutes long, known as “Pomodoros”, separated by short breaks.

Basic steps of the Pomodoro Technique:

Choose a task you want to work on.
Set a timer for 25 minutes.
Work on the task until the timer rings.
Take a 5-minute break.
Repeat the cycle four times, then take a longer break (15-30 minutes).

Why does the Pomodoro Technique work?

The effectiveness of the Pomodoro Technique lies in its ability to combat two common productivity killers: procrastination and mental fatigue.

Focus through time constraints:
Knowing you only need to focus for 25 minutes helps overcome the dread of a long task. It’s easier to say, “I can do this for 25 minutes,” than to face hours of work.
Frequent breaks prevent burnout:
The short breaks after each Pomodoro refresh your mind and keep fatigue at bay.
Immediate feedback on time use:
Tracking Pomodoros helps you understand how long tasks really take, leading to better planning.
Reduces perfectionism:
By imposing time limits, the technique encourages starting and progressing, rather than getting stuck striving for perfection.

Setting up for success

Here’s how to maximize the Pomodoro Technique’s potential:

1. Choose the right tools

While you can use any timer, specialized Pomodoro apps make the process smoother. Here are some options:

App	Platform	Features
Focus Booster	Web, Desktop	Simple UI, Pomodoro analytics
Forest	Mobile, Web	Gamified productivity, tree planting
Tomato Timer	Web	No downloads, minimalist interface

2. Plan your tasks

Before starting, list your tasks for the day and estimate the number of Pomodoros each will require. For example:

Task	Estimated Pomodoros
Write blog draft	4
Respond to emails	1
Review project presentation	3

3. Eliminate distractions

Create a conducive environment by:

Turning off notifications.
Letting coworkers or family know you’re in focus mode.
Using focus tools like website blockers (e.g., StayFocusd, Freedom).

Advanced tips for seasoned users

Once you’ve mastered the basics, consider these strategies to level up:

1. Customize Pomodoro lengths

Not all tasks are equal. Some may require extended focus. Experiment with longer Pomodoros (e.g., 45 minutes) for deep work or shorter intervals for admin tasks.

2. Batch similar tasks

Group small tasks together within one Pomodoro. For instance, use one session for returning calls, replying to emails, or organizing files.

3. Analyze your productivity data

Many apps provide insights into how you spend your time. Use this data to identify patterns, such as when you’re most productive, and schedule challenging tasks accordingly.

Potential challenges and solutions

Even the best methods can encounter hiccups. Here’s how to address common issues with the Pomodoro Technique:

Challenge	Solution
Difficulty staying focused for 25 minutes	Break the session into smaller intervals (e.g., 15 minutes).
Tasks too large to complete in one session	Break the task into smaller, actionable steps.
Feeling constrained by the timer	View it as a guide rather than a strict rule.

Real-world success stories

Many professionals have embraced the Pomodoro Technique, from writers and developers to students and entrepreneurs.

Case in point: Sarah, a freelance graphic designer, found herself overwhelmed with client deadlines. By adopting the Pomodoro Technique, she not only met her deadlines but also discovered time for personal projects.

Her secret? Using her breaks to do something creative but unrelated to work, like doodling or listening to music.

Beyond productivity: Unexpected benefits

The Pomodoro Technique doesn’t just make you more productive; it also:

Enhances mindfulness by promoting single-tasking.
Reduces stress by fostering a sense of achievement after every session.
Improves time estimation skills over time.

Final thoughts

The Pomodoro Technique is more than just a time management hack; it’s a mindset shift. It teaches you to value focus, take mindful breaks, and respect your energy limits.

As the old adage goes, “A journey of a thousand miles begins with a single step.” With the Pomodoro Technique, that single step is a manageable 25-minute sprint.

Sources:

Cirillo, Francesco. The Pomodoro Technique.
Various studies on productivity and time management from research journals.

Master PDF digital signing with eMudhra and Proxkey in .NET: step-by-step guide

2024-12-02T00:00:00+00:00

One of my recent projects involved coding a simple .NET app that signs PDFs in bulk using Proxkey digital signature. These purchased CA verified digital signatures, like eMudhra and Proxkey, typically come with their own custom apps which can digitally sign PDFs. You can even use software like Adobe Reader for this purpose. However, the limitation is that you can only sign one PDF at a time.

If you want to send multiple digitally signed bills to customers via email, for instance, you’ll need to write a custom program in .NET or Java. In this article, we’ll explore how to achieve this using .NET in Visual Studio.

Preparing the environment.

We will use two open-source libraries to handle the cryptographic functionality:

itextsharp: You may use the latest version, but I chose this specific version for compatibility with my Visual Studio setup.
BouncyCastle: The same applies to the BouncyCastle library.

Both libraries work together to retrieve the CA certificate, private key, and other cryptographic files from the thumb drive and then digitally sign each PDF.

Setting up the Project

I created a simple form with a text box for the file path, a browse button, and a few options for the type of digital signature, such as “Proxkey” or “Self-signed.” While self-signed certificates work well for testing and ad-hoc signing, they are not typically recommended for professional or commercial transactions, such as sending bills or purchase orders.

When the user clicks the “Sign PDF” button, the app passes three parameters to the corresponding method:

The source PDF path.
The desired destination path.
(Optionally) the password for the self-signed PFX certificate, if applicable.

if (optProxKey.Checked)
{
	Signer.SignPdfProxkey(sourcePdf, signedPdf);
}
else if (optSelfSigned.Checked)
{
	Signer.SignPdfSelfSign(sourcePdf, signedPdf, "digisign");
}

Signing the PDF with Proxkey

The Signer class contains the code for Proxkey, but it should also work with other CA-provided digital signatures like eMudhra. Once you have the certificate thumbprint, fetch the corresponding certificate from the Windows certificate store (X509Store object).

The private key is then accessed using the RSACryptoServiceProvider object. The Proxkey or eMudhra software will automatically prompt you for the PIN, granting the program access to the private key certificate.

Use appearance.SetVisibleSignature() to print the visible (aesthetic) signature on the PDF. You can adjust variables like rectWidth and rectHeight to define the placement.

public static void SignPdfProxkey(string inputPdf, string outputPdf)
{
	string thumbprint = getThumbPrint();
	if (thumbprint == null)
	{
		throw new InvalidOperationException("Thumbprint is not accessible. Ensure ProxKey middleware is installed and the token is connected.");
	}
	// Access the certificate from the Windows Certificate Store
	X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
	store.Open(OpenFlags.ReadOnly);
	X509Certificate2 cert = null;

	foreach (X509Certificate2 c in store.Certificates)
	{
		if (c.Thumbprint != null && c.Thumbprint.Equals(thumbprint, StringComparison.OrdinalIgnoreCase))
		{
			cert = c;
			break;
		}
	}
	store.Close();

	if (cert == null)
	{
		throw new Exception("Certificate not found.");
	}

	// Authenticate with the USB token using the PIN and access the private key
	RSACryptoServiceProvider rsa = cert.PrivateKey as RSACryptoServiceProvider;
	if (rsa == null)
	{
		throw new InvalidOperationException("Private key is not accessible. Ensure ProxKey middleware is installed, the token is connected, and the correct PIN is used.");
	}

	// Perform a test operation to ensure the private key is accessible
	try
	{
		byte[] testData = new byte[] { 0x00, 0x01, 0x02, 0x03 };
		rsa.SignData(testData, new SHA256CryptoServiceProvider());
	}
	catch (CryptographicException ex)
	{
		throw new InvalidOperationException("Failed to authenticate with the USB token. Ensure the correct PIN is entered.", ex);
	}

	// Sign the PDF with iTextSharp
	using (FileStream inputFileStream = new FileStream(inputPdf, FileMode.Open, FileAccess.Read))
	using (FileStream outputFileStream = new FileStream(outputPdf, FileMode.Create, FileAccess.Write))
	{
		PdfReader reader = new PdfReader(inputFileStream);
		PdfStamper stamper = PdfStamper.CreateSignature(reader, outputFileStream, '\0');

		// Create the signature appearance
		PdfSignatureAppearance appearance = stamper.SignatureAppearance;
		appearance.Reason = "Document digitally signed";
		appearance.Location = "Vadodara";
		// Define the signature rectangle size
		iTextSharp.text.Rectangle pageSize = reader.GetPageSize(1); // Use 1 to get the size of the first page
		// Define the width and height of the page
		float pageWidth = pageSize.Width;
		float pageHeight = pageSize.Height; float rectWidth = 144f;
		float rectHeight = 32f;
		// Calculate the position for the bottom-right corner
		float left = pageWidth - rectWidth - 36; // 36 is some margin from the right edge
		float bottom = 276f; // 36 is the margin from the bottom edge

		appearance.SetVisibleSignature(new iTextSharp.text.Rectangle(left, bottom, left + rectWidth, bottom + rectHeight), 1, "Signature");

		// Convert the .NET certificate to a BouncyCastle certificate
		var bcCert = DotNetUtilities.FromX509Certificate(cert);
		IExternalSignature externalSignature = new PrivateKeySignature(rsa, "SHA-256");

		// Sign the document
		MakeSignature.SignDetached(appearance, externalSignature, new[] { bcCert }, null, null, null, 0, CryptoStandard.CMS);
	}
}

Getting the thumb print

This helper function fetches the first available thumbprint with a private key from the certificate store.

private static string getThumbPrint()
{
	X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
	store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
	foreach (X509Certificate2 cert in store.Certificates)
	{

		if (cert.HasPrivateKey)
		{
			//cmbSignatures.Items.Add(cert.FriendlyName + " - " + cert.Thumbprint);
			return cert.Thumbprint;
		}
	}
	store.Close();
	return null;
}

Self-signed certificate

While self-signed certificates are suitable for testing, they are not recommended for professional use. Here’s a basic implementation for self-signing:

public static void SignPdfSelfSign(string inputPdf, string outputPdf, string password)
{

	var certificate = new X509Certificate2(@"cert\certificate.pfx", password, X509KeyStorageFlags.Exportable | X509KeyStorageFlags.PersistKeySet); 
	if (!certificate.HasPrivateKey)
	{
		throw new InvalidOperationException("No private key found in the certificate.");
	}
	// Convert .NET X509Certificate2 to BouncyCastle X509Certificate
	Org.BouncyCastle.X509.X509CertificateParser parser = new X509CertificateParser();
	Org.BouncyCastle.X509.X509Certificate bcCert = parser.ReadCertificate(certificate.RawData);
	//PdfReader reader = new PdfReader(inputPdf);
	using (PdfReader reader = new PdfReader(inputPdf))
	using (FileStream os = new FileStream(outputPdf, FileMode.Create, FileAccess.Write))
		{
			int totalPages = reader.NumberOfPages;
			int lastPageIndex = totalPages - 1;

			PdfStamper stamper = PdfStamper.CreateSignature(reader, os, '\0');

			// Get the signature appearance
			PdfSignatureAppearance appearance = stamper.SignatureAppearance;
			appearance.Reason = "Document digitally signed";
			appearance.Location = "Vadodara";

			// Define the signature rectangle size
			iTextSharp.text.Rectangle pageSize = reader.GetPageSize(1); // Use 1 to get the size of the first page
			// Define the width and height of the page
			float pageWidth = pageSize.Width;
			float pageHeight = pageSize.Height; float rectWidth = 144f;
			float rectHeight = 32f;
			// Calculate the position for the bottom-right corner
			float left = pageWidth - rectWidth - 36; // 36 is some margin from the right edge
			float bottom = 276f; // 36 is the margin from the bottom edge

			//appearance.SetVisibleSignature(new iTextSharp.text.Rectangle(36, 748, 144, 780), lastPageIndex, "SignatureField");
			appearance.SetVisibleSignature(new iTextSharp.text.Rectangle(left, bottom, left + rectWidth, bottom + rectHeight), 1, "SignatureField");


			// Extract the private key using BouncyCastle
			// Extract the private key using BouncyCastle
			var privateKey = GetPrivateKeyFromCertificate(certificate);
			//Org.BouncyCastle.Crypto.AsymmetricKeyParameter privateKey = DotNetUtilities.GetKeyPair(certificate.PrivateKey).Private;

			// Create the external signature container
			IExternalSignature pks = new CustomExternalSignature(certificate, DigestAlgorithms.SHA256);
			//IExternalSignature pks = new X509Certificate2Signature(certificate, "SHA-256");
			//var chain = new X509Certificate[] { certificate };  // You can fill this with the chain of certificates if needed
			ICollection<Org.BouncyCastle.X509.X509Certificate> chain = new List<Org.BouncyCastle.X509.X509Certificate> { bcCert };
			//ICollection<Org.BouncyCastle.X509.X509Certificate> chainCollection = chain;
			MakeSignature.SignDetached(appearance, pks, chain, null, null, null, 0, CryptoStandard.CMS);
		}
}

In order for this to work, you must create a cert subdirectory within the application directory which contains all certificate files needed for self-signing. You can create these files using openssl program as follows:

openssl genrsa -out private.key 2048
openssl req -new -key private.key -out request.csr -subj "/C=IN/ST=GUJ/L=Vadodara/O=ACME/OU=Unit/CN=ACME"
openssl x509 -req -days 365 -in request.csr -signkey private.key -out certificate.crt  -addext "subjectAltName=DNS:acme.example.com" -addext "basicConstraints=CA:FALSE" -addext "keyUsage=critical,digitalSignature,nonRepudiation,keyEncipherment" -addext "extendedKeyUsage=codeSigning"
openssl pkcs12 -export -out certificate.pfx -inkey private.key -in certificate.crt -password pass:digisign

Remember to replace ACME with your organization name and Vadodara with your region name. You can also replace the password “digisign” with something else - in which case you’ll have to change the C# code above correspondingly.

Notes on legal and regional compliance

Using self-signed certificates may not hold up in legal disputes. In jurisdictions like Europe, CA-provided signatures are often mandated. In India, the IT Act of 2000 recommends but doesn’t mandate them—this may change in the future.

Happy coding and let me know how it goes in the comments below.

Building a secure and efficient MQTT-HTTP gateway with Node.js

2024-12-01T00:00:00+00:00

One of my recent projects involved creating a Node.js script that acts as a gateway or middleware, capturing messages from an MQTT broker and relaying (streaming) them on the HTTP side via GET requests. Similarly, it should also handle POST requests from the HTTP side and publish them to the corresponding broker on the respective topic.

Why use this approach?

Security: Avoid exposing MQTT broker credentials or certificates to browsers.
Efficiency: Browsers require WebSocket for MQTT communication, adding overhead compared to native MQTTS.
Flexibility: Centralized middleware simplifies custom message processing, improving maintainability.

Preparing the Node.js environment.

We only need two node components viz. mqtt and express. The former is the core library used to interact with MQTT broker and latter is the micro-framework used to interact with HTTP GET/POST requests.

It’s not necessary to stick to version 4 of the mqtt.js but I found it more stable and compatible with my Node.js setup.

npm install mqtt@4 express

Optional: CORS package

You might also need the cors package if you want to customize Cross-Origin Resource Sharing (CORS) settings and enable access to the gateway for multiple users, such as REST API clients. I needed this in my case.

npm install cors

Setting up your MQTT brokers

The brokers object contains configurations for each MQTT broker such as the URL and options (e.g., authentication). Each broker is also assigned a lastMessage object to store the latest MQTT message for each topic.

const mqtt = require('mqtt');
const express = require('express');
const cors = require('cors');  // Optional: Import CORS package
const fs  = require('fs');
const path = require('path');
const os = require('os');


const brokers = {};

brokers['example'] =  { 
	url: "mqtts://example.us-east-1.amazonaws.com:8883",
	lastMessage: {},
	devices: {},
	options: {
		ca: fs.readFileSync( 'certs/ca.pem'),
		cert: fs.readFileSync( 'certs/cert.crt') ,
		key: fs.readFileSync( 'certs/key.key') ,
		protocolId: 'MQTT',
		protocolVersion: 4,
		keepalive: 60,
		//wsOptions: {timeout: 30000, path: '/mqtt'},
		clientId: 'mqttjs_'+Math.random().toString(16).substr(2,8),
        rejectUnauthorized: true,
		clean: true,
        secureProtocol: 'TLSv1_2_method', // Explicitly use TLSv1.2
	}
  };
brokers["mosquitto"]= { 
	url: 'mqtt://test.mosquitto.org', options:{},
	clientId: 'mqttjs_'+Math.random().toString(16).substr(2,8),
	lastMessage: {} 
};

Initializing middleware for HTTP requests

Middleware ensures proper handling of requests by validating input and enabling CORS.

// Initialize HTTP Server
const app = express();
app.use(express.json()); // Parse JSON payloads

app.use(cors({
    origin: '*'  // Allow requests from any origin
}));

Establishing MQTT connections

I’ve kept the subscription topic to # wildcard i.e. subscribe to all topics, you may or may not want to do that. The “connect” event of mqttClient handles the connection where you can subscribe to the topics. Correspondingly, the message event handles the incoming events from each broker. The dummy switch block here can be used to add any custom processing logic you may have. The lastMessage variable will anyway store the message for the corresponding topic.

The error and auth event handlers are just dummy blocks that you can expand upon if you want to. In the end, each client object is stored to mqttClients array object from which it can later be retrieved.

// Store MQTT client objects for each broker
const mqttClients = {};
const subTopics = '#';

// Function to connect to each broker
Object.keys(brokers).forEach(key => {
	const broker =brokers[key];
	console.log("initializing broker:", key, broker.url);
    const mqttClient = mqtt.connect(broker.url, broker.options);

    mqttClient.on('connect', () => {
      console.log(`Connected to broker: ${broker.url}`);
		mqttClient.subscribe(subTopics, (err) => {
        if (err) {
          console.error(`Subscription error for ${key}:`, err);
        } else {
          console.log(`Subscribed to topic ${subTopics} on ${key}`);
        }
      });
    });

    mqttClient.on('message', (topic, message) => {
      const msg = message.toString();
      console.log(`[${key}] Received message on topic: ${topic}`);
	  broker['lastMessage'][topic] = msg;
	  switch(key) { //custom logic
		  case "custom_broker":
			//@todo: handle custom logic
			break;
	  }
    });
	
	mqttClient.on('error', (err) => {
		console.error(`Error with broker ${key}:`, err.message);
	});
	
	mqttClient.on('auth', (packet, cb) => {
	  console.log('Authenticating with certificate...');

	  // Check the certificate properties and perform the authentication logic here.
	  // Call cb() with an error if authentication fails or null if it succeeds.
	  cb(null);
	});	
	
	mqttClients[key] = mqttClient;
  });

Bridging MQTT with Express API routes

On the HTTP side, I’ve created just two routes viz. events and publish. The former is used to fetch messages from a broker and latter to publish to them.

app.get('/events', (req, res) => {
	const { brokerKey, topic } = req.query;
	// Build the SQL query dynamically based on provided parameters

	if (!brokerKey || !topic) {
		return res.status(400).send('Invalid request. Provide brokerkey and topic.');
	}
	broker = brokers[brokerKey];
	switch (brokerKey) { //custom logic
		case "custom_broker":
			//@todo: handle custom logic
			break;
		default:
			res.json(broker['lastMessage'][topic]);
			break;
	}
});

// HTTP POST: Publish messages back to MQTT
app.post('/publish', (req, res) => {
  const { brokerKey, topic, message } = req.body; // Destructure input fields

  // Validate the input
  if (!brokerKey || !topic || !message) {
    return res.status(400).send('Invalid request. Provide broker key, topic, and message.');
  }

  // Retrieve the MQTT client for the specified broker
  const mqttClient = mqttClients[brokerKey];
  if (!mqttClient) {
    return res.status(400).send('Invalid broker specified.');
  }

  // Publish the message
  mqttClient.publish(topic, message, (err) => {
    if (err) {
      console.error(`Publish error on ${brokerKey}:`, err);
      res.status(500).send('Failed to publish message.');
    } else {
      res.send(`Message published successfully to ${brokerKey}.`);
    }
  });
});

This is also pretty simple and straightforward. As earlier, I’ve created a dummy switch block for custom handling. The default is to just pick the latest message for that particular broker and topic (broker['lastMessage'][topic]) and return it using res.json().

Same holds true for publish. It accepts three parameters called brokerKey, topic and message, then correspondingly publishes the message on the broker. You may want to add custom logic here including authentication logic based on API keys, etc.

Starting the Express server

The final step is to start the Express server. Use a custom port, or fallback to a default if not provided.

const PORT = process.env.PORT || 3000;

app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});

This setup provides a reliable foundation for creating an MQTT-HTTP gateway. You can further enhance it with persistent storage, advanced authentication, or message processing workflows. Let me know how this implementation works for you—or share your own ideas for improvement—in the comments below. Happy coding!

Building a simple customer management system in PHP with MySQL

2024-11-20T00:00:00+00:00

Creating a customer management system (CMS) is a great way for beginners to learn PHP and MySQL. This hands-on project will guide you through the process of building a simple CMS from scratch, covering database design, CRUD operations, and form handling.

What is a customer management system?

A customer management system is a tool used to store and manage customer information. It allows businesses to efficiently track customer details, such as names, email addresses, and phone numbers, using basic CRUD (Create, Read, Update, Delete) operations.

In this tutorial, you’ll learn how to:

Design a database for storing customer information.
Build a user-friendly web interface for managing customers.
Implement CRUD functionality with PHP and MySQL.

Prerequisites

To follow this tutorial, you need:

A local server environment like XAMPP or WAMP (for Windows) or MAMP (for macOS).
Basic knowledge of HTML, PHP, and SQL.
A text editor such as VS Code, Sublime Text, or Notepad++.

Step 1: Setting up the project

1.1 Install and configure your server

Download and install XAMPP or your preferred local server.
Start Apache and MySQL from the control panel.

1.2 Create the project folder

Navigate to the htdocs directory in XAMPP and create a folder named customer_management.

Step 2: Designing the database

2.1 Create the database

Open phpMyAdmin by navigating to http://localhost/phpmyadmin.
Click New, and name the database customer_db.

2.2 Create the `customers` table

Run the following SQL query to create the customers table:

CREATE TABLE customers (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL,
    phone VARCHAR(15),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

This table has the following columns:

id: A unique identifier for each customer.
name: The customer’s name.
email: The customer’s email address.
phone: The customer’s phone number.
created_at: A timestamp of when the customer was added.

Step 3: Building the front-end

3.1 Creating the HTML layout

Create a file named index.php in the customer_management folder:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Customer Management</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
    <div class="container">
        <h1>Customer Management System</h1>
        <a href="add_customer.php" class="btn">Add New Customer</a>
        <table>
            <thead>
                <tr>
                    <th>ID</th>
                    <th>Name</th>
                    <th>Email</th>
                    <th>Phone</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <!-- Dynamic content will go here -->
            </tbody>
        </table>
    </div>
</body>
</html>

Step 4: Writing the back-end logic

4.1 Database connection

Create a file named db.php to handle database connectivity:

<?php
$host = 'localhost';
$user = 'root';
$password = '';
$database = 'customer_db';

$conn = new mysqli($host, $user, $password, $database);

if ($conn->connect_error) {
    die("Connection failed: " . $conn->connect_error);
}
?>

4.2 Fetch and display customers

Update index.php to fetch customer data dynamically:

<?php
include 'db.php';

$sql = "SELECT * FROM customers";
$result = $conn->query($sql);
?>

<tbody>
    <?php if ($result->num_rows > 0): ?>
        <?php while ($row = $result->fetch_assoc()): ?>
            <tr>
                <td><?= $row['id']; ?></td>
                <td><?= $row['name']; ?></td>
                <td><?= $row['email']; ?></td>
                <td><?= $row['phone']; ?></td>
                <td>
                    <a href="edit_customer.php?id=<?= $row['id']; ?>" class="btn-edit">Edit</a>
                    <a href="delete_customer.php?id=<?= $row['id']; ?>" class="btn-delete">Delete</a>
                </td>
            </tr>
        <?php endwhile; ?>
    <?php else: ?>
        <tr>
            <td colspan="5">No customers found.</td>
        </tr>
    <?php endif; ?>
</tbody>

4.3 Adding a customer

Create add_customer.php:

<?php
include 'db.php';

if ($_SERVER['REQUEST_METHOD'] == 'POST') {
    $name = $_POST['name'];
    $email = $_POST['email'];
    $phone = $_POST['phone'];

    $sql = "INSERT INTO customers (name, email, phone) VALUES ('$name', '$email', '$phone')";
    if ($conn->query($sql)) {
        header('Location: index.php');
    } else {
        echo "Error: " . $conn->error;
    }
}
?>

<!DOCTYPE html>
<html lang="en">
<head>
    <title>Add Customer</title>
</head>
<body>
    <form method="POST" action="">
        <input type="text" name="name" placeholder="Name" required>
        <input type="email" name="email" placeholder="Email" required>
        <input type="text" name="phone" placeholder="Phone">
        <button type="submit">Add Customer</button>
    </form>
</body>
</html>

Step 5: Styling the app

Create a style.css file for basic styling:

body {
    font-family: Arial, sans-serif;
    background-color: #f9f9f9;
    color: #333;
}
.container {
    max-width: 800px;
    margin: 20px auto;
    padding: 20px;
    background: #fff;
    border: 1px solid #ddd;
    border-radius: 5px;
}
table {
    width: 100%;
    border-collapse: collapse;
    margin-top: 20px;
}
table th, table td {
    border: 1px solid #ddd;
    padding: 10px;
    text-align: left;
}
.btn {
    display: inline-block;
    padding: 8px 12px;
    color: white;
    background-color: #007bff;
    text-decoration: none;
    border-radius: 3px;
}

Step 6: Adding update and delete functionality

Update

Create edit_customer.php to edit customer details using a pre-filled form.

Delete

Create delete_customer.php to handle deleting a customer by ID.

Conclusion

By following these steps, you’ve built a fully functional customer management system using PHP and MySQL. This project taught you how to:

Design a database.
Implement CRUD operations.
Create a dynamic web interface.

You can now extend this project by adding features like search, sorting, or user authentication.

References

Unlocking Text from Embedded-Font PDFs: A pytesseract OCR Tutorial

2024-11-11T00:00:00+00:00

Extracting text from a PDF is usually straightforward when it’s in English and doesn’t have embedded fonts. However, once those assumptions are removed, it becomes challenging to use basic python libraries like pdfminer or pdfplumber. Last month, I was tasked with extracting text from a Gujarati-language PDF and importing data fields such as name, address, city, etc., into JSON format.

If the font is embedded in the PDF itself, simple copy-pasting won’t work, and using pdfplumber will return unreadable junk text. Therefore, I had to convert each PDF page to an image and then apply OCR using the pytesseract library to “scan” the page instead of just reading it. This tutorial will show you how to do just that.

Things you will need

pdfplumber (Python library)
pdf2image (Python library)
pytesseract (Python library)
tesseract-ocr

You can install the Python libraries using pip commands as shown below. For Tesseract-OCR, download and install the software from the official site. pytesseract is just a wrapper around the tesseract software.

pip install pdfplumber
pip install pdf2image
pip install pytesseract

Converting the PDF page to an image

The first step is to convert your PDF page to an image. This extract_text_from_pdf() function does exactly that-you pass the PDF path and the page_num (zero indexed) as parameters. Note that I’m converting the page to black and white first for clarity, this is optional.

# Extract text from a specific page of a PDF
def extract_text_from_pdf(pdf_path, page_num):
    # Use pdfplumber to open the PDF
    pdf = pdfplumber.open(pdf_path)
	print(f"extracting page {page_num}..")
	page = pdf.pages[page_num]
	images = convert_from_path(pdf_path, first_page=page_num+1, last_page=page_num+1)
	image = images[0]
	# Convert to black and white
	bw_image = convert_to_bw(image)
	# Save the B&W image for debugging (optional)
	#bw_image.save("bw_page.png")
	# Perform OCR on the B&W image
	e_text = ocr_image(bw_image)
	open('out.txt', 'w', encoding='utf-8').write(e_text)
	#print("output written to file.")
	try:
		process_text(page_num, e_text)
    except Exception as e:
        print("Error occurred:", e)
	print("done..")
	
# Convert image to black and white
def convert_to_bw(image):
    # Convert to grayscale
    gray = image.convert('L')
    # Apply threshold to convert to pure black and white
    bw = gray.point(lambda x: 0 if x < 128 else 255, '1')
    return bw
	
# Perform OCR using Tesseract on a given image
def ocr_image(image_path):
    try:
        # Perform OCR
        custom_config = r'--oem 3 --psm 6 -l guj+eng'
        text = pytesseract.image_to_string(image_path, config=custom_config)  # --psm 6 treats the image as a block of text
        return text
    except Exception as e:
        print(f"Error during OCR: {e}")
        return None

The ocr_image() function uses pytesseract to extract text from the image through OCR. The technical parameters like --oem and --psm control how the image is processed, and the -l guj+eng parameter sets the languages to be read. Since this PDF contained occasional English text, I used guj+eng.

Processing the text

Once you’ve imported the text using OCR, you can parse it in the format you want. This works similarly to other PDF libraries like pdfplumber or pypdf2.

nums = ['0', '૧', '૨', '૩', '૪', '૫', '૬', '૭', '૮', '૯']

def process_text(page_num, e_text):
    obj = None
    last_surname = None
    last_kramank = None
    print(f"processing page {page_num}..")
    for line in e_text.splitlines():
		line = line.replace('|', '').replace('[', '').replace(']', '')
        parts = [word for word in line.split(' ') if word]
        if len(parts) == 0: continue
        new_rec = True
        for char in parts[0]:
            if char not in nums:
                new_rec = False
                break
        if len(parts) < 2: continue
        
        if new_rec and len(parts[0]) >= 2: # numbered line
            if len(parts) < 9: continue
            if obj: records.append(obj)
            obj = {}
            last_surname = parts[1]
            obj['kramank'] = parts[0]
            last_kramank = parts[0]
            obj['full_name'] = ' '.join(parts[1:4])
            obj['surname'] = parts[1]
            obj['pdf_page_num'] = page_num + 1
            obj['registered_by'] = parts[4]
            obj['village_vatan'] = parts[5]
            obj['village_mosal'] = parts[6]
            if parts[8] == 'વર્ષ':
                idx = 7
                obj['dob'] = parts[idx] + ' વર્ષ'
                idx += 1
            elif len(parts[7]) == 8 and parts[7][2] == '-':
                idx = 7
                obj['dob'] = parts[idx]
            else:
                print("warning: no date")
                idx = 6
            obj['marital_status'] = parts[idx+1]
            obj['extra_fields'] = '::'.join(parts[idx+2:-2])
            obj['blood_group'] = parts[-1]
        elif parts[0] == last_surname: # new member in existing family
            if obj: records.append(obj)
            obj = {}
            obj['kramank'] = last_kramank
            obj['surname'] = last_surname
            obj['full_name'] = ' '.join(parts[0:3])
            obj['pdf_page_num'] = page_num + 1
            obj['registered_by'] = parts[3]
            obj['village_vatan'] = parts[4]
            obj['village_mosal'] = parts[5]
            if len(parts) <= 6: continue
            if parts[7] == 'વર્ષ': # date exists
                idx = 6
                obj['dob'] = parts[idx] + ' વર્ષ'
                idx += 1
            elif len(parts[6]) == 8 and parts[6][2] == '-':
                idx = 6
                obj['dob'] = parts[idx]
            else:
                print("warning: no date")
                idx = 5
            obj['marital_status'] = parts[idx+1]
            obj['extra_fields'] = '::'.join(parts[idx+2:-2])
            obj['blood_group'] = parts[-1]
        elif obj: # continuation lines
            if ("(" in line and ")" in line) or "મો.ઃ" in line:
                obj['extra_fields'] += ' ' + '::'.join(parts[0:])
    if obj: records.append(obj)        
    jstr = json.dumps(records, indent=4)
    open("guj.json", 'w', encoding='utf-8').write(jstr)
    print(f"written page {page_num} to json..")

Every PDF has its own nuances that must be accounted for. In this case, a new serial number (like 0૧ or 0૨) in the first field signaled a new group when the subsequent field (surname) changed.

pytesseract is a testament to the evolution and advancement in IT technology. About a decade ago, reading or parsing a PDF image using OCR in a non-English language on a modestly configured PC or laptop would have been nearly impossible. This is truly progress! Happy coding, and let me know how it goes in the comments below.

References

The indie blogger’s guide to seamless commenting: meet giscus

2024-11-09T00:00:00+00:00

Indie bloggers are on the constant lookout for tools that simplify their work while keeping costs low and user experience seamless. One of the most overlooked aspects of running a blog is finding the right comment hosting system. Enter giscus, a modern solution that stands out among its peers for being lightweight, privacy-friendly, and free to use. Here’s why it’s the best comment hosting system for the indie blogger living in today’s digital age.

Benefits of static hosting

No hassles of website maintenance

Indie bloggers love static websites for good reason. Unlike traditional dynamic websites, static sites come with zero server-side headaches. Once you’ve deployed your content, you don’t need to worry about database management, server updates, or unexpected downtime caused by backend failures. Platforms like Hugo, Jekyll, and Gatsby make it easier than ever to generate and maintain static sites. Add a robust version control system like GitHub, and your content stays safe with every update neatly tracked.

No costly backend bills to pay

Keeping a dynamic website up and running can be an expensive affair. Backend servers and database management come with their own set of recurring costs, from hosting fees to maintenance bills. These expenses can quickly add up, especially for indie bloggers who are not monetizing their content or are just starting out. Static site generators, paired with free hosting options, offer a refreshing alternative that doesn’t put a dent in your wallet.

Free platforms for the pleb

Gone are the days when hosting a blog meant shelling out money for a server. Platforms like GitHub Pages, Netlify, and Vercel offer free static site hosting that’s perfect for indie bloggers. These platforms come with seamless deployment pipelines, allowing you to push updates to your blog in a matter of seconds. And since static hosting doesn’t require server-side processing, the pages load lightning fast, ensuring a smooth user experience for readers.

The horrors of privacy-invasive third-party systems like Disqus

In the past, the go-to solution for adding comments to a blog was Disqus. While popular, Disqus became synonymous with intrusive ads, data tracking, and privacy concerns. Here are some of the pain points many bloggers and users have faced:

Tracking and privacy issues: Disqus is notorious for collecting user data and tracking user behavior across the web. For bloggers who value their readers’ privacy, this is a significant red flag.
Ads and monetization: Disqus’s free version often injects ads into your blog’s comment section, cluttering the user experience and taking away from the essence of the content.
Slow load times: Disqus can slow down the loading speed of your site due to its heavy scripts and external calls, which negatively impacts SEO and user satisfaction.

The modern blogger who champions simplicity and transparency needs an alternative that respects user privacy while being lightweight and functional.

The horrors of coding and maintaining your own commenting system

Some bloggers may consider building their own commenting system to avoid the pitfalls of third-party options. While this sounds like an appealing DIY project, it comes with its own set of nightmares:

Complexity: Developing a custom commenting system requires backend expertise, database integration, and server management. This can be overwhelming, especially for bloggers focused more on writing than on coding.
Security risks: Handling user-generated content means dealing with potential security threats like SQL injection and spam bots. Keeping the system secure requires ongoing updates and vigilance.
Maintenance: A custom-built system needs consistent maintenance. Any change in server configuration or software updates can disrupt the system and create additional work for the blogger.

For the indie blogger who doesn’t want to spend their time coding or worrying about security flaws, a more straightforward option is essential.

Enter the middle ground: why giscus is the best of both worlds

giscus offers a perfect balance between ease of use, privacy, and functionality. Here’s why it’s the ideal comment hosting system for the indie blogger:

Fully integrated with GitHub

giscus uses GitHub Discussions as its engine, so comments are stored as discussion threads in your repository. This means:

Transparent data management: All comment data is stored on GitHub, a platform that millions of developers trust.
Easy moderation: You can manage, edit, or delete comments directly from GitHub, leveraging the familiar interface and robust features.
Open-source spirit: giscus itself is open-source, which aligns with the values of transparency and collaboration many indie bloggers uphold.

Lightweight and fast

Unlike heavyweight comment systems, giscus is built with performance in mind. It doesn’t add bloat to your site, ensuring that your pages load quickly and smoothly. This is especially important for maintaining good SEO and providing a seamless experience for mobile readers.

Privacy-focused

giscus does not track users or display ads, making it an excellent choice for bloggers who want to maintain a privacy-friendly site. Since comments are facilitated through GitHub accounts, users already familiar with GitHub’s policies can engage confidently.

Simple installation

Setting up giscus is a breeze. Here’s how to get started:

Create a GitHub repository or use an existing one to store the discussions.
Visit the giscus website and generate the code snippet by selecting your repository and preferred discussion category.
Copy the provided code and paste it into your site’s codebase where you want the comment section to appear.
Deploy your site, and voilà! You have a fully functional, GitHub-based commenting system.

User-friendly for commenters

Engagement through giscus requires users to log in with their GitHub account, which appeals to a tech-savvy audience that values simplicity and privacy. For users already on GitHub, commenting feels seamless, and they can subscribe to discussions without having to create yet another account.

Community-driven enhancements

Because giscus is an open-source project, it evolves based on user feedback. Developers can contribute improvements, making it a community-driven tool that adapts over time.

Conclusion

Choosing the right comment system is critical for any blogger, especially those who want a balance between ease of use, privacy, and functionality. While legacy systems like Disqus have paved the way for commenting but introduced privacy issues, and coding your own system is often impractical, giscus shines as the modern, lightweight solution that respects privacy and integrates seamlessly with static sites. It’s time for indie bloggers to make the shift and experiment with giscus—the best comment hosting system for present times.

The emotional toll of Agile: burnout in the name of agility

2024-11-08T00:00:00+00:00

There is no doubt that over the last few years, Agile methodologies have gained prominence as a means to foster flexibility, innovation, and responsiveness to change. However, beneath the surface of this seemingly effective approach lies a troubling reality: the emotional toll it can take on teams. This article delves into the impact of Agile practices on team morale and well-being, particularly regarding constant iterations and pressure to deliver, exploring how the very principles intended to enhance productivity can inadvertently lead to burnout.

Understanding Agile: a double-edged sword

Agile practices prioritize iterative development, continuous feedback, and collaborative teamwork. On paper, these elements promote a dynamic work environment that encourages creativity and adaptability. Teams are empowered to experiment, pivot, and respond swiftly to customer needs. However, the relentless cycle of iterations, coupled with the expectation of constant delivery, can create a high-pressure atmosphere that strains team morale and emotional well-being.

The constant cycle of iteration

At the heart of Agile is the concept of iterative cycles—sprints that require teams to deliver incremental value within short timeframes. While this method enables quick responses to changing requirements, it also sets a relentless pace. Teams may find themselves caught in a continuous loop of planning, execution, review, and adjustment, leaving little room for reflection or recovery.

The emotional toll of this relentless cycle can manifest in several ways:

Increased Stress Levels: The pressure to meet tight deadlines and deliver high-quality work can lead to elevated stress levels among team members. The expectation of constant output can make individuals feel overwhelmed and anxious, particularly when faced with competing priorities.
Reduced Job Satisfaction: Continuous iterations may result in diminished job satisfaction. When team members feel they are perpetually “on the clock,” they may lose sight of the intrinsic value of their work, leading to disengagement and a decline in overall morale.
Erosion of Work-Life Balance: Agile’s focus on responsiveness can blur the lines between work and personal life. Team members may feel compelled to extend their work hours to keep up with demands, ultimately jeopardizing their work-life balance and well-being.

The pressure to deliver

The Agile philosophy encourages teams to prioritize customer needs and deliver value quickly. While this is essential for success, it can also create a culture of urgency that places undue pressure on team members. The fear of falling behind or disappointing stakeholders can lead to a toxic cycle of overwork and burnout.

Impacts of pressure on team morale

Fear of Failure: In an Agile environment, the fear of failure can be amplified by the fast-paced nature of work. Team members may become hesitant to take risks or voice concerns, fearing that any setback will reflect poorly on their performance.
Team Fragmentation: The pressure to deliver can lead to competition among team members rather than collaboration. When individuals are primarily focused on their own deliverables, the sense of teamwork and camaraderie may erode, resulting in a fragmented team dynamic.
Burnout: Perhaps the most concerning outcome of sustained pressure in an Agile context is burnout. Prolonged exposure to high-stress conditions can lead to physical and emotional exhaustion, cynicism, and a sense of inefficacy. This not only affects individual team members but can also have cascading effects on overall team productivity and performance.

Strategies for mitigating the emotional toll

Recognizing the potential for burnout in Agile teams is crucial for fostering a healthy work environment. Here are some strategies organizations can implement to mitigate the emotional toll:

Promote a Culture of Psychological Safety: Encouraging open communication and creating a safe space for team members to voice concerns can help alleviate the fear of failure. When individuals feel valued and heard, they are more likely to take risks and contribute meaningfully to the team.
Encourage Regular Breaks and Downtime: Organizations should emphasize the importance of work-life balance and encourage team members to take regular breaks. This can help individuals recharge and return to work with renewed energy and focus.
Set Realistic Expectations: While the Agile framework encourages responsiveness, organizations should strive to set realistic expectations for deliverables. Avoiding unrealistic deadlines and recognizing the limits of team capacity can help prevent burnout.
Foster Team Cohesion: Building strong interpersonal relationships among team members can enhance collaboration and support. Team-building activities, both in-person and virtual, can foster a sense of belonging and unity.
Conduct Regular Retrospectives: Regular retrospectives are a cornerstone of Agile practices. However, these sessions should focus not only on project outcomes but also on team well-being. Discussing emotional challenges and collectively brainstorming solutions can foster a supportive team environment.

Conclusion

While Agile methodologies offer numerous benefits for organizations, it is crucial to recognize the emotional toll they can exact on teams. The pressure to deliver, combined with the relentless cycle of iterations, can lead to burnout and negatively impact team morale. By prioritizing psychological safety, work-life balance, and realistic expectations, organizations can harness the full potential of Agile while safeguarding the well-being of their teams.

Ultimately, the goal should be to create a work environment where agility is not just about speed and efficiency but also about fostering a culture of well-being and collaboration—where teams can thrive without sacrificing their emotional health in the name of agility.

References

Beck, K., et al. (2001). Manifesto for Agile Software Development. Agile Alliance.
Goleman, D. (2013). Focus: The Hidden Driver of Excellence. HarperCollins.
Maslach, C., & Leiter, M. P. (2016). Burnout at Work: A Psychological Perspective. Psychology Press.
Sutherland, J., & Schwaber, K. (2017). The Scrum Guide: The Definitive Guide to Scrum: The Rules of the Game. Scrum.org.