DEV Community: Majdi Zlitni

Augmented Coding Patterns: The Developer's Playbook for Working With AI

Majdi Zlitni — Fri, 06 Feb 2026 11:19:11 +0000

AI as your new pair partner but are you using it right?

Every developer I know has tried AI-assisted coding but most are doing it wrong.

They paste code, get output, accept or reject. Rinse, repeat. That's not augmented coding that's autocomplete with extra steps.

The Augmented Coding Patterns project created by Lada Kesseler
changes that.
It's a living catalog of patterns, anti-patterns, and obstacles that define how developers should truly collaborate with LLMs in their daily workflow.

What Are Augmented Coding Patterns?

Think of them like the Gang of Four design patterns but for human-AI collaboration. They're recurring solutions to recurring problems that arise when you use LLMs (Claude, GPT, Copilot, etc.) as coding partners.

The catalog is organized into three pillars:

Category	What It Covers
Patterns	Proven techniques that work feedback loops, semantic zooming, visible context
Anti-Patterns	Traps developers fall into blind trust, context starvation, over-delegation
Obstacles	Inherent limitations of LLMs you must design around

Pattern 1: Feedback Loops

The Problem

You give the AI a big task. It gives you 200 lines. You read them, find 3 bugs, rewrite half of it. You just wasted 15 minutes.

The Pattern

Build small, iterative cycles. Ask for one function. Validate. Ask for the next. Correct course early.

Real Example

Anti-pattern (one-shot prompting):

"Build me a complete ASP.NET Core REST API with authentication,
JWT, validation, rate limiting, and SQL Server integration for a Todo app."

Pattern (feedback loop):

Step 1: "Create the Express server setup with CORS and JSON middleware."
→ Review → Approve

Step 2: "Add a POST /api/todos route with Zod validation for title (string, 
required) and completed (boolean, default false)."
→ Review → Fix the Zod schema import → Approve

Step 3: "Add JWT middleware. Here's my auth flow: [describe]."
→ Review → Adjust token expiry → Approve

Each iteration is small enough to validate in under 60 seconds. Errors are caught before they compound.

Implementation in Practice

Step 1: You ask AI to scaffold the validation layer
Step 2: You ask AI to create the route handler using your schema
Step 3: You review: AI used safeParse correctly, returns flattened errors.
Step 4: Let's say it didn't add the userId from JWT. You correct: "Add userId from req.user.id to the created todo."

The key: never let more than 30 lines go unreviewed.

Pattern 2: Semantic Zooming

The Problem

You're stuck at one level of abstraction. Either you're in the weeds asking about semicolons, or you're at 30,000 feet asking "how should I architect this?"

The Pattern

Shift between levels deliberately.:

Start high (architecture)
Toom to mid-level (module design)
Dive to low-level (implementation)
Zoom out to verify the big picture still holds.

Real Example

ZOOM LEVEL 1 Architecture:
"I'm building a notification service. I need to support email, SMS, and push notifications. What's the best pattern? I want it extensible."

AI Response: Strategy pattern + factory + message queue.

ZOOM LEVEL 2 Module Design:
"Show me the interface for the NotificationStrategy and the factory that selects the right one."

ZOOM LEVEL 3 Implementation:
"Implement the EmailStrategy using AWS SES. Here are my SES configuration constraints: [details]."

ZOOM BACK TO LEVEL 1:
"Given what we've built, does this architecture handle the case where SMS fails and we need to retry with exponential backoff? What needs to change?"

Each zoom level gives the AI the right amount of context to produce useful output:

Level 1: The architecture AI suggested
Level 2: The factory
Level 3: The implementation

Pattern 3: Visible Context Show Your Work

The Problem

You ask the AI to fix a bug but don't show it the error message, the test that failed, or the surrounding code. It hallucinates a solution for a problem it can't see.

The Pattern

Externalize everything the AI needs: error logs, test output, type definitions, database schemas, business rules. Make the invisible visible.

Real Example

Context-starved prompt:

"My user registration is broken. Fix it."

Context-rich prompt:

"My user registration throws this error:

  PrismaClientKnownRequestError: Unique constraint failed 
  on the fields: (`email`)

Here's my register function: [paste code]
Here's my Prisma schema for User: [paste schema]
Here's the test that fails: [paste test]

The test creates a user, then tries to create another with 
the same email. I expect a 409 Conflict response but I'm 
getting a 500."

The AI now has a crystal-clear picture and can respond with accurate response.

The Top 3 Anti-Patterns to Avoid

1. Blind Trust

Never accept AI output without reading it. Period. The AI doesn't know your business rules, your deployment constraints, or your team conventions.

2. Context Starvation

The less context you give, the more the AI hallucinates. Every prompt should include:

Relevant code
Errors
Types
Constraints.

3. Over-Delegation

"Build me a production-ready microservices architecture" is not a prompt it's a prayer.

Break it down
Own the decisions
AI will handle the implementation

The developers who will thrive in the AI era aren't the ones who prompt the best. They're the ones who collaborate the best.

References:

A reading first GH-300 cert prep: what to study, what to skip, and what actually matters

Majdi Zlitni — Sun, 28 Dec 2025 18:50:27 +0000

How I passed the GH-300 (GitHub copilot) certification

In this blog I will explains how I prepared for the GH-300 GitHub Copilot certification, what resources actually mattered, and what I learned especially if you prefer reading over watching videos, like I do.

What is GH-300?
Exam basics (quick Facts)
Assessment
Main course I used (core resource)
What I learned the most
- Principles of prompt engineering
- How Copilot learns from our prompts
- How GitHub copilot processes our input
Extra Microsoft learn modules I found useful
GitHub and advanced topics I explored
Practice questions
My final tips
Final thoughts

What is GH-300?

GH-300 is a Microsoft certification exam focused on GitHub Copilot.

It validates the ability to use GitHub Copilot effectively and responsibly in real-world development workflows.

Key topics include:

Responsible AI (7%)
GitHub copilot plans and features (31%)
How GitHub copilot works and handles data (15%)
Prompt crafting and prompt engineering (9%)
Testing with GitHub copilot (9%)
Privacy fundamentals and context exclusions (15%)

More details provided by Microsoft on their exam study guide.

Check the official: Microsoft course GH-300T00-A: GitHub Copilot

Exam basics (quick facts)

What you need to know before the exam:

Exam code: GH-300
Passing score: 700 / 1000
Duration: 1 hour 40 minutes
Questions: ~60–65
Format: Multiple choice, multiple answer, scenario-based
Difficulty: Generally easy, especially if you already use GitHub Copilot in your IDE

Assessment

You can check your knowledge and try the official practical exam which is free and a great way to identify your weak areas.

Main course I used (core resource)

I relied primarily on the Microsoft Learn GH-300 course:

Why this worked for me

Text-based content
Easy to skim and navigate
Clear learning objectives
No unnecessary fluff

Since I prefer reading over videos, this format let me focus on what matters.

What I learned the most

Principles of prompt engineering

The 4 Ss of prompt engineering

Single → One well-defined task
Specific → Clear and explicit instructions
Short → Concise, straight to the point
Surround → Use descriptive filenames & keep related files open for context

This alone improves Copilot output dramatically.

Practical example

BAD: "Write a function"

GOOD: "Write a TypeScript function that validates email addresses using regex. Include error handling and return a Boolean."

How Copilot learns from our prompts

Zero-shot learning
The model generates an answer based only on your prompt, without any examples.
One-shot learning
The model is given one example along with the prompt, helping it understand the desired format or logic.
Few-shot learning
The model is provided with several examples in the prompt, allowing it to better generalize and produce more accurate or relevant outputs.

How GitHub copilot processes our input

Understanding this helps with both exam questions and real usage:

Secure prompt transmission
- Your prompt is securely sent to GitHub servers.
Proxy filtering
- Blocks prompt injection attacks
- Prevents system manipulation
Toxicity filtering
- Blocks hate speech
- Filters inappropriate content
- Redacts detected personal data
Code generation using LLMs
- Models trained on public code
- Generates based on context and prompts

👉 If you want to see my detailed study notes you can check it via Notion

Extra Microsoft learn modules I found useful

These are not strictly required for GH-300, but they clarify concepts:

GitHub and advanced topics I explored

These helped me understand real-world usage beyond the exam:

Practice questions

This open source repo is a life saving because it contain really good practical questions with explanations and hints directing to official sources you can check it practical copilot exam:

Exam-style practice questions
Detailed explanations for each answer
Links directing to official Microsoft Learn resources
Not a question dump it's a legitimate study project to help people pass GitHub certifications

My Final Tips

DO:

Start with practice assessments to identify gaps
Use Microsoft Learn, it's the source of truth
Focus on concepts and reasoning, not memorization
Understand why Copilot behaves the way it does
Study Responsible AI thoroughly it's heavily weighted
Practice prompt engineering with real examples
Review enterprise features

DON'T:

Skip the "boring" sections on ethics and privacy
Memorize answers without understanding reasoning
Ignore the official study guide

Final Thoughts

GH-300 is not about being a "Copilot power user." It's about:

Understanding how Copilot works data flow, security, limitations
Using it responsibly ethics, bias awareness, copyright considerations
Integrating it effectively real developer workflows, best practices
Knowing when to trust (and distrust) AI-generated code

Good luck!

Learning resources I used, where to practice your knowledge and how you can earned your GitHub cert too.

Majdi Zlitni — Sat, 25 Oct 2025 17:10:31 +0000

Majdi Zlitni

Oct 25 '25

I’ve earned my GitHub Foundations Certification for that I’ve shared my learning resources, and how you can earned your GitHub cert too.

How You can Earn Your GitHub Certification; Lessons, Resources & the Story Behind Mona the Octocat

Majdi Zlitni ・ Oct 25

#github #git #opensource

Comments

1 min read

I’ve earned my GitHub Foundations Certification for that I’ve shared my learning resources, and how you can earned your GitHub cert too.

Majdi Zlitni — Sat, 25 Oct 2025 17:08:32 +0000

How You can Earn Your GitHub Certification; Lessons, Resources & the Story Behind Mona the Octocat

Majdi Zlitni ・ Oct 25

#github #git #opensource

How You can Earn Your GitHub Certification; Lessons, Resources & the Story Behind Mona the Octocat

Majdi Zlitni — Sat, 25 Oct 2025 15:31:47 +0000

The mascot behind the GitHub logo
The fun story behind Mona the GitHub mascot
GitHub Certification
Exam Details
My Study Method
Key Lesson

The mascot behind the GitHub logo

In the early days of GitHub (around 2008), the founders wanted something fun for their error pages, specifically the 404 Not Found page.

They bought a stock illustration from iStockphoto created by Simon Oxley, the same artist who designed the original Twitter bird.

That illustration was called “Octopuss”, a cute half-cat, half-octopus standing in a puddle.

When GitHub used it, they renamed it “Octocat” for obvious reasons😹.

Later, GitHub designer Cameron McEfee gave Mona her unique identity and created themed variations to expand on the Octocat for various internal uses, including slide decks, blog posts, and event promotions. He began illustrating the Octocat in different costumes and with different personalities, which proved to be very popular.

The fun story behind Mona the GitHub mascot

In the early days of GitHub, the daughter of one of GitHub’s developers fell in love with the Octocat. In that love, she wrote a story.

Once upon a time, there was a cat whose name was Monalisa. Monalisa and her owner went to the beach. When Monalisa got to the beach, her owner Kelly gave her goggles so Monalisa could swim and see what was in the ocean. When Monalisa went in the water she found lots of fish. When Monalisa was swimming she was so excited she opened her mouth and swallowed a coral that made you grow legs like an octopus but keep your normal face. So Monalisa grew legs and became Mrs. Monalisa Octocat. [sic]

The Octocat is more than a logo; it is a symbol of creativity, curiosity, and collaboration which are the values that reflect GitHub’s developer community.

GitHub Certification

The GitHub Foundations Certification validates your understanding of:

GitHub’s core features (repos, branching, pull requests)
Collaboration tools (Issues, Projects, Discussions)
GitHub Actions & Automation
Security & Compliance features (like Dependabot, code scanning)
Billing & licensing models

If you are a student with the GitHub Student Developer Pack, you receive a one-time free passing voucher, so you can save $99 USD.

Exam Details

The exam duration is 120 minutes, so you can get ~1.6 minutes/question with a total of 75 questions in multiple-choice and multiple-answer formats.

The passing score is 700/1000. You can take the exam either in a test center or online; I prefer the test center to avoid the extensive online proctoring process.

There is no penalty for wrong answers, so leave nothing empty!

The certification is valid for two years from the date of achievement.

My Study Method

I use GitHub daily, so I focused on filling knowledge gaps and understanding advanced features.

I started with the Microsoft Practice Assessment.

I reviewed my weak topics using the Microsoft Learn modules.

I studied GitHub Foundations Part 1 and GitHub Foundations Part 2, took notes, and used AI prompts to deeply explain difficult concepts.

Here’s an example of an AI prompt that I used:

You are a GitHub expert trainer. I’m preparing for the Foundations certification. Your goal is to help me master every concept through challenging, exam-style practice questions and explanations.

I used the Role + Context + Goal to create a good prompt:

Role → Define who the assistant should be. Example: “You are a GitHub certification coach.”
Context → Describe the situation or task. Example: “We’re preparing for the GitHub Foundations certification.”
Goal → Specify the outcome you want. Example: “Generate tricky, realistic exam-style questions with detailed explanations.”

This approach enhanced my knowledge particularly in areas I found tricky.

I practiced using ghcertified, which is a great open-source project you can contribute to or get started with on GitHub: https://github.com/Shahbaz-Alee/GitHub-Foundation-Exam-Prep/blob/main/Slides.pdf

Note: They don’t include official exam questions; all content is original.

I skim-read Andrew Brown's slides provided by FreeCodeCamp a great resource with images and examples.

Key Lesson

GitHub is not just a code host, it’s a collaboration hub, and this certification is just the beginning toward more advanced GitHub certifications. It is the initial step to understand the core concepts, products, and workflows for collaborating on GitHub.

If you’re starting this journey, take your time, keep learning, and remember every git commit -m "init" is a step forward in your progress.

Why I changed to Cloudflare and you should too

Majdi Zlitni — Wed, 15 Oct 2025 00:08:11 +0000

First Stop
Comparing Hosting Platforms
Why I Chose Cloudflare Pages
Setting Up My Domain
Goodbye Vercel
Final Thoughts

I used to deploy on Vercel, and it was my go to because it made everything free, fast, and globally available.

Until this happened:

// Detect dark theme var iframe = document.getElementById('tweet-1972669025525158031-960'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1972669025525158031&theme=dark" }

Seeing that post made it clear, I had to quit Vercel and move to something else not just for technical reasons, but for principles.

I wanted to support platforms that align with transparency, openness, and independence.

First Stop

At first, I tried Replit (@helloreplit).

Many developers were migrating there in support of the Pro-Palestine movement, and I wanted to contribute, even in the smallest way. Everyone was talking about Replit.

// Detect dark theme var iframe = document.getElementById('tweet-1972706418794045832-179'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1972706418794045832&theme=dark" }

The migration was smooth:

With just a few clicks after linking my GitHub account and selecting the Starter plan, Replit’s AI agent handled most of the setup automatically:

Unfortunately, when publishing, it asked to upgrade my plan, and with Tunisia’s monetary regulations and foreign currency restrictions, that wasn’t an option.

So, I canceled and looked for another free way to publish my portfolio.

Amjad Masad, CEO of Replit, made great moves to attract users and even offered $50 in credits:

// Detect dark theme var iframe = document.getElementById('tweet-1972805067771355518-983'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1972805067771355518&theme=dark" }

Comparing Hosting Platforms

Here’s a technical breakdown of alternatives I researched:

Platform	Type	Free Plan	Custom Domain	CI/CD Support	Backend Support	Ease of Use	Best For	Notes
Cloudflare Pages	Managed Hosting	✅ Yes	✅ Yes	✅ Yes (GitHub/GitLab)	⚠️ Limited (Static + Workers)	⭐⭐⭐⭐⭐	Static & JAMStack Sites	Excellent docs, global CDN, easy migration.
GitHub Pages	Managed Hosting	✅ Yes	✅ Yes	⚠️ Limited (manual CI/CD)	❌ No	⭐⭐⭐	Portfolios, docs, static sites	Simple but lacks backend/dynamic features.
Render	Managed Hosting	✅ Yes (limited hours)	✅ Yes	✅ Yes	✅ Full backend (Node, Python, etc.)	⭐⭐⭐⭐	Full-stack & API apps	Auto SSL, DBs, background workers.
Hetzner Cloud	Self-Hosted VPS	❌ No (paid)	✅ Yes	✅ Custom via CI/CD tools	✅ Full backend	⭐⭐⭐	Devs who want control	Cheap, powerful VPS for custom infra.
Docker + Coolify (Self-Hosted)	Self-Hosted	⚠️ Free (if self-hosted)	✅ Yes	✅ Yes (custom)	✅ Full backend	⭐⭐	Experienced devs	Great for learning DevOps & full control.

Why I Chose Cloudflare Pages

Deployed on 300+ global edge locations → ultra-fast performance.
Built-in CI/CD with GitHub/GitLab auto builds & previews.
Serverless backend via Cloudflare Workers.
Free SSL, CDN, DDoS protection, and image optimization included.
Supports Next.js, Astro, Remix, SvelteKit, and more.
Zero config, instant scaling, and excellent documentation.

In short: Cloudflare Pages + Workers = frontend + backend on the edge globally distributed, secure, and free.

Setting Up My Domain

After deployment, I updated my DNS records using ATI.tn

Tunisia’s official domain registry which offers custom domains for 12 TND/year.

Having your own domain means:

Full control over your brand identity
A professional, portable online presence
Freedom from platform lock-in

“Customization isn’t free, but it’s worth it.”

After switching to Cloudflare nameservers, everything synced perfectly:

Deployment successful!

Goodbye Vercel

Finally, I deleted my Vercel account and officially joined the boycott movement, a small but meaningful step to align with my values.

Final Thoughts

Cloudflare Pages is the best free edge hosting option for developers in 2025.
For more control or backend apps, Hetzner + Coolify is an amazing combo.
Your hosting choices can reflect your values, independence, and technical standards.

In the end, the best stack is the one you own ethically, technically, and creatively.

Keywords for SEO

cloudflare pages, vercel alternative, free deployment, jamstack hosting, self-hosted devops, hetzner, coolify, static site hosting, tunisia domain, ati.tn, developer migration

Why manually registering component when Auto-Discovery exist?

Majdi Zlitni — Thu, 18 Sep 2025 16:17:32 +0000

For production grade applications SOLID are a must principles, but when adding a new feature open for extension close for modification principle could be easily violated.

Hardcoding filters

Let's take an example of an image processing application where we need an image filter plugin system.

The core interface is simple, it must be implemented by classes as a best practice.
Name represents the filter that we will apply to a given image.

The common approach

The common way is to manually register every known filter

public class FilterManager
{    
    public IFilter GetFilter(string filterName)
    {
        switch (filterName.ToLower())
        {
            case "grayscale":
                return new GrayscaleFilter();

            case "sepia":
                return new SepiaFilter();

            // PROBLEM: To add a new filter, we must come back here and modify this file.
            /*
            case "invert":
                return new InvertColorsFilter();
            */

            default:
                throw new NotSupportedException($"Filter '{filterName}' is not recognized.");
        }
    }
}

Main application logic:

Why this is a problem?

This approach is technical debt and time consuming because it will introduce:

Open/Close principle violation: The FilterManager is not 'closed for modification.' To add a new InvertColorsFilter, we are forced to open and change the FilterManager code which is time consuming, overwhelming and could be risky for a production grade level.
Error prone: Whenever a new filter is added we should always add it to code to previous switch statement and this creates a tightly coupled application.
Merge conflict: For faster problems solving and project success, team play is needed but as the team grow a single file can become the hotspot where multiple developers edit it simultaneously, which introduces frustrating merge conflicts.

Assembly scanning for discovery as a solution

Refactoring the code for a production-grade level by adding a generic engine that builds classes automatically would be a better approach.

public class FilterManager
{
    private readonly IReadOnlyDictionary<string, Type> _discoveredFilters;

    public FilterManager(IReadOnlyDictionary<string, Type> discoveredFilters)
    {
        _discoveredFilters = discoveredFilters;
    }

    public IFilter GetFilter(string filterName)
    {
        if (!_discoveredFilters.TryGetValue(filterName.ToLower(), out var filterType))
        {
            throw new NotSupportedException($"Filter '{filterName}' is not recognized.");
        }        
        return (IFilter)Activator.CreateInstance(filterType)!;
    }
}

private static IReadOnlyDictionary<string, Type> BuildFilterCatalog()
{
    var catalog = new Dictionary<string, Type>();    
    var pluginAssembly = typeof(Program).Assembly;
    var filterTypes = pluginAssembly.GetTypes()
        .Where(t => t.IsClass && !t.IsAbstract && typeof(IFilter).IsAssignableFrom(t));

    foreach (var type in filterTypes)
    {
        var tempFilter = (IFilter)Activator.CreateInstance(type)!;
        Console.WriteLine($"[Plugin Discovery] Found filter: '{tempFilter.Name}'");
        catalog[tempFilter.Name.ToLower()] = type;
    }

    return catalog;
}

How it works

discoveredFilters.TryGetValue(...): Tries to find an entry in the dictionary using a key.
pluginAssembly.GetTypes(): The pluginAssembly have references to .dll and .exe files.
- GetTypes(): will return every single:
- class
- interface
- struct
- enum
.Where(...): Is a Language Integrated Query, used to keep data that satisfy given conditions.
- t.IsClass: checks if the current type is a class.
- !t.IsAbstract: filters out abstract classes.
- typeof(IFilter).IsAssignableFrom(t): determines if the type can be assigned to a variable of type IFilter.

foreach loop takes a list of objects, each representing a filter class discovered by reflection and for each type in the list, an instance of the class is created using Activator.CreateInstance().

What is reflection?

In .NET an Assembly is a compiled output of code that contains .dll and .exe files and by using System.Reflection.Assembly we can load and inspect our solution files programmatically

Combining dynamic discovery via reflection with builder pattern we achieved not only flexible but also an extensible architecture.

We have used reflection and dependency injection to load filters dynamically without hard coding.

Conclusion

Using this shifting mindset we can create robust and scalable system but scanning every assembly can lead to slowness therefore we should be specific for best practices.

A Comprehensive Guide To Exception Handling in C# .NET

Majdi Zlitni — Sat, 18 May 2024 11:14:23 +0000

What is an exception?

An exception is an occurrence during the execution of a program that disrupts it normal flow.

In the world of computers, when you tell a program to do something, sometimes it runs into a problem. An exception is the way the program says, "Oops! I can't do what you asked because there's a problem."

As you can see in the picture bellow the debugger which is a powerful tool that allows developers to inspect the behavior of their code during execution, making it easier to identify and fix issues such as bugs and exceptions.
In debug mode, when an exception occurs and is not caught by a catch block within the same method, the debugger typically interrupts the program execution and highlights the line of code where the exception occurred.

Why handling exception?

Let's think about riding your bike. When you're on your bike, you wear a helmet, right? That helmet is there just in case you fall, it's there to protect your head from getting hurt.

Now, in the world of computers, sometimes things go wrong when a program is trying to do its job, just like there might be a pothole or a branch that could make you fall off your bike.

Handling exceptions is like wearing your helmet when riding your bike. It is a way for the program to say, "Whoops, something went wrong here, but don't worry buddy, I know what to do!"
Just like your helmet keeps you safe, handling exceptions keeps the program safe so it doesn't crash and lose all the work it was doing.

So by handling exceptions, we can provide meaningful error messages to the user and prevent our programs from terminating unexpectedly. It also allows us to implement recovery scenarios and ensures that the code following the faulty one does not get affected by an error.

How exception are handled

In C# .NET, exceptions are handled using a combination of the try, catch, and finally keywords.

try contains the section of code that might potentially throw an exception.
catch blocks are used to handle any exceptions that occur within the corresponding try block.
The finally block, if present, is executed regardless of whether an exception is thrown or not. This is usually used for cleanup code that must be run regardless of whether an operation succeeds or fails.

In this example MethodToHandleException attempts to divide 10 by 0 using the Divide method. If a DivideByZeroException occurs, it prints an error message, otherwise, it catches any other exceptions and prints a generic error message.

The method ensures cleanup by printing "Cleaning up..." regardless of whether an exception occurs.

  public void HandleDivideByZeroException()
    {
        try
        {
            // Code that might throw an exception
            Divide(10, 0); // Attempting to divide by zero
        }
        catch (DivideByZeroException ex)
        {
            // Handle divide by zero exception
            Console.WriteLine("Error: " + ex.Message);
            // Rethrow the exception without losing the original stack trace
            throw;
        }
        catch (Exception ex)
        {
            // Handle other exceptions
            Console.WriteLine("An unexpected error occurred: " + ex.Message);
        }
        finally
        {
            // Cleanup code, regardless of whether an exception occurred
            Console.WriteLine("Cleaning up...");
        }
    }

There are 3 ways to re-throw an exception:

`throw` — rethrows the current exception and preserves the stack trace.
throw ex — throws an existing exception but resets the stack trace from the point of rethrow.
`throw new Exception` — creates a new exception, which completely rewrites the stack trace.

Handling Exceptions With Filtering in C#

The when clause in C# catch blocks allows as to specify a condition that if true it will be handled in the catch block.

This functionality, termed exception filtering, proves beneficial in situations where exceptions should only be caught under specific circumstances.

We can employ a when clause to handle various instances of FormatException differently:

try
{
   var result = ConvertToNumber("123abc");
   Console.WriteLine($"Processing result: {result}");
}
catch (FormatException ex) when (ex.Message.Contains("invalid format"))
{
   Console.WriteLine("Data has an invalid format. Please check your inputs.");
}
catch (FormatException ex) when (ex.Message.Contains("empty string"))
{
   Console.WriteLine("No data provided. Please enter some numeric data.");
}
catch (OverflowException ex) when (ex.Message.Contains("too large"))
{
   Console.WriteLine("Data is too large. Please enter a smaller number.");
}
catch (Exception ex)
{
   Console.WriteLine($"An unexpected error occurred: {ex.Message}");
}

Best practices for exception handling in C

Avoid throwing generic exceptions:

Throwing generic exceptions like System.Exception can make it difficult to determine the root cause of an issue. Instead, use specific exception types to provide more context and make debugging easier.
Avoid swallowing exceptions:

Swallowing exceptions by catching them and not doing anything with them can hide problems in your code and make debugging challenging. At the very least, log exceptions so you have a record of what went wrong.
Handle exceptions at the appropriate level:

Handle exceptions at the appropriate level of abstraction in your code. For example, catch exceptions at the UI layer for user-facing errors and catch them closer to the source for technical errors.
Provide meaningful error messages:

When throwing exceptions, provide meaningful error messages that explain what went wrong and how to resolve the issue. This makes it easier for developers to understand and address problems.

Here's an example of handling a specific scenario using these best practices:

We have a method that loads data from a file.

We catch specific exceptions like FileNotFoundException and IOException to handle file-related errors and inform the user appropriately.

For any other unexpected errors, we log the exception and inform the user to contact support for assistance.

Finally, we rethrow the exception to ensure it's not swallowed and can be handled elsewhere if necessary.

public void LoadDataFromFile(string filePath)
{
    try
    {
        // Attempt to load data from the file
        var data = File.ReadAllText(filePath);
        ProcessData(data);
    }
    catch (FileNotFoundException ex)
    {
        // Log the exception and inform the user that the file does not exist
        Log.Error(ex, "File not found: {FilePath}", filePath);
        MessageBox.Show($"The file '{filePath}' does not exist.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
    catch (IOException ex)
    {
        // Log the exception and inform the user that there was an error reading the file
        Log.Error(ex, "Error reading file: {FilePath}", filePath);
        MessageBox.Show($"An error occurred while reading the file '{filePath}'. Please try again later.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
    catch (Exception ex)
    {
        // Log the exception and inform the user that an unexpected error occurred
        Log.Error(ex, "An unexpected error occurred while loading data from file: {FilePath}", filePath);
        MessageBox.Show("An unexpected error occurred. Please contact support for assistance.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
        throw; // Rethrow the exception to ensure it's not swallowed
    }
}

DEV Community: Majdi Zlitni

Augmented Coding Patterns: The Developer's Playbook for Working With AI

AI as your new pair partner but are you using it right?

What Are Augmented Coding Patterns?

Pattern 1: Feedback Loops

The Problem

The Pattern

Real Example

Implementation in Practice

Pattern 2: Semantic Zooming

The Problem

The Pattern

Real Example

Pattern 3: Visible Context Show Your Work

The Problem

The Pattern

Real Example

The Top 3 Anti-Patterns to Avoid

1. Blind Trust

2. Context Starvation

3. Over-Delegation

A reading first GH-300 cert prep: what to study, what to skip, and what actually matters

How I passed the GH-300 (GitHub copilot) certification

Table of Contents

What is GH-300?

Exam basics (quick facts)

Assessment

Main course I used (core resource)

Why this worked for me

What I learned the most

Principles of prompt engineering

The 4 Ss of prompt engineering

Practical example

How Copilot learns from our prompts

How GitHub copilot processes our input

Extra Microsoft learn modules I found useful

GitHub and advanced topics I explored

Practice questions

My Final Tips

Final Thoughts

Learning resources I used, where to practice your knowledge and how you can earned your GitHub cert too.

I’ve earned my GitHub Foundations Certification for that I’ve shared my learning resources, and how you can earned your GitHub cert too.

How You can Earn Your GitHub Certification; Lessons, Resources & the Story Behind Mona the Octocat

Majdi Zlitni ・ Oct 25

I’ve earned my GitHub Foundations Certification for that I’ve shared my learning resources, and how you can earned your GitHub cert too.

How You can Earn Your GitHub Certification; Lessons, Resources & the Story Behind Mona the Octocat

Majdi Zlitni ・ Oct 25

How You can Earn Your GitHub Certification; Lessons, Resources & the Story Behind Mona the Octocat

Table of Contents

The mascot behind the GitHub logo

The fun story behind Mona the GitHub mascot

GitHub Certification

Exam Details

My Study Method

Key Lesson

Why I changed to Cloudflare and you should too

Table of Contents

First Stop

Comparing Hosting Platforms

Why I Chose Cloudflare Pages

Setting Up My Domain

Goodbye Vercel

Final Thoughts

Keywords for SEO

Why manually registering component when Auto-Discovery exist?

Hardcoding filters

The common approach

Why this is a problem?

Assembly scanning for discovery as a solution

How it works

What is reflection?

Conclusion

A Comprehensive Guide To Exception Handling in C# .NET

What is an exception?

Why handling exception?

How exception are handled

Handling Exceptions With Filtering in C#

Best practices for exception handling in C