I would look at .NET

For the web, you have ASP.NET Core. It feels like Rails or Django, but with static typing that makes a lot of things easier. You can do things like `db.Books.Where(b => b.PublishedAt < DateTime.Now && b.Rating > 3 && b.AuthorId == 101)` and you get all the normal auto-completion because it's statically typed. With .NET, you can compile down to a single, self-contained binary which makes it really easy to deploy a simple app and Microsoft has really easy Docker container setups if you want to deploy with Fly.io or anything else. You also get the benefit of more speed than you'll get from Ruby or Python. That's certainly not a deal-breaker with other languages, but it's always nice to have something that is just a bit faster.

ASP.NET also makes it really easy to get started. I think a lot of things that aren't named Rails or Django don't make it easy to get started - or they make it easy to get to "Hello World," but then you're left with "uh, how do I connect to a database? I guess I find my own library for this? Is there a template engine? Wait, do I need to choose a JSON serializer?" One of the things that makes Rails and Django so great is that they offer you a great starting experience. ASP.NET offers that Rails/Django-like experience.

It's also simple to return JSON from your endpoints to create an API for your front-end (if you want to use React or something) or your mobile apps.

C# feels a lot like Kotlin to me. It's a Java-like language that has made practical decisions that make it a lot easier to use. There's a lot of things that just make it pleasant to use, if you're looking for the imperative/OO style of programming you'd get with a Ruby/Kotlin/Python/Java/etc. If you're looking for Lisp, it's not Lisp.

C# and .NET are both very mature and Microsoft is putting a ton of work into the ecosystem. Performance is already top-notch (which basically means equivalent to Java and Go in the GC world) and they're continually improving it every year. They're investing in a lot of great stuff like Blazor which is basically a replacement for things like React and Vue, but using C# and Razor templates via WASM (and that can also be executed on the server).

`dotnet watch` is just great. It'll hot-reload your code when you change things and when there are edits it can't hot-reload, it'll recompile and relaunch in a second or two.

.NET offers MAUI (Multi-platform App UI). Basically, write your apps in C# and MAUI and get native apps for Android, iOS, Windows, Mac, Tizen, and likely community-support for Linux. MAUI has some rough edges, but it's getting better and you can always web-view your website to begin. At the same time, Microsoft is putting a lot of effort behind it and I think it will pay off with nice apps that use native widgets without requiring two separate code bases. You've noted Flutter and that's probably the biggest alternative, but Flutter doesn't use native widgets. That's not necessarily bad, but it does mean that the apps are probably going to feel a bit less at home on iOS. There's also the chance to basically share the objects that you're returning as JSON from your backend with your mobile app. Instead of having your backend `Book` class and then making sure your Dart front-end's `Book` class remains in sync with any changes, you just have a single `Book` and don't have to worry about it. You talked about "redundancy and additional parts" and while keeping that stuff in sync isn't necessarily hard, it can be an annoying task that doesn't bring joy. Heck, one of the big things about Rails was that so many stacks made you do tasks that weren't necessarily "hard", but really didn't bring joy - especially when you were searching for a typo that just made things not work.

The great thing about Rails is how productive it lets one person be. You aren't spending your time choosing libraries and wiring things together. I think ASP.NET Core offers that and more - static typing, great performance, and dead-simple deployment with self-contained binaries.

Personally, I'm liking HTMX for adding interactivity to my app. I don't have the most experience with JS out there and I'm not looking to create something that needs the level of interactivity that might require React and it allows me to do the things that will be nice for users.

If I were looking for more interactivity and didn't mind giving up a little "App speed and performance, specially on the client side", I think I'd reach for Blazor. I believe .NET 7 (coming in November) will be making improvements in Blazor performance and client download size, but it's still decent with .NET 6. Plus, improvements to WASM will make Blazor a lot better. Right now, GC'd languages need to ship their garbage collector as WASM code in the download, but it looks like WASM will handle garbage collection natively in the future. Blazor is around half as fast as React and the download sizes will likely be 3 times as large, but as Microsoft improves Blazor and WASM gets better the gap will likely narrow. Plus, with Blazor, you can just create a .NET MAUI Blazor app and now you have your iOS/Android apps. Later, if you want a more native experience on iOS/Android, you can shift to a native .NET MAUI app (rather than web-view powered).

What are the downsides of the .NET/C# ecosystem. First, I'd say that if you're not on Windows, you're going to want to pay for JetBrains' Rider ($150/$120/$90 per year for first, second, third+ years). It just works and it's wonderful. There is a Visual Studio for Mac which is decent and better than a lot of IDE/editor ecosystems out there for other languages. There is VSCode with its C#/.NET support and again it can be decent if you're used to working with an editor that doesn't help you 100% of the time. Rider can just be so pleasant though. Also, once you get over a certain amount of revenue or employees, Visual Studio Community isn't free. If you have over 250 PCs or $1M in annual revenue, you have to pay the $500 for Visual Studio Professional. That isn't much compared to the $100,000-300,000 per year you're paying a developer or even the $150/year you're likely paying Slack, but it can certainly be a turn-off to some people. There is always VSCode which is decent and free and Rider which is just wonderful (and only $250/year for businesses from the third year on), but I know some people just hate the idea that the best editor experience might cost some money (and that most people in the C# world will just pay $100-500 a year to get it rather than fighting the system for open source).

Second, I'd say that nothing really matches Rails' asset pipeline in terms of letting a backend-heavy programmer have a decent front-end setup without having to dive into the whole world of Grunt/Webpack/Gulp/Browserify/etc. It's been a while since I've used Rails, but I remember that being such a nice addition. Microsoft does have some docs (https://learn.microsoft.com/en-us/aspnet/core/client-side/bu...) and you can always use Gulp or Webpack or whatnot and LigerShark's WebOptimizer will let you minify and bundle things in C# (and handle TypeScript compilation, Sass, vendor prefixing, etc), but I remember Rails' opinionatedness being kinda nice for this.

Finally, I'd say that C# and .NET can be annoying if you care about little things. For example, I've heard a lot of people debate significant whitespace vs. opening/closing braces or tags. If you care about those things, C# might be a bit annoying. I'll give you an example to illustrate. This is what a simple data class would look like in C#:

class Person
{
public string Name { get; set; }
public int? Age { get; set; }
public boolean IsAdmin { get; set; }

}

"Omg, the variables are PascalCase like classes." "I hate that I see the `{ get; set; }`" (I just type `prop` in my IDE and it creates the property so I don't even have to type it all). "How could they put the opening brace on a new line!"

I get complaints like that, but it's also stuff that kinda falls into the background when you're actually trying to get work done. Java beans didn't fall into the background. You'd be fighting constant little cuts and it would be hard to differentiate a class that had special behavior from one that was just a basic bean. The properties in C# are easy to see that they have no special behavior and easy to see when they do have special behavior (you can just do `{ get => _age + 10; set => _age = value; }` if you want a custom getter).

ASP.NET Core really grabs so much of the best ideas out there in a language that's really good with great IDE support and dead-simple deployment as a single binary - and all with one of the biggest companies out there funding people to make it better, write docs, etc. And it takes time to write great, in-depth posts like this: https://devblogs.microsoft.com/dotnet/performance_improvemen.... I find it a pleasant place to develop where I can just focus on my work.