Why would you use C# if starting a company/project today? I know C# fans love it, but seriously why not choose a community driven language over one controlled by microsoft?
TypeScript is also controlled by MS and that has tons of community support. Sure, if things got evil someone would fork/reimplement, but right now Microsoft decides how the language goes for the most part.
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.
But there is a very compelling reason to use TypeScript. There isn't one for C#.
(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.)
This is kinda totally off. You could say that about Spring and Pivotal/Tanzu/VMware or even Quarkus and Red Hat, or just IBM. In my experience though those words apply best to much of the Python and Rust landscape. You could say much more about the Node landscape. But .NET and ASP? Really? Could you substantiate?
I find the opposite to be the case in all honesty.
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.
Perhaps because Java is a mess? Much easier to hire? Where? In some locations there’s a 2:1 to 4:1 of C# over Java ratio for demand. And your “why not just use” something else is kinda condescending. You do realize that’s not how one is supposed to choose their tech stack?
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.
How is the first paragraph significant or even relevant? What scenario are you contemplating to hedge against?
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.
I don’t care who controls what if the technology in question is technically good, and it comes with a good enough license. Here’s two examples.
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.
One could argue that fragmentation is a sign of more active development and a cause for excitement. Of course, it comes with less stability/maturity, but it means that everyone is empowered to do their own thing.
I wouldn't use it personally because I use other languages, but C# is perfectly fine?
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.)
Yeah every time I use C# a bit, I just have to laugh a little bit in comparison with java (which I've used a lot more); it reminds me of nothing so much as reading a first draft, and then reading a final version of the same thing after it's been worked over by a good editor.
To me it’s not about the language, I can anytime switch to Kotlin or Scala, even Clojure but I don’t do LISP. To me it’s mostly about the developer experience, build tools and the simplicity in the ops. In JVM there’s so many moving pieces and knobs to control, it’s so brittle. I can live with the trap field in Java the language that’s justified by backwards compatibility. But I prefer to let juniors steer away from Java to Kotlin so they avoid all those traps. I love Java and the JVM for the versatility and the variation. But Java steals too much productive time and eats up too much RAM.
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.
Your mileage may vary but my opinion: Because its controlled by Microsoft. ASP.NET Core brings everything necessary to develop a web application, from an ORM, to a web server, to a router, to an HTML templating language, to a client-side SPA framework. All components are designed to work together and have high quality documentation.
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.
I still despise Microsoft but I'm old although I'm old but I think most people on here too. They do make some good development products VSCode and Github in particular but I'd still rather avoid them as much as possible.
Why not? It's a great mix of productivity and power and the Microsoft/Azure ecosystem works really well together.
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.
We like the fact that it's pay to play and controlled by one big org. There is a strong financial incentive to keep current customers locked-in and happy. This aligns well with our business model which involves b2b software contracts that last 5+ years.
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.
If you're building Windows software, then you might find it easier to use the Windows-native stack.
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.
There are some tradeoffs, but some really key benefits which make it worth it.
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.
Benefits:
- 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
Some lessons learned:
- 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 CLI
Yeah, I’ve run the same dev setup since the M1 came out. Totally stable and robust. Nothing wild at all. Every .NET dev who’s on an ARM Mac today is most likely doing the same. If you like you can run Windows ARM in a VM on the same Mac if you want to run native WinUI, WPF, etc. GUI or anything Win32 specific.
For .Net, there's an established pattern of careless deprecation that produced enough frameworks to date codebases like tree rings:
- 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...
This pattern exists in all languages. I’d argue more so in fragmented community driven projects/languages/tools.
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.
There is a marked difference between a third party releasing some new library and obtaining (to some extent, demanding) community mindshare, without taking away anything, and the official platform maintainer suddenly replacing practically mandatory parts of what is perceived as the standard library. Javascript churn is fast, .Net churn is deep.
That's not really true. .NET Framework is still around. Even .NET core 3.x which is EOL a while ago, is still widely used with active stackoverflow and if you're loud enough with the .NET team at Microsoft they will help you there too.
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.
The "authoritative opinion" is indecisive. Microsoft frameworks tend to be high quality, but there are too many. ASP? ASP.Net? ASP.Net Core? ASP.Net MVC? Razor? Blazor?
Well, you’re covering about 23 years of development there between ASP and ASP.NET Core.
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.
yet they still support it all.
also, you dont want them to stick to some old tech. you want them to evolve and take the best from industry. imho, they are doing just that and they are very good at it.
But why can't you fork it and take it in the direction you want? The situation is literally no different from Python or Node or Ruby, the people running the most popular distribution could take it in a direction you don't like and the power you have (or the only option you have) is forking.
Infront of the public, yes, but it says you need to be invited by someone from their team to participate yourself, compare that with the python process.
There's a distinction to be made between doing something in public and something being done by the public.
I would just like to understand specific threats or issues with using C# as a language. I've used it for 20 years at this point without issue and the latest IEEE language survey shows that it remains one of the top languages[0]; I'm wondering if you have some insight into why .NET and C# are a bad choice for engineering teams that I've somehow overlooked in my 20 years of working with it.
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.
My personal opinion is that C# is the language that most teams want but don't know enough about it or have a bad taste from the .NET Framework days. While the runtime is more complex than Node, the language is very similar to TypeScript owing to its lineage from Anders Hejlsberg. C# and .NET in its current form is a great language and platform to build on.
Besides, if a team is already using VS Code, GitHub, and TypeScript, they're already in the Microsoft controlled ecosystem.
This is a good list. I really feel it's a very good platform and just a very pleasant environment to work with. I guess I'm a "fanboy" as someone else on this thread said, but I became one because I had to use it for a job and I found out how solid it was and how much I enjoyed tinkering with it.
I really appreciate what I can do with .NET and I don’t do much care for the language that I need to use. Yes C# is nicer compared to Java and C++, but after many years with Haskell they all are nowhere nearly as ergonomic and expressive, which is fine. I’ve tried F# a couple of times but couldn’t get used to the OCaml like syntax.
Anyway, 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.
When I joined the .NET team in 2015, we were rounding out the first arc of the journey to be truly cross-platform, and June of 2016 released a 1.0. It was an absolute mess of a release, but it actually happened. You can bet your ass that "go after startups" was a part of the strategy - in my first team meeting we literally all read a blog post about how Go was picked over C# at Parse. I'm sure our execution of that strategy could have gone better, but it could have been a lot worse too.
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.
Perhaps we’re looking at different time frames or different locations, but as for your last paragraph, I’ve observed a qualitative shift in .NET job postings over the past two years. Several years ago, lots of jobs used to be posted by the proverbial .NET sweatshops and outstaffing agencies. These days, quite the opposite—lots of greenfield projects, lots of enterprise projects not even running on Microsoft software infrastructure, that is, not based on Windows and not related to document processing on the Office suites, not even on Azure. Great salaries.
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.
Honestly, when I started dev the .net learning materials made me feel like an idiot. It seems like no one teaching it was willing to acknowledge how things were organized might have been stupid. Ergo, any confusion you had was a problem with you not the software.
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.
As a fullstack dev working with c#/.net backend and react frontend, I can say that c# is great, and I wished more projects would use it.
<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>
>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
Why would you need pro? Also did you use VS with free extensions like Roslynator which significantly increase its refactor capabilities?
Rider (from JetBrains) is basically the go to IDE for most .net/c# devs I've met professionally. VisualStudio has come a long way but Rider is just chefs kiss.
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.
As a lifetime Linux user, I think it's obvious. A startup is about getting a product out to market as soon as possible, and hopefully as cheaply as possible, which can best be done with open and freely available tools.
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.
> A startup is about getting a product out to market as soon as possible, and hopefully as cheaply as possible, which can best be done with open and freely available tools.
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.
The tooling is not entirely open or freely available.
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.
Those links both show the tooling is freely available, and for the core debugging interface, there are open source implementations as documented at those links as well. I'm not sure what the problem is.
I've been in the rodeo for 20 years now. I started as a Jr dev in a Microsoft based software company that had some kind of M$ certification which gave us all the MSDN CDs. I was the first C# .Net programmer when I joined as C# had just been introduced and I loved learning it at uni as an alternative to ugly Java.
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
Then I guess Microsoft have a long way to come in destroying old stigmas about their software and ecosystem.
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. ;)
>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. ;)
I recently launched a startup, we use Java, some Python and even a little bit of Rust. For web we also use plain Javascript. We will most likely add some GoLang and C/C++ for specific problems we need to solve in the future.
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.
I can't tell if this is serious that you're a startup using 3 languages with plans to use 2 more. I'm not saying that those might be the best tool for the job, but the complexity to manage that whole build chain sounds crazy overkill complicated for what amounts to premature optimization using all those languages
While I agree with you that such complexity is expensive to manage, I think it primarily depends on the expertise of your team. If you can foresee the need for Rust, say, and your team knows how to manage its risks, and it is financially viable to maintain so many stacks, I think it’s fine. But if the team just wants to put a badge on their chest for using Rust, that’s a different story. I’ve been always striving to reduce the complexity and pick only one framework. Sometimes it’s hard and such decisions must be made. On a larger project I integrated and developed Go, Rust, and Java services, tightly knit to their context bounds. It was alright and seemed to make sense but the strain was immense.
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.
I can explain why. Java is great for web, api's and most things. But Java is not really that great for doing data science. Python is great for data science, the Python community has put a great effort making Python "The place to be for Data Science" and Rust helps us speed up heavy tasks that are too slow with Python.
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.
i've tried to "escape" .net ecosystem few times already. reason always was curiosity about pther ecosystems / languages. Ruby, Python, JS, Rust.
i have returned every single time. from my point of view every other thing i've tried is underdeveloped toy compared to what .net ecosystem gives you. superb languages (c#, f#) toolset, compatibility guarantees.
i understand the rebelion point of view and a pay huge respect to those people pushing alternatives forward. thanks to them Microsoft was also able to adapt to latest fanciest standards.
Their idea of a long term release is 3 years, for one, which can cause maintainability headaches. Second, portability across Unix platforms is low - the current release doesn't even run on FreeBSD .
The naming truly sucks. You search for .NET and you find .NET framework, ASP.NET, .NET Core, .NET Framework, what even is .NET Xamarin MAUI?
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.
The naming situation has been the biggest barrier to adoption for me. I’d love a ‘definitive’ guide or set of docs for how to approach the ecosystem in 2023 if anyone has recommendations :)
More and more recently I have been seeing C#/.NET show up in job listings that aren't just 10,000+ employee enterprise companies. I think it has been becoming more popular.
And rightfully so, dotnet nowadays is really a pleasant environment to work with. Fast, good language(s), good libraries, good dev experience and cross platform. Most criticism I see on threads like this is either based on outdated perceptions or on Microsoft hate.
.NET Core was in some ways inspired by the ALT .NET movement(I think).
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)
Dot net is a series of efforts for the holy grails of write once, run anywhere (WORA) codes.
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.
I actually enjoy it. And this is coming from someone that spent a lot of time in C, assembler, lisp, Scala, Java, and so on....C# is much nicer than it used to be, and gets out of the way. Tooling is so much better than it was just 5 years ago. I'm using rider on an m2 with no issues. Of course it's not free- regular vs2022 won't even open on a mac. Most of the things I don't like about C# mostly have to do with the community and the average C# developer. Even the documentation, which used to just suck, is getting better.
>I'm using rider on an m2 with no issues. Of course it's not free
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.
You should use the best tool for the job, and if that's dotnet go for it. That said, it would be difficult to hire strong engineers, across all experience levels. Your team would probably skew older and have outdated engineering practices.
I don't think that's true. We have been using ASP .NET Core + SignalR for everything in Notesnook[0]. It has great performance, libraries for everything out there, very good ergonomics, and a mature ecosystem.
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.
My 2¢: if they really wanted to light up adoption, release a TypeScript compiler. I don't mean to JavaScript but TS to CLR. C# is already so close to TypeScript. And the TS ecosystem and mindshare is huge
oh lord. Not just a meme language as discussed, but the language and framework design decisions alone are bad enough. add onto that the business heads who think they should use C# for their startup also bring legacy enterprise ideas with them that won't work...
A big part of why java sucks is that you get failed software engineers to teach them at universities, and teenages took their crappy code and think that's representative of java or programming as a whole even.
the evil is trying to do web dev with whatever back-end language that's convenient to you even though javascript might be better. PHP, JSP, ASP they're all the same kind of mess, just some of them are more verbose than the others.
