Hacker News new | comments | show | ask | jobs | submit login
Open Source .NET three years later (mattwarren.org)
216 points by matthewwarren 7 months ago | hide | past | web | favorite | 185 comments



What's holding .Net back is a lack of the vision thing. That's a shame, since in many ways it is a better designed framework, with a superior flagship language (C#) compared to the Java platform. Their framework and language designers are truly world-class, probably the best in the world.

The problem with .Net's vision has been painfully obvious to anyone following .Net over the years - it is still Windows First. While in Enterprises and Startups [1], Linux is what matters on the Server.

As an example, just last week I was looking for some http2 libraries in C#. Go and Java have mature libraries already in production, while .Net only supports http2 services on Windows. That in turn affects other ecosystems as well, such as gRPC Services. This to me is a red flag. Given how important something like http2 was going to be, how come Microsoft is so late to the party? What exactly is .Net's niche, given front-end wars are over?

Another example, the very promising CoreRT project (https://github.com/dotnet/corert) page says this about Linux: "Same as Windows, the libraries are less complete."

As a late comer, .Net faced an uphill climb. High-end web tooling is almost exclusively JVM based (Kafka, Cassandra, Elastic Search, Kibana etc). The upcoming competitor is Go, not .Net. If Microsoft doesn't pour a billion dollars into getting .Net ready for Linux in 2018, .Net is over.

[1] I've been a consultant to several Small and Medium sized businesses (especially in Medical) which predominantly use Windows and .Net, and that's still a huge market. But even they are looking to move off Windows.


It's definitely not dead.

.NET runs everything from desktop apps to web infrastructure to mobile games - it's a lot more encompassing than building some websites. It also integrates into a vast ecosystem with Office, SQL Server, Active Directory and is backed up by the fast-growing Azure Cloud. Most small, medium and 100% of the Fortune 500 run on .NET code and services.

HTTP/2 is just not part of Kestrel yet, which is the default new .NET Core web server. You can always use other libraries and this doesn't affect GRPC at all (which can easily generate the server from .proto stubs).

And how are the front-end wars over? Asp.net has great integration with all these modern JS frameworks, along with MVC and WebForms which are both still viable and used often. Why does there need to be a "niche" when .NET already does far more?

It seems like you found 1 missing feature and are proclaiming it a failure when the reality is that it's one of the most common frameworks today, and now also runs great on Linux. It'll be around for decades.


> everything from desktop apps to web infrastructure to mobile games

AKA mobile and Windows.

.Net is cross platform on mobile. Outside of it, if your project ever need to run in anything that isn't Windows, or communicate with anything that isn't Microsoft, then you can't use .Net. That makes it fit for enterprise CRUDs and not much else.


I'm not really sure what you mean by "Communicate with anything that isn't Microsoft, then you can't use .Net" I've used .net to communicate to vast array of non-microsoft products, serial over usb, shared pipes, com-interop, services, message buses, webapi etc..

I mean it is honestly by far the best framework I've uses to communicate to everything from 40 year old hardware to modern web services and APIs.

As far as "run on anything that isn't windows" I'll grant you, that's a very emerging area, but you can run .net (or some flavor it) on a lot of different platforms.

Hell I've got a raspberryPi running windows 10 IOT with .net running on it, and it works like a top.

And statements like "If Microsoft doesn't pour a billion dollars into getting .Net ready for Linux in 2018, .Net is over." say's to me, you don't really have your finger on the pulse on the enterprise ecosystem at all.

You'll be hard pressed to find a language that has breadth and depth that .net has. Couple that with the new push to Open source, from an enterprise standpoint, it's a very attractive platform.


Compared to Python, serial in C# is quite a bit more annoying to handle. Esp. at those speeds, easier to write it all in Python and call it a day.

Windows 10 IOT is basically Raspberry Pi and Allwinner A64 only at this point, which excludes most of the ARM SBCs out there.

The problem with both these platforms is they are horribly I/O limited, to the tune of 1 full USB port worth of bandwidth. Other SBCs commonly push 4x that or more!


I dont think you know what .NET is - it's an entire software platform comprising of several languages (C#,F#,VB) along with a compiler toolchain (Roslyn,RyuJIT), managed runtime (CLR), high quality standard libraries (.NET standard/BCL), and productive application frameworks (ASP.NET), that compile into programs that can now run on Windows, Mac, Linux, mobile phones and even Raspberry Pi's.

These programs can do anything, just like any other code in any other language, and the protocols (like HTTP or UDP) to talk between processes or programs have nothing to do with the code itself, which gets compiled down to the same machine level instructions anyway regardless of what language you use.


> Outside of it, if your project ever need to run in anything that isn't Windows, or communicate with anything that isn't Microsoft, then you can't use .Net.

So what communication protocol are you using that .NET can't talk to? In Enterprise it's almost always SOAP or REST and .NET has some of if not the best technologies for producing or consuming both.


> then you can't use .Net

That's just plain wrong. Not only might .NET be a good option for a backend system (which can, of course, communicate with any platform), but people have been using .NET on non-windows systems via Mono for many years


That is a bit strong. I’m running an ASP.NET Cote app on Linux (well, SmartOS Linux emulation) with a PostgreSQL database and it works just fine.


.NET core runs on Linux, OSx and Windows. I would say that is about as cross platform as it gets.


I would find it hard to believe any new Projects would still use webforms. The fake statfull web MS tried to create with WebForms is just too bloated. With MVC they have something great, something you’d have to use generic handlers for in the past to get any sort of performance.


I'm a consultant and work across a number of accounts. Not sure what "fake statfull web" (assuming you meant state-full) means to you, but in one huge healthcare org and two medium-sized fin. services co's 4 new WebForms projects have started in the last 6 months. Smallest project is worth $1.2mm.


WebForms was meant to loosely mimic WinForms and provide an easy transition for VB developers from desktop to Web, and it was mostly successful. The fake statefullness OP's referring to is FormState and the attempts to make WebForms more like WinForms.

With the emergence of AJAX though most competent WebForms developers dumped it because of then overheads and used the framework more like Classic ASP while integrating AJAX.


To be fair, FormState problems could get pretty bad. By default, large apps would be posting back several hundred KB on each click (sometimes even in the low MB range). With AJAX, it was better, but still not in the acceptable range for non-intranet apps. There were always mechanisms by which competent developers could work around these problems, but for the most part, those would mean that you're fighting with the framework and not working in a particularly idiomatic, WebForms-y way.

In retrospect, I'm not surprised MVC gained popularity so quickly.


WebForms was a beast and a horrible web technology for the web. I was just stating that, since MS intent on killing VB, it was intended to make transition from Enterprise VB Desktop apps to Enterprise Web Apps easier and in that regard it was successful.

The issues with FormState made it mostly unusable over the internet, it was relegated to intranet applications for the most part.


>state-full

You meant stateful, right? I mean if we're being pedantic it's good to actually be correct.

Something that has success is successful, and when you're having trouble sleeping you might say you're feeling wakeful. Why then would it be state-full?


I think it's different in Europe (where you appear to be located), but at least in the States Webforms are huge amongst the Fortune 500 and healthcare industries.


It's pretty awful in about any regard in my experience. What would be the reason to use it over MVC?


Isn't using WebForms faster for implementing intranet apps? Drag and drop stuff, done.


It can be for simple stuff. It can also be a huge pain in the ass and it took a while before it was truly JavaScript and AJAX friendly.


WebForms are still actively developed and supported by Microsoft. The latest version is very good and the WebForms paradigm is incredibly productive for general business-line apps. You can build entire apps within hours or days that would take months otherwise with separate frameworks.

If you have a massive complex webapp then you should use MVC, or look at a separate frontend JS talking to a backend API, but WebForms serves its niche very well.


WebForms is only good for the simplest of LOB apps. Yes it is still supported, but many organizations are discouraging its use in new applications due to difficulties in scaling and long-term maintenance. In my company, all new projects are required to use MVC.

WebForms' selling point is that it is easy to bootstrap, but its limitations quickly become a liability in an enterprise setting, where small apps rarely stay small. Once you decide you need to extend your app and/or integrate with newer non-MS web technologies, you are backed into a corner.

WebForms is something that really ought to have been deprecated, but people are still clinging onto it because it's so easy to use and there are too many legacy apps that still depend on it.

I suspect it's the kind of Stockholm Syndrome that have kept Mongo users faithful over the years. At the back of your head you know you're going to have to pay down the technical debt later, but you can't resist because it's so easy to get started and to see results.

(though to be fair, Mongo 3.4 onwards has overcome some of the serious flaws of earlier versions)


I work in the finance sector, and I don't see any new projects being built around JVM (or kafka, or cassandra, but elastic search is still popular). That said, the existing java product deployments are solid and there is no terrifying rush port them. New web tooling is a split between go and python. Also it doesn't hurt that gigantic amounts of business logic are PLSQL, with more going that way every day.

We haven't seen .NET for a new project in 5+ years. Doesn't mean it's not a viable tool, but the deployment story is a cost nightmare to us, and our teams distrust the upstream vendor.


Tons of stuff is still built on the JVM. The big five tech companies (besides MS) use Java nearly exclusively for back end development. Python is good for ML and data crunching, but compared to Java it's dog slow.

Go is definitely catching on but nowhere near passing Java, maybe it will someday


The big 5 tech companies are Apple, Microsoft, Google, Facebook, and Amazon.

Neither Apple nor Microsoft use Java.

Facebook uses PHP, Google uses a lot of languages but mostly C++ for Search. Amazon does seem to use a lot of Java.


> Neither Apple nor Microsoft use Java.

From what I understand Apple uses java/scala fairly extensively for backend services.


And they also run portions of iCloud on Azure using .NET.


They run portions on Azure. That doesn't mean they are using .Net. Azure supports more than .Net.


I've been hearing that .NET is dead/dying for probably 8 years now. I work on an enterprise software platform comprised of mostly .NET microservices and some NodeJs sprinkled here and there on the back end. 80% of our .NET code is running in a container on a Linux distro. The other 20% just hasn't been ported to .NET Core or has some shitty dependency which can only run on a Windows environment. I see some of our devs switching to Macs for development already. All of this has occurred in just 2 years. I would say give it some time. The progress has been amazing in my opinion.


> That's a shame, since in many ways it is a better designed framework, with a superior flagship language (C#) compared to the Java platform. Their framework and language designers are truly world-class, probably the best in the world.

While I'm happy about the progress and I hope that .NET Core succeeds, I've heard this claim repeatedly and I must say that it doesn't stand up to scrutiny.

The biggest problem of .NET's community and Microsoft's is that it fixated on Java the language, missing out on the improvements that happened in Java the runtime, not to mention the ecosystem.

Just to give a small example, the "tiered compilation" coming in .NET Core has been in Java since version 1.4, so we're talking about 2002. That was the Java version coming with the Hotspot VM, inspired by Self and Strongtalk. And it has only gotten better since then.

Java the language is terrible, we can all agree, however you can swap it with Scala, Kotlin, Clojure, Haskell (Eta), Groovy, JRuby and others, all of which benefit from running on the JVM, with the JVM itself turning out to be a much better host for other languages. Which is a little ironic given .NET's initial marketing.

Also another problem is that the community is waiting to be spoon-fed by Microsoft. In Java's ecosystem on the other hand the endorsement of Oracle is almost irrelevant. Outside the OpenJDK JVM itself most interesting projects are not built by Oracle. And even in the JVM area you've got interesting alternatives like Azul's Zing, featuring an awesome "pauseless GC".

Hopefully with the opening of .NET we'll see some actual competition to the JVM, but to those of us that have been in JVM's ecosystem for some time it's actually pretty clear why .NET lost thus far.


It's not like when you switch to Scala you get all the advantages of java without having to deal with a crappy language. You're also giving up a large amount of tooling.


A lot of the tooling is reusable. Profilers, debuggers, build tools, libraries all work.

And IntelliJ IDEA has been doing a good job with its support for multiple languages, having great support for Scala, Kotlin, Groovy and JRuby at least. There's also great support available for Clojure built by a third party.

Yes, I think you get most of the advantages of Java. There's a learning curve involved for Java developers of course, but it's very incremental because the underlying platform is the same and this matters.


> you can swap it with Scala, Kotlin, Clojure, Haskell (Eta), Groovy, JRuby and others

Only Scala and Kotlin are feasible alternatives to Java for building applications on the JVM or Android. The others in that list are limited by dynamic typing to scripting only or didn't see much adoption for building large systems, e.g. Apache Groovy for glue code and build scripts.


"High-end web tooling is almost exclusively JVM based (Kafka, Cassandra, Elastic Search, Kibana etc). "

This is what's making me want to move away from .NET. Most really interesting development is done in Java and Linux. With .NET and Windows you are often a step behind.


I have to agree. When evaluating what to learn next, all the interesting distributed systems I’d like to work in are all writen in Java, C++, and now a sprinkling of GoLang.

All the C# I run across is line of business stuff. So it may very well be great for that, but it’s less interesting from a development perspective.


I feel this is anecdotal, with the truth being that there are now more and more alternatives to the JVM for enterprise systems. Which could be one reason why the JVM has been loosing market share over the past few years. Not to say that Java, Scala or Clojure are not great languages. But I think its going to be trend that continues.


I agree with the stuff that's going around Go and others. But .NET is certainly not where the cool stuff is happening.


Don't forget the Unity3D, most of the people who use Unity uses C# to make a game. Recently, Godot Engine also added C# support. So .Net is not just about web development.


To be fair Unity is using a very old version of Mono.


They will be upgrading this year, I think.


I think .NET's vision is get people using Azure. You could say the same about VS Code. MS want to gain developer mind-share and get them using their cloud.


How does VS Code play into their cloud strategy?


They provide you with the convenience to push to Azure with a push of a button. These extensions are automatically recommended when you modify various file types.


You know, I've heard this claim before (that the strategy behind VS Code is to make deploying code to Azure easy), but it never made much sense to me. Deploying a service to production straight from an IDE/editor sounds like a recipe for disaster. I say this as a daily user of Visual Studio, VS Code, and Azure.


I don't think it's about production deployments.

Making it easy to setup a demo project means things may stay on Asure because that's the fastest path to production. Thus it's about business migrating from Demo (Asure) > Production (Asure) vs Production AWS > Azure.


Basically this, but they also push things like Application Insights, which is heavily tied to Azure.

The VS Code editor is also embedded in the Azure web portal. So by getting people using Code they may find it easier to up-sell to Azure. In fact, Code started life as the Monaco editor in Azure and was spun out into a separate product.


Oh my god someone mentioned App Insights organically! My day has been made.

Dev here, our strategy for AI is Azure-first, but not Azure only. While we provide first class monitoring for ASP.net services running on Azure, we also have lots of open source SDKs available for major languages, as well as first class Java and node.js SDKs and are trying to bring some of our other open source SDKs to the same level.

We totally get that ASP.net isn’t the end all be all and that people run other types of services, so we’re trying to bring App Insights to as many of these services as possible.


Java may be the JVM's "flagship language", but why would I replace the whole platform with C# when Scala and Clojure exist, and stay compatible with the JVM?


Kotlin as well as a less radical departure from Java.


Some people would take CLR over JVM, so YMMV


Ok but why? There are a few low-level performance-oriented programs that benefit from struct types (which the JVM now has too) or reified generics. For ordinary day-to-day programming, though, F# is underwhelming by comparison with Scala, and C# is better than Java but not by enough to be worth migrating platforms for. What's the USP of the CLR? When it first came out I thought it was more friendly to foreign languages, but that doesn't seem to have been borne out in practice e.g. Jython felt like it saw way more use than IronPython.


I think one reason jvm has so many more languages is because the need for java substitutes is higher. C# is a pretty good language. And it's hard for better languages to make up for the lack of tooling.


I'm not convinced; C# has some usability improvements over Java (particularly earlier versions) and VS is maybe a bit better than the Java options, but it's not a huge margin. And, I mean, IronPython existed and had an audience. But I suspect Python is a much bigger leap for Windows developers than it is for *nix developers. More than that, third-party languages were never really a big thing on .net - F# and Scala fill very similar niches, but one got the sense that F# was only ever developed by Microsoft Research, whereas Odersky worked on Generics Java and then Scala as a professor not directly affiliated with Sun/Oracle.


I think that today c# and java aren't that far apart. But Scala was created in 2004, c# got lambdas in 2007,and java got them in 2014. So there were a lot of years when the c# java gap was pretty large, which gave Scala lots of time to grow to a critical mass.

I think you're right another factor is that there are more Python and Ruby devs looking to write Python and Ruby on the JVM then the clr.


The most compelling reason I have for choosing CLR and C# over virtually anything else (and ESPECIALLY Clojure and Scala) is availability (and consequently cost) of skilled resources. Availability both today, and 5 or 10 years from today, depending on the project or program.

In my world (Fortune 500) boutique tech carries inherent risk.


This sounds as if skilled Java developers are harder to find that C# developers. Is this indeed so?


For me, Oracle is not as good of a stewart of Java as Microsoft is of .Net.

I wouldn't waste my time converting from a Java infrastructure to a .Net infrastructure and if I were a Linux shop, I probably would stick with Java for awhile, but if I'm already using Windows servers or have my choice today of using Windows only for the backend, I would definitely chose it because of the number of devs and network people available.


I know why you said Java. But I pretty expressly didn't, because BigCorp won't know or care why you said Java. Technical smugness doesn't change the fact that Scala and Clojure are exotic, and that exotic carries risk.


> F# is underwhelming by comparison with Scala

Please elaborate. This is the first I have heard from someone experienced in both F# and Scala to assert this.


I like F# but the lack of higher kinds means F# is mostly just C# with a teaser grammar. It doesn’t really allow for a fundamentally different library envronment.


Disagree as someone who has programmed in both Scala and F#; I found F# pretty much could do the same things just in different ways. In F# I found more ways to squeeze performance than in Scala which by comparison is bloated. For the data applications ive written F# wins usually especially with ad-hoc tactical apps and in my experience was easier to teach than Scala which is not as coherent of a language.


> could do the same just in different ways

Write a function that works with any monad? No?

Write a function that works with any numeric type? No?

You can fake type-classes, but it’s in no way a first class citizen. You can’t easily fake higher kinds.

You may not need those features, it doesn’t make my original statement any less true.


I agree with the first missing feature as you state; I just don't know how much value-add those features actually add in real world apps - often people use them in weird and unintitutive ways as well. F# has other features that other languages don't have as well. I find the workflow syntax eliminates some of the need for the first; and I find I can write functions that work with most numeric types at least a lot more so than C#/Java/etc. As a simple example the in-built F# library comes with functions that work on most number types (e.g SumBy works with anything that supports (+) including my own types). Sure there might be advanced examples that I wish I could do but they don't come often. I do find F# more concise, generally less "smart" and more explicit than Scala code which I think is a good thing. I've seen some funky Scala code in the past. Ease of code/learning/etc, and a maintainable codebase at least for me trumps features most of the time.


> If Microsoft doesn't pour a billion dollars into getting .Net ready for Linux in 2018, .Net is over.

I feel very confident stating the opposite. If Microsoft halts all investment in .Net today, .Net will still be around another 30 years at least with maintenance work alone.


Yeah, but its direct competitor is also fine in this regard. If all Oracle employees are nuked tomorrow, Java will still outlive Cobol.


They are busy porting millions of lines of code to work on Linux. Cut them a little slack on HTTP2. It's coming I'm sure.


.NET core is lacking so many features it's ridiculous, we've had to downgrade 2 projects recently because even MS Azure service APIs weren't supported - if you have to work with .NET avoid core and save your self the hassle - it's still alpha quality in many aspects after years since "1.0". I regret pursuing .NET career at this point, all recent developments on the platform are a joke - despite the praise they get for OSS moves. I'm moving towards frontend these days just to get away from this mess (ironic considering how messy frontend is - should tell you enough about state of .NET core/xamarin)


I've found the same, trying to do anything non trivial in dotnet core is just asking for headache after headache. Its basic things that end up costing hours in effort to get them working. Stuff you don't think twice about in .net. I really really want to use core but it just doesn't seem ready yet, sadly.


I first tried going full on .Net Core with an ASP.Net Core project with Docker and I was going to try to use Kubernetes even though we were going to stick with Windows Servers.

It was overly complicated and there were so many gotchas I found in the proof of concept that I did, I backtracked and went with the ASP.Net Core Framework (aka Asp.Net 5) using Kestral on top of .Net 4.6 and using Hashicorp's Nomad for orchestration.

I'll try again in a year....


What features are lacking exactly? With .NET Standard, almost everything should work unless it's relying on Windows specific APIs.


I was hoping your footnote was going to be a cite from a reputable source when you stated most startups and Enterprises are predominantly Linux, not just your own anecdotal experience.

My own experience is that most large enterprises use Windows because that's what their network people are use to and finding Windows network admins and developers are easier.


Regarding HTTP/2: I felt the development of this feature went a little bit "strange". For a long time the feature was blocked by missing support for ALPN negotiation on SSL. There was some interest from the outside to work on it, but discussion on it was stuck for a loooong time (1.5 years). As far as I can see now ALPN support has finally been added to .NET core: https://github.com/dotnet/corefx/pull/24389

HTTP/2 itself requires ALPN to talk to browsers, however a large part of the implementation can already been done without it. Out of personal interest I poured quite a ton of work in the beginning of this year into writing a solid HTTP/2 library for .NET, which could have been the base for webservers as well as things like GRPC: https://github.com/Matthias247/http2dotnet

It's state should be good enough to enable HTTP/2 now with less than a 2 weeks of work. However unfortunately I never got any feedback around it or felt interest in it, even though I think lots of stakeholders should be aware about it.

It seems like the ASP .Net core team is implementing now their own HTTP/2 library, which was far more barebones than mine when I last looked at it (https://github.com/aspnet/KestrelHttpServer/pull/1991). Don't have the time and interest to review the latest state.


gRPC C# currently comes with its own HTTP2 implementation, and is basically a wrapper over the C code that implements gRPC and HTTP2 stack. It doesn’t rely on .NET’s implementation of HTTP2 at all. And it does run on Linux as well as Windows.


> with a superior flagship language (C#)

and don't forget VB.net, which is an excellent language for non IT professional novice programmers, particularly if they come form VBA. .net provides a good language for novices that gives access to most of the flexibility and power of the framework (outside Xamarin basically).


I would not recommend VB.NET to anybody. The similarly to VBA is only very superficial and otherwise pretty much all attention is on C#.


Visual Basic is really not a good language. And it's essentially dead. Good luck finding examples, even sometimes on MSDN docs, using VB. Unless you also know C# and can translate between them, it's somewhat difficult to develop in VB.

I'm sort of surprised that Python on the CLR isn't more popular than it is; with the investments made in the DLR specifically for better dynamic language support, that seemed to be a natural move to me.


What's the appeal of CLR's python implementation when compared to the C python implementation?


You can interop with other .NET code. That's very attractive sometimes.


No GIL


http2? its too new to be supported.

.net http client does not support http cookies rfc 6265 which is 6 years old.


> What's holding .Net back is a lack of the vision thing.

What gives you the impression that it's being held back?

> High-end web tooling is almost exclusively JVM based...

Pffffft. You can't just pick a few JVM tools and proclaim that those are the only "high-end" options. Far from it. Have you heard of Mongo? Redis? Azure Event Hub? ScyllaDB?

> But even they are looking to move off Windows.

Oh how convenient that your anecdotal evidence supports your argument. Well, I also consult for small and medium sized business including many, many Medical companies. None of them want to move off of Windows. Quite the opposite - some of them have Unix systems that they can't get away from fast enough.


The only thing that is holding .NET back is the significantly slower compilation speed when compared to Eclipse's incremental java compiler.


If you spend 99% of your time coding and 1% of your time compiling, does it really matter that much?


the resharper plugin to visual Studio or the rider ide will both do this. Only builds the projects required and doesn’t need to build dependent projects unless a signature changed.


It's not comparable whatsoever to how much faster Java is. In Eclipse it basically compiles in the background right after saving a file so you never feel the impact of compilation.


you can do that in .net with the watch command https://docs.microsoft.com/en-us/aspnet/core/tutorials/dotne...


I'm not sure now, but 10 years ago I was really feeling the impact of compilation in eclipse. On a big project that I was working on it was taking about 20 minutes for a full build and I had to disable the background compilation because it always messed up stuff and my code would be out of synch. I think that in general Java compilation feels a bit faster, but for sure you can't say that you don't feel it at all in big projects.


How big is your codebase for this to be a factor?


I abandoned .NET over a lack of http2 support as well. The reason? It uses an HTTP implementation baked into the windows kernel. Wtf?

So not only does it lack HTTP2 support on Linux but also non-evergreen versions of windows.

And yes Go is the new competitor for Java, .NET core is a footnote because it has no open source community support.

I'll agree that C# is perhaps the best designed language I've ever used, but it seems that Microsoft decided to open it up many years too late to save it's market share.

Their best bet is creating native Java library interoperability. Third parties have been offering for years, but if it was baked in MS might just have a chance


Always confused that people talk about .Net as if it's failed on here, any time I look for employment in the UK there is a seemingly unlimited amount of high paying C# jobs available and it doesn't take long to get hired. Even my university taught in C# for the first year.

Net core is a slow moving project for sure, and it's not at a stage to use in production yet, but it'll get there and I look forward to further improvements made in 2018.


In the UK C# occupies the main enterprise language slot that Java does in America, that's why. Java just didn't get as far here. I remember in mid-2000s not being sure whether to learn Java or VB6/.Net, but a few years later I rarely saw Java jobs.

At least that's my impression from being on HN for the last decade, and working mainly in MS back-end languages in the UK.

The other one I never see mentioned in the UK is Oracle, I've only had Oracle mentioned to me IRL once, and that's because the local council is inexplicably moving from MS SQL to Oracle for reporting, but they're super incompetent.


Aahhh, thank you for stating this. I’m reading HN for only 1 year and half and couldn’t figure out why Java seemed so present in conversation as I thought it was not spread that much.

I’m french and I only know one person who’ve been on the Java path, and he’s not even working in France. I of course know companies working on Java, but not that much (not at all, if you except those working for Android) and suddenly it becomes crystal clear.

Thanks again.


While that's true, C# isn't limited to enterprise.

I've worked in startups and digital agencies throughout my career, and C# is everywhere in the latter. It's a lot harder to find startup work, but there are people building on the .NET framework.

You can happily make a career in .NET without ever working in an enterprise capacity.


.NET is pretty popular in the UK and elsewhere (particularly in finance) but you also see Java/Oracle in the same space. There are moves towards JavaScript/TypeScript for modern front-ends though.

The only place .NET appears to be discounted is in SV, at least from those I've talked to. Outside of that it's fairly mainstream but obviously you see more of it if you work with it and write/talk about it.


Sure, HN is exceptionally SV-skewed. .NET is the bread and butter of most small and middle businesses around the world, as it's Java and Oracle for upper-middle and enterprise.


I was a consultant in SF, we had plenty of huge Fortune 500 customers running .Net. The bigger problem was most of their desire to try to outsource everything to "save" money.


Yeah, I meant the startup culture in SF/SV. Among regular companies I assume .NET will have a fair share of use.


Net core is production ready since more than 1 year, Net Core tooling was not perfect until 6 month ago. Still the whole project from zero to version 1 in 2 year is not fast, its insanely fast ! Find something with comparable features made in less time (runtime, libraries, tooling etc..)


Most programming jobs on the world are for writing enterprise CRUD, that is not a public activity and not technically challenging (it is challenging, but in other ways) enough to be of interest here.


Same where I am. JS is usually the most popular in job ads, but C# seems way more popular than java in business, at least judging from ads. Go, python etc doesn’t seem wanted much. Probably because the software industry isn’t so focused around web tech corporations but on traditional industry, government, financial etc.

I think it’s the US in general and SV in particular bias of HN: there is an under-representation of the meat-and-potatoes software industry. The one where an average employment is 10 years, and an average employee is 40.


We've moved everything to .NET Core in Docker containers on Kubernetes. It's been solid all year and .NET Core 2.0 is definitely production ready.


Getting .NET/Java jobs has never been an issue. If that was Microsoft's motivation why even open source it? The open sourcing of .NET was to get the mind share of open source developers predominately on Linux. It hasn't fared better than Mono in that respect.


I've been using .Net core in production for over 6 months, it's been solid


I'd like to switch away from Java in future applications, and C# seems like the top contender, but there are questions I'd really like answered before I make the switch.

I see a lot of people talking about Microsoft open-sourcing .NET Core. But as someone who's never used it, what is .NET Core? And if .NET Core was open-sourced, what about the rest of it? Am I likely to run into major parts of the ecosystem that are still proprietary?

Also, can I develop and use C# applications on Linux without feeling like a second-class citizen? The ability to easily develop on Linux using free software and then run on my clients' Windows computers is one major reason I use Java at all, and I definitely won't switch to a language that doesn't support Linux properly.

And finally, how likely is Microsoft to fuck free software developers over with proprietary extensions in the future? This is Microsoft we're talking about, after all.


I've written[0] and spoken[1] a lot about .NET Core, so I understand that it can be confusing. The similar naming certainly doesn't help. To summarize (and oversimplify) there are three main varieties of .NET: .NET Core, .NET Framework and Xamarin.

The new open source and cross-platform one is .NET Core and it is currently suited to writing server-side web apps (e.g. ASP.NET Core) and command line applications. It is a reimplementation of .NET and more use cases are coming (UWP, CoreRT, native tool-chain etc.).

The Windows only one is .NET Framework and it is better for graphical desktop apps on Windows. WPF and Windows Forms are not open and are Windows only, so are not in .NET Core.

Finally, Xamarin is also open now and lets you build native mobile and desktop apps on Android, iOS and macOS. Full details of all these are on the official docs site[2] if you want to read more, or you could buy my book on ASP.NET Core 2 :).

[0]: https://unop.uk/book/

[1]: https://unop.uk/talks/

[2]: https://docs.microsoft.com/en-gb/dotnet/


Where does Mono fit in all this?


Xamarin is built on top of Mono. The same applies to Unity3D.

We're sharing more and more code with .NET Core now so there's convergence happening but there are still pieces that are unique to us.

Disclaimer: I'm working on Mono for Xamarin/Microsoft.


Mono is a reimplementation of .NET Framework. It supports most APIs and modules from the full framework, with one notable exception being WPF, the UI toolkit. They've been integrating code from .NET Core for better compatibility, but ever reaching 100% feature parity with the full framework is rather unlikely.

Mono used to have it's own C# compiler in addition to the runtime, but since the official C# compiler is open source, well-engineered and cross-platform compatible, it now uses the same compiler as other runtimes.

Xamarin is based on mono, and Unity ships Mono as their .NET runtime. Mono supports the most platforms out of all .NET implementations, including all current and previous generation gaming consoles.


Thank you for tuning in here.

I imagine that WCF was one of the first parts to be converted. How mature is the Core .NET WCF now?


This is a bit complex, but for what most people think of as WCF (enterprise SOAP APIs) then it is not supported on .NET Core. The W stands for Windows after all.

However, the ASP.NET Core MVC framework supports Web API and this was originally part of the WCF REST services. Of course, you can still interact with SOAP endpoints (served by various frameworks) as a client, as pointed out elsewhere here.


For me, WCF is the ability to run web services that can be configured on the fly for different protocols, security requirements, etc.

It's sad that it won't be available. Honestly, it puts a bit of damper on my development plans.


.NET Core does not have an implementation of WCF, and I can’t imagine to ever will.

.NET Core has a pretty good MVC framework you can build REST services on, GraphQL, or gRPC etc.

Most of the framework baggage was left behind.


There's https://github.com/dotnet/wcf which are the _client_ libraries of WCF for .NET Core.

For the server side of WCF you're right those are only available on .NET Framework right now.


I hope they won't port WCF. wCF makes simple things complicated.


For me personally, WCF made complicated things trivial. My startup was able to get into Fortune 100 enterprises with all their insane compliance requirements, letting their IT departments configure things the way they see fit.

Once you get the hang of it, WCF is one of the best frameworks EVER written.


> And finally, how likely is Microsoft to fuck free software developers over with proprietary extensions in the future? This is Microsoft we're talking about, after all.

There's a radical change in public behavior of Microsoft since Satya Nadella became CEO. While at first I was skeptical, it's now been three years we have had to observe whether Microsoft's actions match their promises.

So far, I'm impressed. I think their new vision and approach to doing business is much improved from that of their previous two CEOs - it's better for consumers and developers, and frankly it was necessary for the long term survival of MS.

I don't expect to see nasty behavior from them like we have seen in the past.


It seems like the floodgates opened after VS Code when Microsoft realized people actually like what Microsoft produces when they make it easy to use (no confusing, expensive licensing), so there's no need to lock people in. Everything people ever hated about Microsoft was a result of it trying to protect its monopoly rather than coexist.

They're still a little confused about Windows (why do I need to spend $50 on Pro to encrypt my drive?), but you can get Office on anything now. Even Edge has an Android port (beta).


Nasty behaviour is still there. Windows is a joke in terms of how bloated and clunky it still is, how it snoops on you, doesn't let you turn off updates without doing some shady things with the register and whatnot (which, a regular person, will never be able to do) and it has ads in the OS.


What about when the CEO changes?


Well, they could commit suicide and get a Ballmer clone.

They lost control of the client (it's web + Android/iOS now), steering away from the current course and back to the old one is a sure way to irrelevance.


I recently wrote about working with .NET Core on macOS and Linux [0].

The TLDR is the dotnet install script works great. Use Jetbrains Rider if you want the best experience (though not free). VSCode is just ok.

Overall I've really enjoyed my dive into this world I never thought I'd be a part of (let alone exist).

0: https://doesnotscale.com/developing-with-net-core-on-macos/


dotnet core = new, entirely cross platform runtime + core libs meant to serve as the new core of dotnet. In the future everything dotnet will be based on it, for now this isn't the case cause of legacy code. Basically you'd have dotnet core + Windows stuff for the Windows framework, dotnet core + various bits for Mono, etc.

Regarding the ecosystem, even Java has proprietary libs on top. For dotnet, Windows stuff is still proprietary, but even that is changing. You won't care about it anyway.

Just make sure you stay within dotnet standard (i.e. cross platform API standard for dotnet) and either use Open Source Microsoft extras or just use community-developed stuff.

For Linux C# dev, Jetbrains Rider or Visual Studio Code + C# plugin.

Regarding extensions, the battle has shifted. Microsoft is fighting Azure and GCE these days. The proprietary bits are in the services. The clients are Open Source to get mindshare, so no worries there.


Very accurate and precise.

Just one thing: MS is fighting AWS and GCE :) not Azure :). Well on the other hand, who does not remember the old org chart. Who knows.


Freudian slip. I'd say Microsoft is fighting Windows, these days :))


You can technically do everything with an all open-source stack. But you will have to create most of your workflow and integrate your tools by yourself. The all integrated official environment is closed-source only.

On Linux you'll be a second-class target for libraries. The language itself is well supported, but only it.

About future Microsoft behavior, your guess is as good as mine.


I am a decade long VisualStudio user but since .NET Core I switched to VS Code. I cannot understand your complaints at all. Tooling is nice and sweet under VS Code and from the command line. VisualStudio has so much irrelevant bloat that they rewrote even their VS installer to simplify it. For .NET Core the whole experience is very similar.

The second class target is also not accurate. Azure (the future of MS) runs 60% Linux (afair) which makes .NET Core on Linux their primary target.

Give Microsoft and the .NET community a break. They achieved a lot in three years. The vendors other than the .NET team (including the rest of MS) just need some time to adopt their libraries (I am looking at you Amazon).


Most libraries are being moved over to .net standard which is fully compatible with .net core.


> Also, can I develop and use C# applications on Linux without feeling like a second-class citizen?

I don't have much experience with C# development and basically none with .NET, but so far my experience has been a clear No.

The elephant in the room is the IDE. Visual Studio is the C# IDE and doesn't exist on Linux. There's MonoDevelop, which is now also owned by Microsoft and seems to share some components with Visual Studio, but it's still not nearly as powerful of an IDE. It feels more like a clunky text editor with a button that will make your program run.

Next thing is that I don't think, you can really develop GUIs on Linux. There seems to be some integration with GTK in MonoDevelop, but I sort of doubt that this works well, and my experience in Visual Studio has been that you practically cannot develop GUIs in C# without using Visual Studio, as so much of the design process is directly integrated into that. Also, developing a GUI application on Linux that will run on Windows, I don't think is possible at all, though I haven't spent much time researching that.

Last point that I have is sort of just a dumb bug, but it felt the most like I'm a second-class citizen. MonoDevelop does not currently support executing console applications on an external console on Linux when you install it via Flatpak (which is their primary distribution method).

But that by itself is not even the problem, it works fine with the internal console and I can live with that. The problem is that there's a checkbox to enable running on an external console and that checkbox is enabled by default. You cannot run console applications on MonoDevelop out of the box, solely because of this.

And console applications seem to be the main-thing that MonoDevelop is good for, so you'd think they would test that and ensure that it works, but apparently not. And really, just disabling this checkbox by default would fix the issue.

What makes this issue worse:

1. The error message is entirely cryptic, it says "Debugger operation failed - Cannot start process because a file name has not been provided.". Thankfully, the internet coughs something up quickly when you copy-paste that into a search engine, but at least I personally first thought I had forgot to give it a file name somewhere and tried to find that.

2. This isn't just one flag in the global settings that you have to flip once and you're done. Instead it's a per project setting, so you have to flip it every time that you start a new project and it's not particularly easy to find either.

3. This has been a known issue for a while (or at least, I hope that they know about it).


> the IDE

https://code.visualstudio.com/Download

> I don't think, you can really develop GUIs on Linux.

I can. E.g. recently I’ve picked GLES + NanoVG for the lower level of the stack, and implemented the upper levels (controls, touch input, transitions, etc.) in C#.

There’re higher-level approaches, including a couple of cross-platform ones (Gtk#, Avalonia, electron-based), I’ve picked lower-level stack because I needed to replace the whole Debian desktop including its desktop manager.


Or, if you’re willing to pay for something closer to VS:

https://www.jetbrains.com/rider/


That's interesting. Is the code/result public in any way?


The project’s proprietary, but it was straightforward.

I’ve created a C++ *.so library that uses DRM/KMS to initialize GLES on top of hardware GPU, and exposes NanoVG’s C API. Then in C# [DllImport], and actual GUI implementation. For touch input I just read /dev/input/event0 using FileStream API.

I’ve spent about a week implementing that thing, so it’s not that hard to do.

The main downside is the lack of ClearType. On the lower level FreeType library supports that, but NanoVG doesn’t.


Why would you want to do that? What do you find missing in 2017's Java and JVM comparing to other solutions?


.Net, C# and a version of Visual Studio have always been free since their release 17 years ago...


He means free as in freedom, so it has to respect the freedom of the end-user to inspect the code, modify the code to their needs and to redistribute their modified version as well as the unmodified version.

Basically open-source, but with the strong philosophical difference that the goal is for the users to have their freedom, not for a company to apply the same software development strategies that made Linux and Firefox so successful. (Also, someone will now murder me in my sleep, because I've said that it's basically open-source.)


Heck, I spent years earlier in my career as a .NET dev and I also don’t understand their naming. I wasn’t totally clear on what .NET core is. It’s not the biggest problem but the way they name things is quite confusing.


You know when movie franchises go through a reboot? That's very similar what Microsoft is doing with .NET Core. The 'Core' part of the name is hinting at a redesign based on a new runtime. They could've called it .NET Framework 6, but that doesn't give you any hints about the rewrite. I appreciate it's still not the best name in the world, but hopefully the analogy helped.

To add some additional information, whilst there has been a redesign, work has been carried out to allow a certain level of backward compatibility. This work is referred to by the name .NET Standard. Can think of this as re-implementing a selection of commonly used libraries from older .NET versions on the new .NET platform to make porting easier. The most up to date .NET Standard version is version 2.0.

https://github.com/dotnet/standard/blob/master/docs/versions...


> C# seems like the top contender

> can I develop and use C# applications on Linux

> I definitely won't switch to a language that doesn't support Linux properly.

I find this comment really strange. What makes C# top contender for you ? You seem to be asking really basic questions about it.


In truth, C# was the "top contender" because it was the only contender. Sorry for the misleading way I phrased it.

My main reason for using Java is for the easy cross-platform development. Most of what I code are basic GUI apps that do conversions between spreadsheets and various file formats. Java's "compile once, run everywhere", with its GUI support and many libraries, is exactly what I'm looking for.

When I heard that .NET was open-sourced and getting support for all platforms, I thought that meant it could be an actual competitor to Java for my use-case. As I've learned from the responses here, it's actually not, and my fears of running into major parts of the ecosystem that are still proprietary were well-founded. I don't need to worry about "future" proprietary extensions: they're already here!


My 2c: I never had any interest in writing C# on the .NET platform until it was open-sourced and added first party-supported cross-platform support with the introduction of .NET Core.

Nowadays it's my favourite language I write in - it has _excellent_ tooling, especially JetBrains Rider IDE. The open-source library ecosystem might not be as broad as NodeJS or Ruby, but it's high quality and growing all the time.


Let me say something about the prejudice (mostly my own).

For most the late 80s-early 2000s, I was not a huge fan of Microsoft mostly because of their predatory practices and the shoddy quality of their software. But they had a few products that I thought were legitimately good, and Visual Studio (and the C# language) was one of them. Part of my admiration of it was partly because of Anders Heijlsberg, its architect.

I started my programming life with Borland tools (Turbo Pascal), and then later Delphi. Anders architected all of these tools. They are long in the tooth now but at the time, these tools were fairly well regarded because they reflected flair and good taste. When Anders created C#, I managed to look at it without being clouded by my Microsoft prejudice, because I knew who was behind it.

I started writing C# code a couple of years ago when I started working for a large enterprise. Even as a Linux/UNIX guy, I am able to say that C# is a truly elegant language that is fun to work with, and I would pick it over Java or Scala any day. I don't like its Windows centricity (Windows is still not my favorite platform), but outside of that, it is truly a well-architected language.

Silicon Valley types would do well to put aside their prejudices of the C# language and evaluate it based on its own merits.


C# is a great language and I love using it (especially compared to Java), but right now the Microsoft stack is prohibitively expensive compared to the common stacks for java, ruby, and python. .NET Core is a great step in the right direction, but it is going to be a long time before parity with other ecosystems is reached and unfortunately enjoying writing the code is way less important than having the libraries I need to interact with modern web technology.


What are you paying for with C#? Tooling including IDE is free, servers are typically free (unless you run IIS on windows) and databases are obviously the same as in any other stack. In an apples to apples comparison I can’t see .NET coming in more expensive than java. The only thing that might be more expensive on Linux is if you need a better IDE than vs code - you’ll have to pay for JetBrains Rider.

But good java IDEs aren’t free either.


I'm pretty sure he meant windows, IIS and possibly the upgrade from headless to something with a gpu for windows ops.


Yes, I am in the same boat. I started my PC career in DOS with Turbo Pascal then C++, then in Delphi/Oracle after college. I started C# full force around 2005 or so and have been using it ever since.

Delphi was way ahead of it's time.

PS: Commodore 64 was my first love.


Do not forget Anders Heijlsberg involvement in that little thing that TypeScript is :). I am also a big fan.

To be fair, you should also mention Anders involvement in the thing that J++ was, and the Sun vs MS settlement.


FYI - there is support in .net to run any nodejs package



Do you use Rider professionally with other team members that use Visual Studio? If so, can you elaborate a bit how your experience was? I'm a Java developer that is now working with C# and Visual Studio is driving me crazy. I want to use Rider but I'm unsure on how it interacts with TFS and MS-centric workflows with other team members.


Seems to play nice with the solution. Code styles are customizable so you'll want to tweak that to be your team's style. I think there's a tfs plugin but I haven't used that. It's good enough to try for a bit, I'd say.


I have given up on .NET for the most part. Wake me up when we are in Fedora's repos because until then, there are pieces that Microsoft hasn't (won't?) release that we need to get out of COPR.

The people of Dot Net Special Interest Group at Fedora are too nice to say this but I am not. Microsoft is dragging its feet and it is ridiculous.


.NET core seems to install and work fine on Fedora 27 using:

https://www.microsoft.com/net/learn/get-started/linuxfedora

There were issues with Fedora 25 which is what I was previously running, but that resolved itself after I dnf upgraded to 27.

Or am I missing something here?


Fedora has strict guidelines that you have to meet to be included in the default repos. These packages don't meet them.

This indicates the project isn't free enough.


COPR = ?

I also can't imagine why Microsoft wouldn't want higher adoption levels...



Maybe because it hasn’t been the most popular tech among open source developers .net is now a very effective tool for almost any kind of work. The choice of libraries and frameworks is smaller than in Java but quality is better and purpose more clear. You can pick a few core libraries and build on that instead of sifting through millions of half-done or incompatible frameworks. And if you don’t demand that Windows is like Linux then it’s quite decent OS. The only thing missing is good desktop UI framework, but nobody has a better solution now


.NET Framework is still closed source AFAIK. .NET Core is open source, but that's two different things. Moving existing applications from .NET Framework to .NET Core and running them on Linux is still troublesome (for example lack of proper ODBC support on .NET Core). Serialization between the two is often not possible or not easy (differences in byte layout). While I think .NET Core is better than nothing, it all has a long way to go, including MS-provided API dlls (like ADOMD, etc.).


I learned C# a while ago when started a project in the now defunct XNA. I loved how I felt like home when moving from Java bit with some really nice differences.

I thought that after open sourcing .Net the C# adoption outside the MS ecosystem would be wider by now, but I feel it's not the case. Or am I missing a trend I'm not aware of? (which is very likely too)


There is still wide resentment towards Microsoft, just go to /r/programming and check out threads about .Net, there's at least a few threads at the bottom going "EEE".

Plus dotnet core wasn't API stable until recently. I think we're still 1-2 years from mass adoption.

Also check @librexpr's comment above, there's a lot of confusion around.


It's still not really any where near finished is it?

I think they finally managed to get image manipulation in to replace the missing System.Drawing, but EF Core is still woefully half-finished.

The literally seem to have no clue about how people actually use their system and keep focusing on all the wrong things. Actually, it's more like some idealist programmers have become the core team instead of getting-it-done programmers, so it's all the latest fads instead of getting finished. The obsession with async isn't helping either, it makes the code so bad for no real-world performance gains.

My impression is they are moving super slowly and from the POV of an existing customer, the whole process has been a complete disaster. It might end up ok, but at the moment it's just a bad version of existing .Net.


Your paragraph about they "literally don't know how people use their system" seems obvious to me that you must be a 10x mega developer with insider knowledge. Idealist programmers, you're right! Async await offers NO benefits and was implemented in es6 as a mistake... probably corporate bullying.


Async is bad and you're pining for entity framework? We lead different lives.


It's slow going but I'm not sure that's bad or unexpected. MS bought mono and that blessed it as a platform that isn't dead in the water. Most existing projects are fine staying where they are until Microsoft hardens .NET core.


C# is significantly missing tooling. The tooling on Windows is okayish, but that's about it.

You have no cross-platform build and dependency management tool that runs on .NET Core (Using MSBuild and NuGet together requires Mono or the full .NET Framework), and there's only an early version of JetBrains' Rider IDE for non-Windows platforms, there's basically no working integration with any CI or CD system, and the library ecosystem is basically not existing, compared to the open source Java world.


This is just incorrect, and getting more incorrect every day. Rider is RTM, and works beautifully, particularly with .Net Core. It's trivial to setup CI/CD with Jenkins, or TeamCity, or VSTS.

What library support is missing on .Net vs the JVM? In my experience everything that's really useful has .Net ports.


It is trivial?

Then please help me — I'm trying to use C# more again — what I should use for dependency management, builds, and artifacts deployment (basically, an equivalent to gradle) on .NET Core. I'm seeing Cake, aka C# Make, but the C# subreddit told me that's useless and I should just use MSBuild. But that doesn't get me my dependencies at all, and doesn't run on .NET Core. I could write a bash script to invoke nuget and the C# compiler but that would be ridiculous.

For libraries, from http2 to time + date libraries, C# is lacking, in tmy last project I ended up straight up translating the parts of JSR-310 I needed.

I'm looking for a 1:1 replacement for JVM languages here, especially regarding tooling. Rider has proven much less mature than IDEA for now.


Trying to directly translate a Java-style workflow to .Net is probably going to be tough sledding; it's just not how things are done. You can do it, but you'll fight everything more than being on the happy path. The dotnet CLI tooling is relatively slick, from what I've seen.


What would the C# tooling workflow then look like? I haven't found anything that's reasonably easy to use with just .NET Core.


What were you using Gradle to do that you want a c# replacement for?


Basically everything. In my web projects, gradle runs css and js minification and compilation, and in game projects, it runs the asset preprocessing.

The build-time code is handled with gradle’s buildSrc folder.

I also obviously use Annotation Preprocessors to pre-generate code for my Java projects, and additional build tools to further minify and optimize the output (e.g., for Android, I also run redex over it).

Basically, gradle for me handles the entire build – fetching dependencies, building native libraries, running code generators, building Java code, binding them together, processing assets, compressing the result, and optimizing it all – and deploying the results.

In nice, and modular steps.


"dotnet publish" should have you covered for restoring from nuget, compiling and producing a deployable package. Is there something it's missing for your use case?

Noda Time might have what you need in a datetime library.


> "dotnet publish" should have you covered for restoring from nuget, compiling and producing a deployable package. Is there something it's missing for your use case?

Thanks a lot – this is the first time someone actually provided a useful solution, this might actually work well enough for simple projects.

> Noda Time

Also thank you a lot, that actually is significantly better than Joda Time in the Java world, and as result, actually useful (in fact, it feels like a 1:1 clone of JSR-310, at least from what I've seen in their API docs)

This is actually very helpful, thank you :)


Link to the recording (slides and audio): https://www.youtube.com/watch?v=garlskQb8BU


Thanks, this is exactly what I've been looking for.


If you don't want to watch through the whole thing I wrote a post the gives an outline, see http://mattwarren.org/2017/11/14/Microsoft-and-Open-Source-a...


It’s funny when Java devs mention that C# and .NET is a copy cat. The irony is the other way around , even though Java predates .NET , the same creator was then one that created Delphi which Java pretty much copy pasted not as elegantly. It’s great to see Delphi being around and it’s legacy continue through C# and .NET. The fact that Microsoft open sourced it brought a smile in my face. My Delphi days are over, nowadays I Code in Python, but .NET still feels like home.


It actually goes further back than that. Anders Hejlsberg created Turbo Pasacal, then Delphi.

However, the development of c# did follow the development of Java. C# is not really related to Delphi or Pascal other than they have the same author.


Not really, .NET is heavily tied to its IDE and winforms are very similar to VCL. Not to exclude the fact that Microsoft was already heavily copying Delphi way before .NET. Java is simply another programming language.


created Delphi which Java pretty much copy pasted not as elegantly

Maybe that is funny, but it's not even a little bit true. Delphi and Java were released roughly contemporaneously. One was mostly an IDE/RAD tool for Windows, the other a cross-platform VM + language. Unlike .NET/Java, Delphi/Java were not even the same kind of system.


Being open source is good but outside of Windows it's still perceived as a Windows solution with bonus Linux support. I have yet to hear someone migrate from Java, Go, Node, Ruby ... to .NET in meetups I attend. Is open source .NET penetration on Linux any better than Mono?


   What exactly is .Net's niche, given front-end wars are over?
.NET works as an awesome back-end for Angular 2+


But so do most other programming languages and frameworks.


Can we have a link to the actual talk please?


I am extremely impressed by Microsoft. I think Microsoft has proven the world that nothing is impossible. Once a hip tech company at the beginning of the computer era, then transitioned into an old, boring and outdated corp has now turned into one of the healthiest, most innovative, brave and genuinely nicest tech giants of our time again. What Microsoft has done and achieved in recent years is astonishing.

They played many years catch up and I think at the point when they realise they cannot do everything themselves and started to embrace the open source world they quickly moved from catching up to being the innovator who pushes new limits again (Azure, Surface devices, Window 10, .NET Core, etc.)

It's already a bit old, but I wrote a blog post not too long ago where I tried to sum up some of the amazing things that happened at Microsoft over the course of the last few years:

https://dusted.codes/thank-you-microsoft-for-being-awesome


Literally none of these characterizations of Microsoft, past or present, resonate with me at all. Maybe the company has truly turned a new page, but I still mostly see them copying others’ ideas and playing second string as a result. I’m glad they finally have some real OSS offerings but I don’t yet see any as truly collaborative efforts which keeps them on the sidelines.

But, you know, hail corporate!




Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact

Search: