DEV Community: ZenOfCode

Feature Flags in .NET

ZenOfCode — Mon, 05 May 2025 21:05:41 +0000

Feature Flags in .NET: A Minimal API with Toggle Power (Using Microsoft.FeatureManagement)

Feature flags give you fine-grained control over your application’s behavior—turn features on or off, run experiments, and roll back instantly without redeploying. In this tutorial, you’ll integrate the first‑party Microsoft.FeatureManagement package into a .NET Minimal API, source flags from configuration and a custom provider, and explore both attribute- and code-based gating.

Why Use Microsoft.FeatureManagement?

First‑party support: Official Microsoft package, integrates with .NET configuration and dependency injection.
Flexible filters: Time windows, percentages, custom logic.
Clean architecture alignment: Business logic stays decoupled from flag storage.

Project Setup
Define Feature Flags in Configuration
Wire Up Microsoft.FeatureManagement
Use Flags in Endpoints
FeatureGate Attributes
Custom Feature Provider
Testing
References

Project Setup

dotnet new webapi -n FlagsWithMicrosoft
cd FlagsWithMicrosoft

Edit your .csproj to target .NET 6+ and remove the default Weather sample. Then install the feature management package:

dotnet add package Microsoft.FeatureManagement

Define Feature Flags in Configuration

Using appsettings.json, declare flags under a FeatureManagement section. This keeps flags in config, supporting environment-based overrides.

// appsettings.json
{
  "FeatureManagement": {
    "NewUI": true,
    "BetaEndpoint": false,
    "TimeLimitedFeature": {
      "EnabledFor": [
        { "Name": "TimeWindow", "Parameters": { "Start": "2025-05-01", "End": "2025-06-01" } }
      ]
    }
  }
}

NewUI: simple on/off.
BetaEndpoint: off by default.
TimeLimitedFeature: auto‑enabled during a date range.

Wire Up Microsoft.FeatureManagement

In Program.cs, register feature management services:

using Microsoft.FeatureManagement;

var builder = WebApplication.CreateBuilder(args);

// Add feature management and built-in filters
builder.Services.AddFeatureManagement()
    .AddFeatureFilter<Microsoft.FeatureManagement.FeatureFilters.TimeWindowFilter>();

var app = builder.Build();

This reads FeatureManagement from configuration and enables the built‑in TimeWindowFilter.

Use Flags in Endpoints

You can check flags manually using IFeatureManagerSnapshot:

using Microsoft.FeatureManagement;

app.MapGet("/new-ui-data", async ([FromServices] IFeatureManagerSnapshot fm) =>
{
    if (!await fm.IsEnabledAsync("NewUI"))
        return Results.NotFound("New UI not available.");

    return Results.Ok(new { message = "Welcome to the new UI!" });
});

Above: manual check with IsEnabledAsync().

FeatureGate Attributes

For attribute-based gating, add [FeatureGate] on endpoints or controllers. This automatically returns 404 if the feature is disabled.

using Microsoft.FeatureManagement;

// Attribute on Minimal API endpoint
app.MapGet("/beta-attr", () => "Beta data via attribute")
   .RequireFeature("BetaEndpoint");

// In MVC controller
[ApiController]
[Route("api/[controller]")]
public class ReportsController : ControllerBase
{
    [HttpGet("special")]
    [FeatureGate("TimeLimitedFeature")]
    public IActionResult GetTimeLimitedReport()
    {
        return Ok("Time-limited report data");
    }
}

.RequireFeature("BetaEndpoint") for Minimal APIs
[FeatureGate("TimeLimitedFeature")] for controllers

Custom Feature Provider

Implement IFeatureDefinitionProvider to fetch flags from an external service.

// Infrastructure/ExternalFeatureProvider.cs
using Microsoft.FeatureManagement;
using Microsoft.FeatureManagement.FeatureDefinitions;

public class ExternalFeatureProvider : IFeatureDefinitionProvider
{
    private readonly IExternalFlagRepository _repo;
    public ExternalFeatureProvider(IExternalFlagRepository repo) => _repo = repo;

    public async Task<FeatureDefinition> GetFeatureDefinitionAsync(string featureName)
    {
        var flag = await _repo.FetchFlagAsync(featureName);
        return new FeatureDefinition(
            name: featureName,
            enabledFor: flag.Enabled 
                ? new[] { new FeatureFilterConfiguration("AlwaysOn") } 
                : Array.Empty<FeatureFilterConfiguration>());
    }

    public async Task<IEnumerable<FeatureDefinition>> GetAllFeatureDefinitionsAsync()
    {
        var flags = await _repo.FetchAllFlagsAsync();
        return flags.Select(f => new FeatureDefinition(
            f.Name,
            f.Enabled ? new[] { new FeatureFilterConfiguration("AlwaysOn") } : Array.Empty<FeatureFilterConfiguration>()));
    }
}

// Infrastructure/ExternalFlagRepository.cs
public interface IExternalFlagRepository
{
    Task<FlagDto> FetchFlagAsync(string name);
    Task<IEnumerable<FlagDto>> FetchAllFlagsAsync();
}

public class InMemoryExternalFlagRepo : IExternalFlagRepository
{
    private readonly Dictionary<string,bool> _store = new() { ["NewUI"] = true, ["BetaEndpoint"] = false };
    public Task<FlagDto> FetchFlagAsync(string name) =>
        Task.FromResult(new FlagDto { Name = name, Enabled = _store.GetValueOrDefault(name) });
    public Task<IEnumerable<FlagDto>> FetchAllFlagsAsync() =>
        Task.FromResult(_store.Select(kv => new FlagDto { Name = kv.Key, Enabled = kv.Value }));
}

public record FlagDto { public string Name { get; init; } public bool Enabled { get; init; } }

builder.Services.AddSingleton<IExternalFlagRepository, InMemoryExternalFlagRepo>();
builder.Services.AddSingleton<IFeatureDefinitionProvider, ExternalFeatureProvider>();

Testing

Unit test attribute endpoints by mocking IFeatureManagerSnapshot.
Integration test custom provider by seeding InMemoryExternalFlagRepo.

Example xUnit test for manual check:

[Fact]
public async Task NewUI_ReturnsNotFound_WhenFlagOff()
{
    var fm = new Mock<IFeatureManagerSnapshot>();
    fm.Setup(x => x.IsEnabledAsync("NewUI", It.IsAny<CancellationToken>())).ReturnsAsync(false);

    var result = await new UIEndpoint(fm.Object).Get();
    Assert.IsType<NotFoundObjectResult>(result);
}

Feature flags give you the serenity to release often and safely. Stay Zen.

References

Official docs: https://learn.microsoft.com/en-gb/azure/azure-app-configuration/feature-management-dotnet-reference
GitHub repo: https://github.com/microsoft/FeatureManagement-Dotnet

🧘‍♂️ Like this kind of content?

Follow my dev blog → ZenOfCode

Or drop me a follow here on Dev.to 💬

Cryptocurrency & Blockchain 101: Bitcoin, Ethereum, dApps, and Beyond

ZenOfCode — Sat, 03 May 2025 06:00:00 +0000

Cryptocurrency and blockchain technology have shifted from niche curiosities to mainstream innovations powering finance, supply chains, gaming, and more. If you’ve ever wondered what makes Bitcoin different from Ethereum, or how decentralized apps (dApps), DeFi, and Web3 fit together, you’ve come to the right place. Let’s demystify the landscape in a calm, practical ZenOfCode style.

1. What Is Blockchain? (Simple Terms)

Shared digital notebook: Everyone holds the same copy. Write once, can’t erase.
Blocks & chain: Full pages (blocks) glue shut and link in order.
No single boss: The group agrees on new pages.

Zen tip: Blockchain is trust through transparency—everyone sees the same notebook.

2. Why Was Blockchain Invented?

Before blockchain, digital records and money relied on banks or companies to verify and store data. In 2008, Satoshi Nakamoto introduced Bitcoin and its blockchain to:

Enable peer‑to‑peer transactions without banks.
Guarantee immutability—once recorded, transactions can’t be altered.
Allow open participation—anyone can join, verify, and view data.

This created a “trustless” system: you don’t trust a single authority, the network enforces honesty.

3. Bitcoin: The Digital Gold

Launch: 2009 by Satoshi Nakamoto
Consensus: Proof‑of‑Work (PoW)—miners solve puzzles to add blocks.
Supply cap: 21 million BTC (deflationary)
Use case: Store of value, peer‑to‑peer cash

Feature	Bitcoin
Consensus	Proof‑of‑Work (PoW)
Supply cap	21 million BTC
Block time	~10 minutes
Smart contracts	Very limited (scripts)

Note: PoW secures the network but uses significant energy.

4. Ethereum: The World Computer

Launch: 2015 by Vitalik Buterin et al.
Smart contracts: Self‑executing code stored on‑chain.
EVM: The sandboxed “computer” that runs smart contracts.
Consensus: Switched to Proof‑of‑Stake (PoS) in 2022’s “Merge” (‑99% energy).

Feature	Ethereum
Consensus	Proof‑of‑Stake (PoS)
Supply policy	No fixed cap; dynamic issuance
Block time	~12–14 seconds
Smart contracts	First‑class citizens

Note: PoS uses far less energy and allows token‑holders to secure the network.

5. Other Blockchains at a Glance

Network	Consensus	Focus	Notable dApps / Projects
BSC (Binance Smart Chain)	PoSA (Staked Authority)	Low‑fee DeFi	PancakeSwap, Venus
Solana	PoH + PoS	High throughput, low latency	Serum, Audius
Polkadot	Nominated PoS (NPoS)	Interoperability (parachains)	Acala, Moonbeam
Avalanche	Snow-based PoS	Scalability and subnets	Trader Joe, Benqi

Analogy: Each blockchain is a café—pick the vibe and speed you like.

6. Decentralized Apps (dApps)

A dApp is like a vending machine on the blockchain:

You insert coins (crypto).
Smart contract runs automatically.
You get your snack (service) with no middleman.

Core parts

On‑chain smart contract (backend logic)
Web/mobile UI (frontend)
Wallet (e.g., MetaMask) to connect

Popular categories

DeFi: Aave, Uniswap
NFT marketplaces: OpenSea
Gaming & metaverse: Axie Infinity
DAOs: Aragon, Snapshot

7. What Is DeFi?

Decentralized Finance (DeFi) uses blockchain to offer financial services without banks.

Lending & borrowing: You lock crypto as collateral to borrow assets (Aave, Compound).
Decentralized exchanges (DEXs): Trade assets directly with others (Uniswap, SushiSwap).
Yield farming: Earn rewards by providing liquidity.
Stablecoins: Crypto pegged to fiat (USDC, DAI) for price stability.

Zen tip: DeFi is like an automated market of money lego—compose services without permission.

8. What Is Web3 & Its Evolution?

Web1 (1990s–early 2000s): Read‑only web—static pages and basic hyperlinks.

Web2 (mid 2000s–today): Read‑write web—dynamic, social, centralized platforms (Facebook, YouTube).

Web3 (emerging): Read‑write‑own web—decentralized, user‑owned networks powered by blockchain.

Key ideas

Ownership: Users truly own data and digital assets via wallets.
Permissionless: Anyone can build and use services without gatekeepers.
Trustless interactions: Smart contracts enforce rules rather than companies.

Evolution summary: Web1 gave information, Web2 enabled interaction, Web3 returns control to users.

9. Vital Concepts to Know

Wallets
- Hot wallets (online): MetaMask, Trust Wallet
- Cold wallets (offline): Ledger, Trezor
Exchanges
- Centralized: Coinbase, Binance
- Decentralized: Uniswap, PancakeSwap
Gas fees
- Payment to process transactions (varies by network load).
Private key vs. seed phrase
- Private key: Your secret password to spend crypto.
- Seed phrase: Backup to recover your wallet.

Security Zen: Never share your private key or seed phrase—treat it like your toothbrush.

10. Getting Started: Tools & Tips

Explore on testnets (Ropsten, Goerli) before mainnet.
Use faucets to get test tokens.
Simulate with local chains (Ganache).
Audit contracts (MythX, CertiK) before deploying.

Conclusion

Blockchain is simply a shared, unchangeable notebook for recording transactions without a central boss. Bitcoin gave us digital gold; Ethereum opened programmable finance; DeFi unlocked permissionless money legos; and Web3 returns data and asset ownership to users. Armed with this understanding—and the right wallets, tools, and security habits—you’re ready to explore and build in the decentralized world.

Stay calm, stay curious, and code (and transact) on.

All information is accurate as of May 2025. Always do your own research before investing or deploying smart contracts.

🧘‍♂️ Like this kind of content?

Follow my dev blog → ZenOfCode

Or drop me a follow here on Dev.to 💬

Vibe Coding: The Calm Revolution in Developer Workflows

ZenOfCode — Wed, 30 Apr 2025 05:00:00 +0000

Vibe Coding: The Calm Revolution in Developer Workflows

In the ever-evolving landscape of software development, 2025 has ushered in a paradigm shift known as vibe coding. Coined by AI researchers, vibe coding represents a transition from traditional, syntax-heavy programming to a more intuitive, AI-assisted approach where developers articulate their intentions in natural language, and AI tools generate the corresponding code.

What Is Vibe Coding?

At its core, vibe coding is about conveying the desired functionality or behavior of software through conversational prompts. Instead of meticulously writing out code line by line, developers describe what they want the software to do, and AI models translate these descriptions into executable code. This method emphasizes clarity of thought and design over manual coding, allowing developers to focus on the “what” rather than the “how.”

The Tools Empowering Vibe Coding

Several AI tools have emerged to facilitate vibe coding, catering to both novice and experienced developers:

GitHub Copilot: Provides code suggestions based on natural language comments and code context.
Replit: Offers an interactive coding environment with AI assistance for real-time code generation.
Cursor: An AI-first code editor designed to streamline the vibe coding experience.
Windsurf: Tailored for advanced users, offering sophisticated AI-driven code generation capabilities.

These tools integrate seamlessly into existing workflows, enhancing productivity without overwhelming the user.

Benefits of Vibe Coding

Enhanced Productivity: Reduces boilerplate coding, letting developers focus on design and problem-solving.
Lower Barrier to Entry: Enables contributors with limited coding experience to articulate ideas in plain language.
Rapid Prototyping: Transforms concepts into working prototypes quickly, facilitating faster iteration.
Focus on Intent: Shifts emphasis to desired outcomes and user experience rather than syntax details.

Challenges and Considerations

While vibe coding offers many advantages, it also brings considerations:

Understanding Generated Code: Developers must review and understand AI-generated code to ensure maintainability.
Security Concerns: AI models can introduce vulnerabilities if outputs aren’t carefully audited.
Maintaining Skills: Over-reliance on AI may erode fundamental coding abilities; balance is key.

Embracing the Zen of Vibe Coding

Vibe coding aligns perfectly with ZenOfCode’s principles: simplicity, clarity, and intentionality. By abstracting away syntax complexities, developers engage more deeply with the essence of their work, crafting software that is both functional and elegant.

As we integrate AI into our workflows, a balanced approach—leveraging AI for efficiency while preserving human insight—will define the next era of calm, focused development.

🧘‍♂️ Like this kind of content?

Follow my dev blog → ZenOfCode

Or drop me a follow here on Dev.to 💬

Crafting a Minimalist File Upload API with Node.js and Express

ZenOfCode — Mon, 28 Apr 2025 17:00:00 +0000

Crafting a Minimalist File Upload API with Node.js and Express

Need a simple file upload API without the overhead of a full-blown framework? Today, we’ll craft a calm, minimalist solution using Node.js and Express.

Just pure backend bliss.

Why Keep It Simple?
Project Setup
Building the API
Testing the Upload
Next Steps

Why Keep It Simple?

A basic file upload service is a common sidekick:

Upload profile pictures
Submit documents
Store small attachments

By using only Node.js + Express with a sprinkle of Multer, we can avoid bloat and focus on clarity.

Project Setup

Let’s spin up a fresh project:

mkdir file-upload-api
cd file-upload-api
npm init -y
npm install express multer

Then create an entry file:

touch index.js

Building the API

Create the Express Server

// index.js
const express = require('express');
const multer = require('multer');
const path = require('path');

const app = express();
const PORT = 3000;

// Set storage engine
const storage = multer.diskStorage({
  destination: './uploads/',
  filename: (req, file, cb) => {
    cb(null, `${Date.now()}-${file.originalname}`);
  }
});

const upload = multer({ storage });

// Middleware
app.use(express.json());

// Upload endpoint
app.post('/upload', upload.single('file'), (req, res) => {
  if (!req.file) {
    return res.status(400).json({ message: 'No file uploaded.' });
  }
  res.status(201).json({ filename: req.file.filename });
});

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

Create the Express Server

Make sure there’s a folder to store uploaded files:

mkdir uploads

Testing the Upload

You can test the API using Postman or cURL: Using cURL:

curl -F "file=@/path/to/your/file.jpg" http://localhost:3000/upload

You should receive:

{
  "filename": "timestamp-file.jpg"
}

And the file should appear inside the /uploads directory.

Using Postman:

Create a new POST request to http://localhost:3000/upload
Under “Body” select “form-data”
Add a field named file
Attach a file
Hit Send!

Next Steps

This calm little project can be expanded:
* Add file type restrictions (only images, only PDFs)
* Limit file size
* Integrate cloud storage (S3, Azure Blob)
* Add simple authentication

🧘‍♂️ Like this kind of content?

Follow my dev blog → ZenOfCode

Or drop me a follow here on Dev.to 💬

Building a RESTful To-Do API with Clean Architecture in Python

ZenOfCode — Mon, 28 Apr 2025 13:40:00 +0000

Building a RESTful To-Do API with Clean Architecture in Python

APIs power modern apps, but without good structure they become tangled. In this tutorial, you’ll learn how to create a simple To-Do API in Python—organized with clean architecture patterns for maintainability and testability.

What You’ll Build
Why Clean Architecture?
Project Structure
Step 1: Define Entities
Step 2: Use Cases (Business Logic)
Step 3: Interface Adapters (Controllers & Repos)
Step 4: Framework & Drivers (Flask)
Step 5: Testing
Next Steps

What You’ll Build

A minimal To-Do API with endpoints to:

Create a task
List all tasks
Update a task’s status
Delete a task

All following clean architecture layers so code remains decoupled and easy to evolve.

Why Clean Architecture?

Clean architecture separates concerns into layers:

Entities: Core business objects
Use Cases: Business rules
Interface Adapters: Convert data between layers
Framework & Drivers: External tools (e.g., Flask)

Benefits:

Testable business logic
Easier to swap frameworks or databases
Clear dependency rule: outer layers depend on inner ones

Project Structure

📂 todo-api
 ├── 📂 entities
 │    └── 📄 task.py
 ├── 📂 use_cases
 │    └── 📄 task_manager.py
 ├── 📂 adapters
 │    ├── 📄 repository.py
 │    └── 📄 controller.py
 ├── 📂 infrastructure
 │    └── 📄 flask_app.py
 └── 📂 tests
      └── 📄 test_use_cases.py

Step 1: Define Entities

# entities/task.py
from dataclasses import dataclass
from uuid import uuid4

@dataclass
class Task:
    id: str
    title: str
    completed: bool = False

    @staticmethod
    def create(title: str) -> "Task":
        return Task(id=str(uuid4()), title=title)

Task holds data and invariants.
create() ensures every task gets a unique ID.

Step 2: Use Cases (Business Logic)

# use_cases/task_manager.py
from typing import List
from entities.task import Task
from adapters.repository import TaskRepository

class TaskManager:
    def __init__(self, repo: TaskRepository):
        self.repo = repo

    def add_task(self, title: str) -> Task:
        task = Task.create(title)
        return self.repo.save(task)

    def list_tasks(self) -> List[Task]:
        return self.repo.get_all()

    def mark_completed(self, task_id: str) -> Task:
        task = self.repo.get_by_id(task_id)
        task.completed = True
        return self.repo.save(task)

    def delete_task(self, task_id: str) -> None:
        self.repo.delete(task_id)

Business rules live here—no Flask or database code.

Step 3: Interface Adapters

# adapters/repository.py
from entities.task import Task

class TaskRepository:
    def __init__(self):
        self.storage: dict[str, Task] = {}

    def save(self, task: Task) -> Task:
        self.storage[task.id] = task
        return task

    def get_all(self) -> list[Task]:
        return list(self.storage.values())

    def get_by_id(self, task_id: str) -> Task:
        return self.storage[task_id]

    def delete(self, task_id: str) -> None:
        del self.storage[task_id]

# adapters/controller.py
from flask import request, jsonify, Blueprint
from use_cases.task_manager import TaskManager
from adapters.repository import TaskRepository

bp = Blueprint('tasks', __name__)
repo = TaskRepository()
manager = TaskManager(repo)

@bp.route('/tasks', methods=['POST'])
def create_task():
    data = request.json
    task = manager.add_task(data['title'])
    return jsonify(vars(task)), 201

@bp.route('/tasks', methods=['GET'])
def list_tasks():
    tasks = manager.list_tasks()
    return jsonify([vars(t) for t in tasks])

@bp.route('/tasks/<id>/complete', methods=['PATCH'])
def complete_task(id):
    task = manager.mark_completed(id)
    return jsonify(vars(task))

@bp.route('/tasks/<id>', methods=['DELETE'])
def delete_task(id):
    manager.delete_task(id)
    return '', 204

Step 4: Framework and Drivers

# infrastructure/flask_app.py
from flask import Flask
from adapters.controller import bp

def create_app():
    app = Flask(__name__)
    app.register_blueprint(bp, url_prefix='/api')
    return app

if __name__ == '__main__':
    app = create_app()
    app.run(debug=True)

Runs on http://localhost:5000/api/tasks

Step 5: Testing

# tests/test_use_cases.py
import pytest
from use_cases.task_manager import TaskManager
from adapters.repository import TaskRepository

@pytest.fixture
def manager():
    return TaskManager(TaskRepository())

def test_add_and_list(manager):
    manager.add_task("Write blog post")
    tasks = manager.list_tasks()
    assert len(tasks) == 1
    assert tasks[0].title == "Write blog post"

Focus on use cases—no need to spin up Flask.

Next Steps

Persist to a real database (SQLAlchemy adapter).
Add authentication (JWT middleware).
Expand entities (due dates, priorities).

🧘‍♂️ Like this kind of content?

Follow my dev blog → ZenOfCode

Or drop me a follow here on Dev.to 💬

How I Use ChatGPT to Refactor Smarter, Not Harder

ZenOfCode — Sat, 26 Apr 2025 21:00:00 +0000

📬 Originally published on ZenOfCode

I'm reposting here to share with more devs — feedback welcome!

How I Use ChatGPT to Refactor Smarter, Not Harder

Refactoring old code feels like walking through a minefield. One wrong move and boom — tests fail, bugs spawn, and your day is ruined.

Here’s how I use ChatGPT as a legit refactoring assistant — not just a novelty.

🧪 Step 1: Let It Explain Old Code

Before I even touch anything, I drop chunks into ChatGPT and ask:

“Explain what this code does and if there are any smells.”

It helps me:

Understand legacy patterns
Spot anti-patterns
See opportunities to clean up

🧠 Step 2: Ask for a Refactored Version

Once I know what it does, I ask:

“Refactor this code to use cleaner naming and extract logic to smaller methods.”

You’ll get suggestions like:

Breaking up long methods
Extracting reusable logic
Better naming

🧼 Step 3: Keep the Parts You Like

ChatGPT isn’t perfect — but it’s a powerful second brain.

Use its suggestions as a starting point, then tweak it to your taste.

⚙️ Bonus: Custom Prompts That Work

Here are a few prompts I’ve saved:

“Refactor this async method to improve readability and keep exception safety.”
“Can you convert this into a more testable service class?”
“Suggest a more SOLID-compliant structure for this code.”

📦 Tools I Pair With It

GitHub Copilot – for inline suggestions
TestGPT – helps generate test cases
Prettier – keep things neat post-refactor

🧠 TL;DR

ChatGPT can help you read, refactor, and rethink your code
It’s not cheating — it’s upgrading your solo dev experience
You still drive — AI just helps navigate

🧘‍♂️ Like this kind of content?

Follow my dev blog → ZenOfCode

Or drop me a follow here on Dev.to 💬

10 VS Code Extensions That Actually Save You Time (Not Just Look Cool)

ZenOfCode — Fri, 25 Apr 2025 21:00:00 +0000

📬 Originally published on ZenOfCode

I'm reposting here to share with more devs — feedback welcome!

10 VS Code Extensions That Actually Save You Time (Not Just Look Cool)

VS Code is 🔥 by default — but the right extensions can take you from dev mode to flow state. Here are 10 extensions I use regularly that actually make me faster, not just flashy.

🚀 1. GitLens

Shows git blame, history, authorship inline.

🧠 Why it matters: Stop asking “Who wrote this?” — GitLens shows it in your editor.

📁 2. Path Intellisense

Auto-suggests file paths as you type.

🧠 Why it matters: No more guessing folder structures or mistyping filenames.

🪛 3. REST Client

Send HTTP requests without leaving your editor.

🧠 Why it matters: Great for quick API testing — faster than Postman for small stuff.

💡 4. TODO Highlight

Highlights your // TODO: and // FIXME: comments.

🧠 Why it matters: Keeps dev debt visible before it becomes tech debt.

🔄 5. Prettier

Auto-formats your code on save.

🧠 Why it matters: Consistency, peace of mind, and zero arguments in PRs.

⚙️ 6. Error Lens

Shows linting + runtime errors directly in-line.

🧠 Why it matters: Fix bugs faster with less clicking.

🔒 7. dotenv

Syntax highlighting for .env files.

🧠 Why it matters: So small but so helpful. Especially for backend projects.

🧱 8. Bracket Pair Colorizer 2

Color-codes matching brackets.

🧠 Why it matters: Essential for nested functions, JSX, or regex hell.

🧭 9. CodeSnap

Take beautiful code screenshots.

🧠 Why it matters: Perfect for blogs, tweets, or docs.

🤖 10. GitHub Copilot

You know the deal.

🧠 Why it matters: Not just autocomplete — it gives full suggestions that can unblock you.

🧠 TL;DR

Install a few of these today. Don’t go plugin crazy — but the right tools compound your speed every day.

🧘‍♂️ Like this kind of content?

Follow my dev blog → ZenOfCode

Or drop me a follow here on Dev.to 💬

Stop Overengineering: Clean Architecture for Real-World APIs

ZenOfCode — Fri, 25 Apr 2025 02:29:40 +0000

📬 Originally published on ZenOfCode

I'm reposting here to share with more devs — feedback welcome!

Stop Overengineering: Clean Architecture for Real-World APIs

If you’ve ever opened a codebase and thought “WTF is all this layering?”, you’re not alone. Clean architecture is powerful — but it’s easy to take it too far and turn your API into a slow-motion car crash of abstraction.

In this post, I’ll break down a practical version of clean architecture for building APIs that are clean, scalable, and easy to ship.

⚙️ What is “Clean Architecture”... really?

At its core:

Business logic should live in one place
External systems (DBs, APIs, UI) are details, not your core
Your code should read like the use-case it solves

🧱 Layers That Actually Matter

Here’s a simple structure that works:

/src
  /Application  ← Business logic (use cases, services)
  /Domain       ← Models and rules
  /Infrastructure ← Database, API clients
  /Web          ← Controllers, HTTP handlers

No fluff. No 13 interfaces for a method that sends an email.

🧼 Keep These Rules in Mind

1. Use Interfaces Where You Actually Swap Implementations

If you’re never going to mock or switch your EmailService, don’t create IEmailSenderFactoryAdapterV2. Keep it simple.

2. Your Controllers Should Do Almost Nothing

No logic in the controller. Just call your use case, handle the response.

[HttpPost("users")]
public async Task<IActionResult> CreateUser(CreateUserRequest request)
{
    var result = await _createUserUseCase.Execute(request);
    return Ok(result);
}

3. Dependency Injection is a Tool, Not a Religion

Wire up only what you need. Avoid over-wiring things you’ll never use.

🚀 Real-World Example: Creating a User API

Here’s how a real CreateUser use case might flow:

Controller gets the HTTP request
Calls CreateUserUseCase from Application
CreateUserUseCase validates + handles logic
Calls UserRepository (in Infrastructure)
Returns a result

Boom. Clean. Easy to test. Easy to maintain.

🧠 TL;DR

Don’t overengineer for problems you don’t have
Keep things layered — but practical
Clean code is readable, not academic
Code Zen = Calm Code = Happy Dev 😌

🧘‍♂️ Like this kind of content?

Follow my dev blog → ZenOfCode

Or drop me a follow here on Dev.to 💬

DEV Community: ZenOfCode

Feature Flags in .NET

Feature Flags in .NET: A Minimal API with Toggle Power (Using Microsoft.FeatureManagement)

Why Use Microsoft.FeatureManagement?

Table of Contents

Project Setup

Define Feature Flags in Configuration

Wire Up Microsoft.FeatureManagement

Use Flags in Endpoints

FeatureGate Attributes

Custom Feature Provider

Testing

References

Cryptocurrency & Blockchain 101: Bitcoin, Ethereum, dApps, and Beyond

1. What Is Blockchain? (Simple Terms)

2. Why Was Blockchain Invented?

3. Bitcoin: The Digital Gold

4. Ethereum: The World Computer

5. Other Blockchains at a Glance

6. Decentralized Apps (dApps)

7. What Is DeFi?

8. What Is Web3 & Its Evolution?

9. Vital Concepts to Know

10. Getting Started: Tools & Tips

Conclusion

Vibe Coding: The Calm Revolution in Developer Workflows

Vibe Coding: The Calm Revolution in Developer Workflows

What Is Vibe Coding?

The Tools Empowering Vibe Coding

Benefits of Vibe Coding

Challenges and Considerations

Embracing the Zen of Vibe Coding

Crafting a Minimalist File Upload API with Node.js and Express

Crafting a Minimalist File Upload API with Node.js and Express

Table of Contents

Why Keep It Simple?

Project Setup

Building the API

Testing the Upload

Using Postman:

Next Steps

Building a RESTful To-Do API with Clean Architecture in Python

Building a RESTful To-Do API with Clean Architecture in Python

Table of Contents

What You’ll Build

Why Clean Architecture?

Project Structure

Step 1: Define Entities

Step 2: Use Cases (Business Logic)

Step 3: Interface Adapters

Step 4: Framework and Drivers

Step 5: Testing

Next Steps

How I Use ChatGPT to Refactor Smarter, Not Harder

How I Use ChatGPT to Refactor Smarter, Not Harder

🧪 Step 1: Let It Explain Old Code

🧠 Step 2: Ask for a Refactored Version

🧼 Step 3: Keep the Parts You Like

⚙️ Bonus: Custom Prompts That Work

📦 Tools I Pair With It

🧠 TL;DR

10 VS Code Extensions That Actually Save You Time (Not Just Look Cool)

10 VS Code Extensions That Actually Save You Time (Not Just Look Cool)

🚀 1. GitLens

📁 2. Path Intellisense

🪛 3. REST Client

💡 4. TODO Highlight

🔄 5. Prettier

⚙️ 6. Error Lens

🔒 7. dotenv

🧱 8. Bracket Pair Colorizer 2

🧭 9. CodeSnap

🤖 10. GitHub Copilot

🧠 TL;DR

Stop Overengineering: Clean Architecture for Real-World APIs

Stop Overengineering: Clean Architecture for Real-World APIs

⚙️ What is “Clean Architecture”... really?

🧱 Layers That Actually Matter

🧼 Keep These Rules in Mind

1. Use Interfaces Where You Actually Swap Implementations