Why isn’t dotnet core popular among startups?
old.reddit.com
old.reddit.com
What risk do you see here?
https://news.ycombinator.com/item?id=37470318
That might be a place to start looking.
It basically comes down to:b they could take development in any direction and the community of users is powerless.
There's a distinction to be made between doing something in public and something being done by the public.
- this year's correct way to access your database is...
- this year's correct way to serve dynamic web pages is...
- this year's correct way to make a Windows GUI is...Except in the case of languages/tools like python, node, neovim etc. Everytime I touch one of these there is always a new better way of accessing DBs, making a web server, making a client side render, no a server side render, async library, configuration system, build system, runtime, GUI patterns etc.
The only difference I see between both is that there is an authoritative opinion when it comes to .NET (Microsoft) while there is no authority figure when it comes to node/Javascript. Even the actual runtime, package manager, module resolution, build tools etc get forked and replaced but since there is no authority, everyone is like "lets wait and see who wins". While with a language like .NET (or Go for that matter) you know that whatever comes from Microsoft (or Google) is the authoritative answer and people are more likely to jump to it right away.
Don’t get me wrong, the naming sucks. Microsoft is far more likely to recycle names for marketing reasons than just introduce a new name for plethora of stupid reasons.
But Active Server Pages means nothing anymore. It stopped meaning anything since 2003 but they use it as a brand name than anything. It’s no less stupid than gulp, bower, webpack, bun, deno, express, koa, next, vite, etc.
It sounds like your argument is "because Microsoft".
If you are using VS Code, GitHub, or TypeScript -- well, all those are also controlled by Microsoft, aren't they? Microsoft is the biggest investor in OpenAI and in fact offers their own Azure labeled OpenAI -- are you going to give up on OpenAI because it's Microsoft controlled? React is controlled by Facebook. Go is controlled by Google. So what?
Why use C#?
- It's a very small step from TypeScript to C# if a team needs higher throughput on the backend[1][2]
- `System.Linq` provides a superset of JS Array methods and is easy to map from one to the other.
- It's performance is on par or superior to Go[3] and competitive with Rust[4] while being much easier to adopt because of the language similarity to JS and TS.
- It is an object-functional hybrid language owing to its influence from F#[5]; discriminated unions are on the roadmap and available today with packages like Dunet and OneOf, it has pattern matching like Rust, extension methods provide flexibility in modelling, named tuples in C# 12 converge even more with TS, it supports destructuring record types and classes, it has immutable record types
- Minimal APIs are very familiar for teams using Express but need more performance. I'd actually say that it's a bit simpler than Express on Node for common use cases since there's nothing to import when setting up minimal APIs since it's all first-party Microsoft.
- Platform support for source generators are a revelation; it removes a lot of boilerplate code while actually improving performance over reflection.
- Many of the things teams love about modern JS actually have influence from C#. Lambda expressions in JavaScript, `async/await`, and more. In fact, C# and JS/TS have been converging (see the linked repo).
- It's relatively easy to write high throughput code in C# with support for both concurrency (Tasks + Channels) and high level abstractions for parallelism (Task Parallel Library) as well as full access to threading.
- C# allows easy access to underlying low-level primitives; you can program with high level abstractions for productivity but still have access to call `unsafe` code if needed.
- EF Core is possibly the best ORM on the market right now in terms of performance, ease of use, maturity, and database engine support.
- A benefit of a language and runtime backed by Microsoft and used in the enterprise is that security issues get addressed by a team of professional engineers; you don't see the same types of security issues that pop up in the Node/NPM ecosystem.
- This is a big boon particularly because of the broad standard libraries and first-party libraries for many use cases. Rather than importing unknown dependencies for common use cases, you end up with a baseline of professionally maintained, OSS code.
- GitHub's State of the Octoverse report in 2020[6] showed that C# had the least Dependabot alerts and has the least transitive dependencies (less prone to security issues via package managers).
- As a general purpose language, it can be used in many domains from desktop to devices to web to gaming (both Godot and Unity; RyujinX).
- It's also quite mature and stable while languages like Rust are still ironing out async and Go just released generics. C# has been there; done that.
Besides, if a team is already using VS Code, GitHub, and TypeScript, they're already in the Microsoft controlled ecosystem.
[0] https://spectrum.ieee.org/the-top-programming-languages-2023
[1] https://github.com/CharlieDigital/playwright-scrape-api
[2] https://github.com/CharlieDigital/js-ts-csharp
[3] https://medium.com/servicetitan-engineering/go-vs-c-part-3-compiler-runtime-type-system-modules-and-everything-else-faa423dddb34
[4] https://www.techempower.com/benchmarks/#section=data-r21&test=composite&hw=cl
[5] https://itnext.io/getting-functional-with-c-6c74bf279616
[6] https://arxiv.org/ftp/arxiv/papers/2110/2110.10246.pdfAnyway, I favor productivity way over ergonomics. And my .NET apps are very robust and very easily deployed. Everything is perfectly well integrated. No surprises. Almost no sharp corners left. The DX is superb. The performance is great. It’s so easy to run. Time to delivery is good. And the most important bit - I don’t need to keep all the hidden Java traps in mind. JVM with its many implementations is an amazing piece of tech, but in my experience it appears as something overengineered and requires too much maintenance and fine tuning. Just like Spring, Hibernate, and many other components of a typical Java app.
It's basically Java without most of the bad parts. It's a very well designed language that fits most niches (fast, compiled, familiar syntax, feature rich, adopts recent PL concepts, etc.)
And every new praised feature comes with many caveats because the OpenJDK folks want to keep it backwards compatible and carry on all that dangerous garbage resulting from the many bad design decision made in the past. Virtual threads come with many caveats. Pattern matching too. The Panama FFI has been underwhelming. The value types proposal is kinda weird. GraalVM is great on paper but have you met someone satisfied with it in production? It’s nice you can, in principle, embed an R, JS, Python, Ruby and Java runtime on it in the same app, but does it actually work in production? It’s all praised to the infinity but it just doesn’t work right in production. And what’s dangerous - the caveats are not advertised at all, you really need to be very cautious and follow all the relevant Oracle talks and discussions here and on Reddit just to not endanger your software. Do you really believe that an average Java developer can cope with all that sheer complexity?
For example, pron might tell you virtual threads are fine but do you have the budget to even invite him on your team? Yes, obviously, you don’t have to be one of the developers of the Virtual Threads to use them appropriately, and they gave their best to make the APIs as user friendly as they could, which few really appreciate. My point is that it’s only the tip of the iceberg that many people talk about when they discuss languages. This may come as an unpopular opinion but that’s just my experience.
So, no, C# is not “basically Java”—it began as such and perhaps a decade ago that would be a good assessment. But today, C# is a robust language in its own right. You can also choose F# or VB if you like, they all run on the same CLR, like the JVM languages. And .NET is a full-fledged robust and comprehensive framework. There’s much less variability in the correctness and cohesion of the implementations across the .NET ecosystem—already because there’s much fewer moving parts and knobs to control. And .NET apps use much less memory for the same throughput and latency than JVM apps. In addition, as for DX, EF Core is much more efficient and straightforward than Hibernate and Spring Data JPA, and so on.
It just works.
https://i.kym-cdn.com/photos/images/newsfeed/001/079/173/ed2...
If you're not, then I'm not sure what the appeal would be.
I work for a company in the former space. We have no intention of supporting nonWindows clients or nonWindows servers or even nonSQLServer DBs. It's not worth doing from a commercial perspective in our particular market. Consequently, it's C# and .NET.
Tradeoffs:
- You'll have to use Rider if you want a full IDE
- Or get used to VS Code and know its gaps
- Some workloads aren't as well supported in VSC (e.g. MAUI, desktop apps); as long as you don't need these, VSC is fine
- I know at least the CosmosDB emulator straight up does not work in ARM, even with the x64 emulation on the Docker image. Has been that way since M1 released.
- Occasionally, you'll run into issues where there are dependencies on x64 binaries like with Google OR-Tools which has a .NET wrapper around a C++ library.
- Have to get used to configuring cross-platform builds for .NET and Docker (not hard) since you'll often still be running in x64 environments in upstream cloud deploy targets.
- Terrible multi-monitor support; you'll need a $250+ DisplayLink capable dock for more than 2 screens.
- And the text doesn't render quite as crisp as Windows; might be that it would if I were using Apple monitors, but the same monitors are notably more crisp with Windows 11.
- PHENOMENAL battery life; for this alone, it was worth the switch. It's insane how good the battery life is for the performance. I've previously used top-of-the-line Dell Precision mobile workstations and the performance for the battery life on ARM64 is just unmatched. I can run Postgres (in Docker), a handful of Docker images, VS Code, and code on a cross-country flight
- The form factor is phenomenal. The same size as a Microsoft Surface 13.5" laptop but has 3 USB-C ports and an HDMI port. Of course, the phenomenal performance and battery life listed above
- The laptop is absolutely silent; never hear the fan kick on. I can be compiling away, running a Node-powered front-end dev runtime, a .NET web API, Docker containers -- never hear a damn thing. Coding in complete silence is kind of crazy.
- Stays relatively cool and never reaches the same temps as a Windows Intel laptop
- It takes a while to remap your brain for KB shortcuts; get Karabiner to save your sanity
- Download iTerm; it's like Windows Terminal
- If you switch to VSC, you need to commit to it and get used to the CLIC# has best tooling on the market, by far.
Btw. C# has huge oss community
Huge cultural difference.
But for some reasons ppl that argue for fragmentation under umbrella of innovation never talk about sane experience, especially for newbies
And for writing C# on the server, the major benefit is that Microsoft has a batteries included web framework that’s very battle tested. There’s at least one good first party answer for every problem (auth, database connections, caching, etc) which is very nice as compared to finding 30 npm packages to try to put stuff together. And C# is a pretty nice type-safe language that’s as fast if not faster than Java.
As for the front-end scene? Yuck. That’s a big ol mess in .NET right now.
(And, oh man, that batteries included battle tested framework is a stinky pile of trash. The language itself is ok, but the framework uses every misguided trend somebody at MS thought as cool, has no documentation of them, and implements half of them in some way that only that person thought about. There is a passable "web framework" inside it, but you have to ignore the MS recommendations and know what tons of pieces to discard, also, it's not very batteries included, because the batteries are almost all poisonous.)
I've never used C# or dotnet core but I know from word of mouth that it is a relatively well put together framework of tools for doing a lot of the things organizations with a lot of backend services to write might need. Many of those orgs are already very locked in with Microsoft, so the greater support by the open source community that comes with typescript is mostly irrelevant. Whatever the officially supported version of something is is what you will be required to use, and the typescript ecosystem provides very little if you want some big company to declare one particular thing to be the blessed solution.
Java is “controlled” by Oracle. Kotlin by JetBrains. Scala is “controlled” by… no one knows. Go is “controlled” by Google. C++ is “controlled” through representatives of a consortium of blue chip corps, including MSFT and GOOG. They also “control” Linux to a significant extent. Their employees contribute to many OSS projects.
There’s no perfect governance structure. .NET has the .NET Foundation, like Haskell (also “controlled” by Microsoft until recently) and Python; but who “controls” Python? Did you ever bother to wonder or was it ever important at all?
And the language alone is insignificant, you need a community and an ecosystem that you and your project fit best in and you can rely upon for the lifetime of you project.
As for the frontend, you have to have so JavaScript somewhere, it’s unavoidable, so typescript is just a way to make the inevitable more palatable.
And there are other frontend options that go without any JS on your side, so it’s quite avoidable. In most cases it’s impractical to avoid JS for the browser target. But the browser is not the only UI target for many apps.
You can go with dynamic languages if you're flying fast and loose, or native languages like Go/Rust if you are worried about performance but you miss out on the "enterprise" integrations of something like Java or .Net.
Speaking of Java, it's great too but the ecosystem is a jungle. It's more flexible, but that flexibility has a cost too and you'll spend a lot of time frustrated trying to figure out the right combination of configs in xml, toml, yaml, json, env, properties, etc files.
They don't always get this right but if you are careful you can get a codebase to survive 10-15 years under Microsoft without too much suffering. If you latch on to every shiny new thing they release (cough MAUI cough), then you will find yourself despising Microsoft.
Stick to the basics and a vendor like Microsoft can take you to the moon with zero drama.
That makes it easier to get started than say Python where you have to depend on multiple third party libraries with different support cycles, API styles, or even async programming models (e.g. gevent vs async/await in Python). And you can still swap components out if needed.
Not saying Rust or Python etc. are bad for writing startup software. Given the ecosystems I personally find it faster to get started with .NET because of the reasons above.
For embedded Linux, .NET runtime delivers memory safety for high-level pieces, great support for networking and multithreading, combined with simple unmanaged interop for low-level pieces. The lower-level parts of the software I made were in C++ to consume OS APIs not exposed to C# like drm/kms/egl, also to implement a few performance-critical functions in C++ with NEON SIMD.
For a web service running on Linux: the same binary runs on my development amd64 Windows and the target aarch64 Linux which makes it easy to develop and test stuff. Asp.net framework is first party, stable, and mature. The runtime is relatively small and is trivial to deploy. That project didn’t use C++ at all; the complete server is implemented in memory-safe managed code, good for security.
Since then, I learned a great deal about how inertia within developer communities works. Every single year I'd speak with a skeptic and they'd have a "reason" not to use .NET that wasn't true. Eventually they'd land on a reason that was true, and in most cases, we were already working on it. We'd even find some past skeptics say publicly how they started paying attention, picked up the tech, and loved it. Fast forward to 2020 and pretty much every possible reason that isn't purely idealogical evaporated because we (hundreds of us) did an immense amount of extremely hard work. But by and large, the perception is still there.
The reality is that .NET was a Windows technology for a long time, operating in a space ("the enterprise") that's a wholly separate universe from startups. And people bring what they know into companies; they don't usually try to learn new languages or tech unless it's required for their job. And that's created a feedback cycle where .NET is outside the startup and high tech scene.
Yes, there's warts (don't get me started on how MSBuild isn't deterministic, although you likely wouldn't have known that...), but few people run into them. Yes, there's missing packages for some stuff but that gap closes every year. It's not about that. It's about a cultural feedback cycle that .NET is simply not a part of. The bet was that we could build great tech that works in most environments, sprinkle some marketing on it, and people will pick it up. That's largely not happened. Most of modern .NET is still in the same space that Windows .NET was, it's just that it's kept pace with (and sometimes led) the modernization of general tech in that space. That's largely fine because there's millions of developers there.
Having to argue with people about how well dotnet runs on Linux after having it deployed on Linux for 6-7 years sucks as hell
I’ve found Microsoft’s developer-targeted marketing campaigns rather annoying. But it’s been professional and even fascinating from the point of view of marketing proper. What I disliked was the few occasions of overreach against the community.
I think .NET has been gaining traction, albeit not uniformly across the world and not at a fast pace, which is reasonable due to the already huge community—you just don’t get to grow that fast in relative terms when you’re already this huge.
Cryptic errors for basic mistakes and the default option for it, at the time, visual studio's thousand menu's and buttons.
"Oh you complete fool, you're using .net version 4.7 which is completely incompatable, go through 5 menus to download it. Hope you have the right version of Microsoft Silverlight!" I had to download like 10 versions of .net by the time I was done.
A comparatively large amount of work for a hello world compared to almost any other choice for PHP or Python. And those had tutorials and text based environments were approachable.
I definitely had issues with Apache's config hidden god knows where but learning how to search for config files was a skill I found far more useful than rooting around layers of menus while someone told me this was normal and, actually, good.
If I had to choose a tech start for a start up MS still wouldn't be my first or second choice. I'm sure it works, but god that first year informed me it wasn't the community I wanted to be in.
<rant> Unfortunately, I agree that Microsoft was too late in realization that it is important to make it easier for developers and that they need to cater to the devs, instead of getting in their ways and making it harder for devs. The visual studio pro is still expensive (it should be FREE! community ed doesn't count) and still not as good as Jetbrain's Rider, which runs circle on VS. In fact, if MS had any sense, they should've bought Jetbrain just for Rider and scrap their bloated/slow visual studio, which only runs on Windows. MS needs to improve their tooling and also make VS for Linux if they want c# to be taken seriously for cross-platform dev. And stop changing the platforms and remove their absolute convoluted naming scheme. Why do we have .NET core which is now .NET 6, .NET framework is now supported and deprecated at the same time, desktop apps were written in WPF, and then UWP? and MAUI, and now is it called WinUI3? I have no idea because I can't keep track of changes anymore. One day it's called .net, who knows in few years it's going to be .azure, or whatever. </rant>
Why would you need pro? Also did you use VS with free extensions like Roslynator which significantly increase its refactor capabilities?
Similar problem with Swift even though it started out as an open source project. The ties to Apple OSes are hard to break and ignore.
And it is available on all platforms.
It used to use IIS express to run its applications locally (it has meh cross platform support) now it by default uses docker when bootstrapping a new application.
I've only ever developed for it on windows and very minimally on Linux, but I did not feel that the experience was worse on Linux.
I think it deserves some of the hate it gets for its previous state, but it is really a pleasure to work with these days.
My current job is a kotlin shop and I miss .net/c# a lot.
When I'm in the zone, my creativity is flowing, the last thing I need is to register on some website, or to purchase a license.
I was actually devops for a .net project at my $dayjob, and I noticed the nuget repositories we setup in Gitlab for the developers. So I could tell that a lot of my preconceptions about .net are probably wrong.
But I'd still prefer any other language like Python, Rust, Golang, Nodejs just because I'm afraid of running into some enterprise wall in their historic walled garden.
It's so damn frustrating to run into tooling issues, and when they stem from ruthless capitalism it seems even more frustrating than simple package management issues with npm for example. At least I can always check the source code. ;)
https://source.dot.net or github
>than simple package management issues with npm
Unlike js, Microsoft has shitton of stuff in std, so no need for 3rd :)
$ apt search dotnet
Sorting... Done
Full Text Search... Done
libgtk-dotnet3.0-cil/testing,unstable 2.99.3-4.1 amd64 GTK.NET library
libgtk-dotnet3.0-cil-dev/testing,unstable 2.99.3-4.1 amd64 GTK.NET library - development files
libgtk2.0-cil/testing,unstable 2.12.40-3.1 amd64 CLI binding for the GTK+ toolkit 2.12
libgtk2.0-cil-dev/testing,unstable 2.12.40-3.1 amd64 CLI binding for the GTK+ toolkit 2.12
Repo
wget https://packages.microsoft.com/config/debian/12/packages-mic... -O packages-microsoft-prod.deb sudo dpkg -i packages-microsoft-prod.deb rm packages-microsoft-prod.deb
C# tooling is open and freely available. The source for the compiler and tools are all on github and the tools are all available free to download and use.
If you, for e.g., want to debug you have to use MS tooling.[0] You also can't use VSCodium because only the MS built/distributed version of VSCode contains the proprietary binary blobs necessary to debug C# (which also means you're forced into the aggressive telemetry and other data collection built into the non-open source distribution of VSCode).
They've also taken steps to lock down the LSP support for C#, which once again requires that you use a MS sanctioned editor to write C#. [1]
I really enjoy writing C# and think dotnet is a great platform to develop for, but the barriers preventing me from building more projects on it is that I don't want to be forced to use VSCode or Visual Studio. I also don't want to get too invested into a particular piece of tooling that is going to be rug pulled down the road by some MS product manager who isn't aligned with the "MS <3 OSS" side of the company.
The two things that "bit" me all these years is that, all "free" stuff given by Microsoft was just "hooks" to claw you into their expensive and closed ecosystem .
As someone said, there may be some misconceptions from legacy behaviour that is no longer true, but I fear that the only "first class" citizen CLR and tooling for .NET lives in windows. Suddenly you need IIS and sqlserver windows and all the expensive stack.
OTOH I think as a language C# is pretty neat and CLR is great tech as well, but I wouldnt dare to use it on production in a Linux system
How do you even imagine it could work?
But it comes from the corporate world, was a Windows only product for years and (worse) was made by Microsoft, so hackers ignored it.
I only figured out how good it was because I started a job doing, yes, corporate/government it.
But using C# .Net? It's completely irrelevant, it adds absolutely nothing. The performance is similar to Java. The syntax is similar to Java. But the eco-system is one of the smallest of all the big programming languages. And most of the documentation/blog posts about C# is heavily Windows focused, and we run only on Linux. The only reason I think of why I should use C# is when we need a Windows-based desktop application. But I think Java+JavaFX will be just as good and will also work great on MacOS and Linux desktop.
People tend to underappreciate how much time it costs to do the context switch in your head when you change across different stacks, and how much lost opportunity it incurs for not spending that time to dice deeper in only one tech stack.
It is not really crazy complicated, it's simple stuff that is very well documented. We try choose the right tool for the job, and we don't care about which language we use. If we tried to do everything in Java, we would spent at least 2x more time on building our software.
You look for a solution and find an [AttributeDecorator] that no longer works or is considered bad practise, or is it the new silver bullet - who knows? You better return IHttpActionResult, or do you set the context.Response? Hmm.
It's much easier with younger Frameworks like Svelte, NestJS, Flutter or younger languages like TypeScript, GraphQL. You won't be told stuff that's been dead for 20 years.
I'm not entirely sure where it started, but if my own experience (from 2012) is any indication then it was very much related to people coming out of enterprise and government, that had to deal with ASP.NET and WebForms, but didn't want to deal with it, because they had experience with web frameworks that weren't the nightmare ASP.NET and WebForms were.
I worked with a few of those in 2012 and people were hopeful about .net core. But the major difference between .net core and typescript besides the historical mental baggage and the way Microsoft typically responds to patches to open source projects is that typescript was building on a massive JavaScript base. And because ECMAScript development was active these two were building on each other.
I think C# is a lot nicer than Java but unfortunately with the community mismanagement it's not really a serious contender unless you HAVE to be in that environment(i.e. Microsoft Stack in US healthcare/govt for example)
It started with C, then Java and then dot net later WORA iteration, albeit it's already more than 20 years old technology, how time flies.
To be fair C is extremely successful in term of popularity (case study Linux), followed by Java (case study Android) and then dot net (case study MAUI), and yet none successfully provides turnkey, seamless and hassle free solution for the WORA codes. This give rise to the joke of "Write Once, Debug Everywhere".
It's most likely that dot net is not going to be the last time people try to invent (or re-invent) WORA codes, so prepare yourself for the next big thing in WORA.
[1] Write once, run anywhere (WORA):
I honestly preferred VB.NET, but I'll settle for C#. It has great community support, great libraries too.
This is coming from someone who started out writing x86 assembler and has been coding on almost every platform known to man for the last 40 years.
I just don't understand the "Rider is not free" thing. Just come on now, guys. It's like $15 a month, a price of 1 good meal pretty much anywhere in the world. In my 3rd world country, even students could afford it. If you earn money with code, it should be no brainer.
If you are a someone who is just learning and hacking around, or just want everything to be free forever, then VS Code with C# DevKit is more than adequate, you can even do professional work with it.
I'm saying this assuming you are on Mac/Linux. On Windows, the powerful (and free) VS Community Edition will get you covered, unless your revenue exceeds 1M, in which case you probably can afford the VS Professional license.
I know you can probably get more performance out of Rust or Go but I don't think rq/s benchmarks really hold up in reality. If you are running a startup, you'd probably see 1 to 2 rq/s unless you become viral. .NET Core can easily handle that and more.
You may find this OSS .Net project I released recently interesting: https://github.com/stepwisehq/prosemirror-dotnet .
I've used it in every startup I've worked at.
and [dupe]
Earlier discussion over here: https://news.ycombinator.com/item?id=37476823