# Software Engineering — Daily DevOps & .NET > Articles about software engineering principles, methodologies, and practices for building professional, maintainable, and scalable software solutions. Source: https://daily-devops.net/tags/softwareengineering/ Generated: 2026-06-14 ## About this topic - [Topic landing page](https://daily-devops.net/tags/softwareengineering/): Articles about software engineering principles, methodologies, and practices for building professional, maintainable, and scalable software solutions. - [Back to all topics](https://daily-devops.net/tags/) - [Site index](https://daily-devops.net/llms.txt) ## Articles tagged "Software Engineering" (44) - [The Codebase Doesn't Know You Quit](https://daily-devops.net/posts/code-as-legacy-after-you-leave/): Every company I've worked for has forgotten most of what I did. The code hasn't. Your name is still in the commit log, and no one can ask you anything. - [The Machine Writes. The Legacy Is Still Mine.](https://daily-devops.net/posts/code-as-legacy-age-of-ai/): Copilot and Claude finish methods before I do, shipping code under my name. What changes when the author is partly a machine, and what doesn't. - [You're Shipping Bugs Faster, and Your Tests Are Helping](https://daily-devops.net/posts/tunit-ai-coding-agents/): AI coding agents make you ship faster. They make your bugs faster too. Generated tests verify what the code does, not what it should. Here's why TUnit helps. - [I'm Done Making Empty Promises](https://daily-devops.net/posts/code-as-legacy-empty-promises/): // TODO: fix this properly. We'll refactor after the release. Tests when the API stabilizes. I've made every one of these promises. I'm done. - [My Biggest Enemy Writes My Code](https://daily-devops.net/posts/code-as-legacy-past-self/): Past Self is the most dangerous engineer on your team: skilled, well-intentioned, and gone when the bill comes due. This is about the code he left behind. - [Six Ways ILogger Silently Fails in Production](https://daily-devops.net/posts/your-ilogger-is-lying-to-you/): Half a day lost to BeginScope silently doing nothing in production. ILogger compiles, runs, produces no errors, and fails quietly in six distinct ways. - [The Code You Write Today Is Someone's Problem Tomorrow](https://daily-devops.net/posts/code-as-legacy/): Code is not just something you write—it is something you leave behind. After nearly two decades in production, here is what treating code as legacy means. - [Stop Pretending TimeProvider Doesn't Exist](https://daily-devops.net/posts/stop-pretending-timeprovider-doesnt-exist/): DateTime.UtcNow is a hidden dependency that breaks tests at midnight. .NET 8 shipped TimeProvider in 2023; two years on, most codebases still ignore it. - [AI Code Review Is a Sycophant: Why It Always Approves](https://daily-devops.net/posts/ai-code-review-is-a-sycophant/): Copilot and Claude find real bugs, but miss wrong abstractions and bad designs. Understanding that gap matters more than debating the tools. - [Source Generators: The Build Performance Killer](https://daily-devops.net/posts/dotnet-source-generators-hidden-costs/): You added a NuGet package and your build jumped from 2 to 8 seconds. That package ships a source generator. Here is what it costs and how to find out. - [Purpose Limitation in API Design: Leaking Data You Shouldn't](https://daily-devops.net/posts/purpose-limitation-api-design/): Why your API returns too much personal data and how ASP.NET Core resource-based authorization enforces data minimization at the endpoint level. - [Real Professional Software Engineering in the AI Era](https://daily-devops.net/posts/real-professional-software-engineering-ai-era/): AI generates code instantly. Professionals spot when it is subtly wrong, debug failures AI cannot reason about, and see through the productivity narrative. - [The Feedback Loop That AI Can't Replace](https://daily-devops.net/posts/feedback-loop-ai-cant-replace/): Compilers validate logic, profilers expose performance lies, and production reveals every deferred decision. AI cannot close that feedback loop for you. - [Kehrwoche: What Swabian Cleaning Teaches About Technical Debt](https://daily-devops.net/posts/kehrwoche-technical-debt/): A Swabian tradition reveals why small, routine maintenance beats big cleanup initiatives—and what software teams get wrong about technical debt. - [Alphabet Soup: The Format Buffet Nobody Ordered](https://daily-devops.net/posts/alphabet-soup-file-formats/): CSV breaks on commas. YAML breaks on spaces. JSON breaks on trailing commas. TOML, TAML, TOON, CCL joined the chaos. Nobody wins. Here's why. - [Why Real Professionals Will Never Be Replaced by AI](https://daily-devops.net/posts/code-sharpens-thinking/): Typing code is trivial now—AI does it instantly. So why will real professionals never be replaced? Because vibe coding collapses under production reality. - [Most Software Teams Are Lying to Themselves—2026 Needs to Be Different](https://daily-devops.net/posts/happy-new-year-2026/): Stop promising to fix technical debt next quarter. .NET 10, analyzers, and tests are ready in 2026; only the engineering discipline is missing. - [2025 in Review: The Year .NET Stopped Lying to Itself](https://daily-devops.net/posts/dotnet-2025-year-in-review/): No runtime revolutions—Aspire, TUnit, and Testcontainers won by making distributed systems visible. Plus .NET's open source sustainability crisis. - [Stop Typing: The .NET CLI Tab Completion You've Been Missing](https://daily-devops.net/posts/dotnet-cli-expanding-scope-autocomplete/): .NET 10 ships native tab completion for the dotnet CLI. One command, no Register-ArgumentCompleter snippets, and your shell finally remembers. - [.NET Job Scheduling — Choosing the Right Framework](https://daily-devops.net/posts/dotnet-job-scheduling-7-comparative-review/): Side-by-side comparison of Hangfire, Quartz.NET, Coravel, NCronJob, and TickerQ with feature matrices and decision heuristics for .NET architects. - [.NET Job Scheduling — TickerQ and Modern Architecture](https://daily-devops.net/posts/dotnet-job-scheduling-6-tickerq/): How TickerQ uses source generation, EF Core, and a real-time dashboard to deliver reflection-free, async-first scheduling for modern cloud-native systems. - [Power of Ten Rules: More Relevant Than Ever for .NET](https://daily-devops.net/posts/dotnet-power-of-ten-rules/): Holzmann's safety-critical coding rules hit harder in modern C#: Roslyn analyzers, nullable types, and the type system enforce what C only wished. - [.NET Job Scheduling — NCronJob and Native Minimalism](https://daily-devops.net/posts/dotnet-job-scheduling-5-ncronjob/): NCronJob plugs into ASP.NET Core hosting to deliver zero-dependency, cron-based scheduling for microservices and containerized .NET deployments. - [.NET Job Scheduling — Coravel and Fluent Simplicity](https://daily-devops.net/posts/dotnet-job-scheduling-4-coravel/): How Coravel delivers lightweight, convention-driven scheduling without external dependencies, accelerating development for small to medium applications. - [.NET Job Scheduling — Quartz.NET for Enterprise Scale](https://daily-devops.net/posts/dotnet-job-scheduling-3-quartznet/): Quartz.NET delivers enterprise scheduling with clustering, advanced triggers, job calendars, and multi-datacenter coordination for high-volume workloads. - [.NET Job Scheduling — Hangfire and Persistent Reliability](https://daily-devops.net/posts/dotnet-job-scheduling-2-hangfire/): How Hangfire delivers persistent background processing with built-in dashboards, automatic retries, and distributed job execution for web applications. - [.NET Job Scheduling — The Landscape](https://daily-devops.net/posts/dotnet-job-scheduling-1-landscape/): Why background processing matters for cloud-native .NET, and how schedulers evolved from manual timers to robust, distributed orchestration engines. - [.NET Job Scheduling — The Complete Series](https://daily-devops.net/posts/dotnet-job-scheduling/): Seven articles comparing Hangfire, Quartz.NET, Coravel, NCronJob, and TickerQ—match each .NET job scheduler to the workloads it actually fits. - [.NET 10 Testing: Microsoft Finally Fixed the Test Runner (Mostly)](https://daily-devops.net/posts/dotnet-10-testing/): Microsoft.Testing.Platform replaces VSTest in .NET 10. See what improves, what breaks, and why your global.json now matters in IDE and CI reliably. - [Code Metrics and Configuration: Beyond the Numbers Game](https://daily-devops.net/posts/code-metrics-configuration/): A critical look at .NET and Visual Studio code metrics, their configuration, and why context matters infinitely more than arbitrary thresholds. - [.NET 10 and the Release Cycle Paradox](https://daily-devops.net/posts/dotnet-10-release-cycle-paradox/): .NET's predictable yearly cadence delivers stability and pressure at once: migration insights, cultural notes, and recommendations for .NET 10. - [Stop Breaking Multi-Targeting Builds with String Comparisons](https://daily-devops.net/posts/proper-use-of-targetframework-conditions/): String comparisons in TargetFramework conditions break multi-targeting builds. Here is why IsTargetFrameworkCompatible() exists and saves you hours. - [Modern Defensive Programming in .NET 8/9 with Throw Helpers](https://daily-devops.net/posts/modern-defensive-programming/): ArgumentNullException.ThrowIfNull modernizes .NET guard clauses; NetEvolve.Arguments gives a unified API across multi-framework target projects. - [Stop Parsing the Same String Twice: CompositeFormat in .NET](https://daily-devops.net/posts/compositeformat-performance-boost/): Parse once, format a thousand times. CompositeFormat eliminates redundant parsing overhead and makes your .NET apps faster with one simple change. - [Clean Code: A Lip Service, Not a Standard](https://daily-devops.net/posts/clean-code-lip-service-not-a-standard/): How misunderstood Clean Code ideals harm .NET systems. Learn to recognize code quality failures and apply C# best practices for maintainable software. - [ConstantExpectedAttribute: Compile-Time Performance](https://daily-devops.net/posts/constant-expected-attribute/): How ConstantExpectedAttribute in .NET 7+ enables compile-time optimizations, better IDE support, and improved performance via constant signaling. - [Retiring Legacy .NET Projects: Risk, Cost, Forward Motion](https://daily-devops.net/posts/retiring-legacy-dotnet-projects/): Modernize legacy .NET systems with modular architecture, risk reduction, cost efficiency strategies, and practical patterns for measurable impact. - [TUnit — A Pragmatic Evaluation for .NET Teams](https://daily-devops.net/posts/tunit-a-pragmatic-evaluation-for-dotnet-teams/): A pragmatic TUnit evaluation for .NET teams - comparing performance, maintainability, and ecosystem readiness against MSTest, xUnit, and NUnit frameworks. - [Buzzword-Driven Development vs. Fundamental Software Quality](https://daily-devops.net/posts/buzzword-driven-development/): Why fundamental .NET software quality must never be sacrificed for trendy buzzwords, including recommended analyzers, settings, and practices. - [Instruction by Design: Transforming ADRs into Actionable AI Guidance](https://daily-devops.net/posts/instruction-by-design/): Transform architectural decision records (ADRs) into actionable AI guidance for enhanced team consistency, streamlined onboarding, and automated workflows. - [Vibe Coding in .NET: Creative Catalyst or Maintenance Risk?](https://daily-devops.net/posts/vibe-coding-isnt-wrong-its-unfinished/): Explore the balance between intuitive coding and structured development in .NET, examining when vibe coding helps and when it hinders project success. - [Managing Errors, Warnings, and Configurations in C# and .NET](https://daily-devops.net/posts/managing-errors-warnings-and-configurations/): Learn strategies for managing static code analysis warnings, improving code quality, configuring analyzers, and integrating into CI/CD pipelines. - [A Tale of Forgotten Pennies and Lost Dollars](https://daily-devops.net/posts/tale-of-forgotten-pennies-and-lost-dollars/): Discover how small technical debts accumulate into major project costs and learn strategies to manage them effectively in software development. - [Introducing Nullability in Legacy .NET Code](https://daily-devops.net/posts/introducing-nullability-in-legacy-code/): Step-by-step guide for implementing nullable reference types in legacy .NET and C# codebases with practical strategies, patterns, and best practices. ## Optional - [Full site index for LLMs](https://daily-devops.net/llms.txt) - [Full content of all articles](https://daily-devops.net/llms-full.txt) - [RSS for this tag](https://daily-devops.net/tags/softwareengineering/feed.rss) - [Atom for this tag](https://daily-devops.net/tags/softwareengineering/feed.atom) - [JSON Feed for this tag](https://daily-devops.net/tags/softwareengineering/feed.json)