Sitemap
A list of all the posts and pages found on the site. For you robots out there, there is an XML version available for digesting as well.
Pages
Posts
Testing ASP.NET Core Apps: xUnit and Integration Tests with WebApplicationFactory
Published:
This post covers the two testing layers most .NET teams rely on heavily: unit tests with xUnit and integration tests with WebApplicationFactory. Unit tests give you fast feedback on isolated logic. Integration tests prove that your application actually boots, routes requests, resolves dependencies, and returns the expected HTTP responses.
EF Core Performance: AsNoTracking, Compiled Queries, and Split Queries
Published:
This post covers some of the most useful EF Core performance techniques you will apply in read-heavy applications: disable tracking for read-only queries, project only the data you need, use compiled queries for hot paths, and understand when split queries help avoid large join explosions. Performance work starts with measurement, but these patterns are worth knowing early.
EF Core Fundamentals: DbContext, Migrations, Tracking, and Relationships
Published:
This post covers the pieces of Entity Framework Core you need before building real data-backed applications. The essential model is: your entities represent data, DbContext coordinates access to that data, migrations evolve the schema, and change tracking decides what EF Core will insert, update, or delete.
Authorization in ASP.NET Core: Policies, Roles, Claims, and Resource-Based Access
Published:
This post covers the part of security that decides what an authenticated user is allowed to do. In ASP.NET Core, authorization usually builds on roles, claims, named policies, and sometimes resource-specific checks performed in code. If authentication answers “who are you?”, authorization answers “may you do this?”.
Authentication Basics for .NET APIs: Cookies vs JWT vs OAuth2/OIDC
Published:
This post gives an overview of the most common authentication approaches you will see in .NET applications: cookies, JWT bearer tokens, and OAuth2/OIDC-based sign-in flows. The important thing is not memorizing every protocol detail. The important thing is understanding what each approach is for and when it fits.
REST Best Practices for ASP.NET Core APIs: Status Codes, Pagination, Filtering, and Versioning
Published:
This post covers the API design habits that matter once you move beyond “it works on my machine” and start building endpoints other systems will rely on. Good REST design is mostly about clear resource modeling, predictable status codes, safe query patterns, and a versioning strategy you decide before clients are locked in.
Error Handling in ASP.NET Core: Middleware, Exception Filters, and ProblemDetails
Published:
This post covers how to handle failures in an ASP.NET Core API without leaking stack traces or returning random error shapes. The goal is not to prevent every exception. The goal is to catch failures at the right level, log them, and return a consistent response contract such as ProblemDetails.
Model Binding and Validation in ASP.NET Core: DataAnnotations and FluentValidation Basics
Published:
This post covers two important jobs the framework performs for you: model binding and validation. Model binding turns incoming HTTP data into .NET values. Validation checks whether those values satisfy your rules. If you understand where each responsibility begins and ends, your endpoints become much easier to reason about.
Building Your First Web API in .NET 8: Controllers, Minimal APIs, and Routing
Published:
This post shows how to build your first ASP.NET Core Web API and, more importantly, how to think about the choices you make along the way. The two main styles are controllers and minimal APIs, and both rely on the same routing system underneath. Once you understand those pieces, building new endpoints stops feeling mysterious.
Dependency Injection Basics in .NET 8: Lifetimes, Service Registration, and the Options Pattern
Published:
This post covers the built-in Dependency Injection container in .NET and the concepts you need to use it safely. If you remember only one idea, make it this: services should declare what they need through constructor parameters, and the container should create those dependencies with the correct lifetime.
Logging and Diagnostics in .NET 8: ILogger, Structured Logging, and Log Levels
Published:
This post covers the logging and diagnostics features you should understand before running a .NET application in any real environment. The short version is: use ILogger everywhere, log structured data instead of string-concatenated messages, and configure log levels deliberately so production logs remain useful instead of noisy.
Configuration and Secrets in .NET 8: appsettings.json, Environment Variables, and User Secrets
Published:
This post covers how configuration works in modern .NET applications and how to keep secrets out of source control. The core idea is simple: settings should come from configuration providers, secrets should be stored outside your repo, and your code should read configuration through strongly typed options whenever possible.
C# Essentials for .NET Developers: Types, LINQ, and Async/Await
Published:
This post covers the C# features every .NET developer uses daily. You do not need to master every corner of the language on day one, but you do need a solid grip on how types behave, how LINQ transforms data, and how async/await keeps your application responsive. These three areas show up in almost every code review, bug report, and production service.
Project Structure in .NET 8: Solutions, .csproj, NuGet, and Build Outputs
Published:
This post covers how a typical .NET codebase is organized. New developers often focus on Program.cs and controllers, but production projects are shaped just as much by how solutions are split, how project files are configured, how packages are restored, and where compiled artifacts are written. If you understand those four pieces, you can navigate almost any .NET repository with less guesswork.
Setting Up Your .NET 8 Development Environment (SDK, VS Code/Visual Studio, and CLI Basics)
Published:
Setting Up Your .NET 8 Development Environment
.NET 8 Web API Fundamentals: Routing, Models, Validation, and the Request Pipeline
Published:
This post covers the fundamentals of building a Web API with .NET 8 (ASP.NET Core). If you’re new to the ecosystem, your goal isn’t to memorize every feature—it’s to understand the core mechanics: how requests flow through your app, how endpoints are defined, how data is validated, and how responses are shaped. Once these pieces click, everything else becomes “just configuration”.
portfolio
AI Articles
Published:
In this section, I share technical deep dives on Artificial Intelligence systems, covering model integration, production deployment patterns, performance considerations, and architectural trade-offs. The articles explore how AI capabilities are engineered into scalable, distributed systems, focusing on real-world implementation rather than theory. Explore the posts by clicking on AI Articles above.
Clouds Articles
Published:
This section documents architectural patterns and engineering practices across modern cloud ecosystems. Topics include distributed system design, scalability strategies, resilience patterns, and cloud-native implementation models. The articles emphasize real-world trade-offs and production considerations for building robust, enterprise-grade platforms. Explore the posts on clicking on Clouds Articles above.
publications
Paper Title Number 1
Published in Journal 1, 2009
This paper is about the number 1. The number 2 is left for future work.
Recommended citation: Your Name, You. (2009). "Paper Title Number 1." Journal 1. 1(1).
Download Paper | Download Slides | Download Bibtex
Paper Title Number 2
Published in Journal 1, 2010
This paper is about the number 2. The number 3 is left for future work.
Recommended citation: Your Name, You. (2010). "Paper Title Number 2." Journal 1. 1(2).
Download Paper | Download Slides
Paper Title Number 3
Published in Journal 1, 2015
This paper is about the number 3. The number 4 is left for future work.
Recommended citation: Your Name, You. (2015). "Paper Title Number 3." Journal 1. 1(3).
Download Paper | Download Slides
Paper Title Number 4
Published in GitHub Journal of Bugs, 2024
This paper is about fixing template issue #693.
Recommended citation: Your Name, You. (2024). "Paper Title Number 3." GitHub Journal of Bugs. 1(3).
Download Paper
Paper Title Number 5, with math \(E=mc^2\)
Published in GitHub Journal of Bugs, 2024
This paper is about a famous math equation, \(E=mc^2\)
Recommended citation: Your Name, You. (2024). "Paper Title Number 3." GitHub Journal of Bugs. 1(3).
Download Paper
talks
Talk 1 on Relevant Topic in Your Field
Published:
This is a description of your talk, which is a markdown file that can be all markdown-ified like any other post. Yay markdown!
Conference Proceeding talk 3 on Relevant Topic in Your Field
Published:
This is a description of your conference proceedings talk, note the different field in type. You can put anything in this field.
teaching
Teaching experience 1
Undergraduate course, University 1, Department, 2014
This is a description of a teaching experience. You can use markdown like any other post.
Teaching experience 2
Workshop, University 1, Department, 2015
This is a description of a teaching experience. You can use markdown like any other post.