There is still work to be done, https://github.com/dotnet/coreclr/issues/1192 . RyuJIT has legacy backend code and the new RyuJIT backend, only the former is functional on ARM but won't be supported. Exception handling, also unwinding for GC is seemingly blocked by an LLVM bug resulting in bad unwind information being output for the exact build settings we need https://llvm.org/bugs/show_bug.cgi?id=24146 . It is quite surprising to me how much visibility this has gotten though even in the very rough state it's in now.
.NET everywhere, that makes five platforms in less than six months. Windows, Linux by MSFT and OSX, FreeBSD, ARM done out in the open by the community via GitHub pull-requests!
It's not ready for end-user yet, I agree on that part. However I experimented with CoreCLR on Linux and managed to get things running. It will most likely take another 6 months or so to polish all those and we'll get ourselves a new cross-platform language.
RyuJIT is included with .Net 4.6, which RTM'd last week. It's production quality on Windows. It's probably an older and more stable version of what is on GitHub.
You are correct. Ryujit is ready for production but coreclr has other parts that are different from .net 4.6 and coreclr specefic (like PAL for non windows) which is not production tested yet.
Mono has worked fine for me in the past but I was more referring to CoreCLR which is consistently called 'cross-platform' now but is far from it as their own tooling crashes all over the place when attempting to use it (dnu restore, dnu install, dnx . run, etc).
Yeah I know, was just saying there was a viable platform for back-end C# development.
I hope both teams do not duplicate work and are happy to share design and code changes. C#/.NET is nic, I think it still has potential to compete for Linux server back-end services with Go and Java.
Coreclr now compiles on arm tested on rasperi-pi 2. This port was a community effort. It is still rough (debugging and exception handling not supported currently) but it will reach their eventually.
Is Visual Studio written completely in .net at this point? Meaning will this get ported over automagically once all the .net pieces are in place on other platforms (assuming machine resources are available)?
No, because it's all using Windows UI APIs underneath. The cross platform VS code editor is code.visualstudio.com. You'll never see FULL VS elsewhere, IMHO.
When you work with non-MEF Visual Studio extensions it's COM all the way down. To port Visual Studio you'd first need to port COM, which is probably never going to happen. Removing COM looks like it would encroach on rewrite territory (and would break a bunch of existing plugins that use it): also incredibly unlikely.
Oh goodness... this. I've been exploring C# lately, and absolutely love the language, but the tooling is abysmal.
Let me get this straight. The only serious IDE is Windows-specific, starts at $600 for the typical company (with advanced editions costing more than a small car)... and THEN you need to pay $200 more for a JetBrains add-on called ReSharper, to make it almost as nice as IntelliJ? That's pure insanity. As a Java developer, I could just pay $199 for IntelliJ, period. Or use Eclipse or Netbeans for free, either of which are light-years beyond MonoDevelop (the only real Visual Studio alternative on the .NET side).
The .NET ecosystem is WAY overdue for some IDE disruption. VS Code is interesting, but I'm skeptical about how far that will go if they don't eventually open source it. Without some legit alternative to Visual Studio, I fear that all of this .NET Core and cross-plat ASP.NET stuff is a waste of time in terms of retaining or drawing new developers.
Visual Studio 2015 Community is a full-featured world-class IDE that's now free (edit: for OSS or Companies with <$1M Revenue) - which I've now moved to exclusively for all my .NET projects.
I also swear by ReSharper (R#) which IMO pays itself in productivity immensely, so the cost isn't an issue for me.
I also use IntelliJ IDEA, WebStorm and Android Studio and IMO they don't match the productivity of VS.NET + R# combo, which I'm putting down to C# being a more enjoyable and toolable language.
It's important to notice that MS have recently shifted their business model around VS.NET where now what used to be the VS 2012/13 Professional edition is now the VS 2015 Community edition which is now free - they're removing the cost barrier into VS.NET (and forgoing VS.NET Revenues) to get more developers onto the .NET platform which will translate into more Windows Server Licenses and Azure revenues.
With this shift, IMO it's fair to assume that if it wasn't for the decade of Windows-specific legacy native code that's in VS.NET they would've also given it away for free on other platforms as well. VS Code is free IDE that they're going to support cross-platform, i.e. I don't think they want to intentionally cripple VS Code to force it as a Gateway drug into VS.NET since that's not their primary revenue strategy for .NET - getting more developers on .NET is.
At the same time I won't recommend VS Code until it's Open Source, you're better off using Atom + Omnisharp combo which is OSS and safe from abandonment and IMO protects end-users should they start loading it with crapware or otherwise become poor stewards of the project, since a fork would be possible.
> what used to be the VS 2012/13 Professional edition is now the VS 2015 Community edition which is now free
Not true. If you are using Visual Studio professionally, rather than for your own personal educational tinkering, then you're only eligible for Community if your company has less than $1 million in revenue. In almost twenty years, I have never worked for a company that would qualify for that condition (and this includes multiple startups). Even if your company is small enough to qualify, then no more than 5 developers are allowed to use Community at once. See section 1(b):
If you are currently using Community for professional work... then either you're an independent freelancer, or else are working for the absolute tiniest of unprofitable companies, or else are violating Microsoft's license terms because you don't understand what they are (like most people, it seems).
> If you are using Visual Studio professionally, rather than for your own personal educational tinkering, then you're only eligible for Community if your company has less than $1 million in revenue.
Or if it, as many companies with more than $1 million in revenue do, develops open source software.
> If you are currently using Community for professional work... then either you're an independent freelancer, or else are working for the absolute tiniest of unprofitable companies, or else are violating Microsoft's license terms because you don't understand what they are.
Or you are a professional developer working on software which is licensed under an OSI-approved open-source license.
Yes, yes, Richard Stallman... I saw your other reply already. :)
While a valid point, surely you would acknowledge that it is a fairly small niche case? I imagine that overwhelmingly, the more common scenario is people using Community to work on non-open source software, simply because they don't fully understand the license terms (or don't care).
Could be said to be an open source 'replacement' for R#. I've only been using it for a short while and while it doesn't do as much as R#, it also doesn't have the performance cost of R# (which is downright obnoxious if you are used to working without R#).
> The only serious IDE is Windows-specific, starts at $600 for the typical company (with advanced editions costing more than a small car)... and THEN you need to pay $200 more for a JetBrains add-on called ReSharper
This is completely ludicrous to me. Is it really that much better than just using emacs, vim, sublime text etc? I've written thousands upon thousands of lines of code with just a text editor (for which I've paid either nothing or very little) and my code runs just as well. It's just text at the end of the day, after all, and most of these editors can give you syntax highlighting, tab completion, linting, etc. For complex build procedures, there's make or any number of other free options. What exactly does one gain from these IDEs that can justify these kinds of price tags?
You're comparing an editor to an Integrated Development Environment. It's really apples and oranges.
The pure editor part of VS (and most IDE's) is probably worse than emacs/vim. However, you do not get refactoring, profiling, source-control, code-sensitive completion and all that other jazz that IDE's provide, all in one package and in more-or-less the same interface.
Sure, there's probably plugins for vim/emacs that do all of these, but do they all work together well and how much time/expertise do you need to set them up.
Now that doesn't necessarily make an IDE better, I fully expect some people do code faster/better in vim than in VS, but it certainly provides a lot of added value/features.
1) It's that much better yes. I'm not going to start an endless discussion on text editors vs IDE's, but for an ecosystem designed from the ground up to handle hundreds of related projects with hundreds of contributors with different roles, and huge class libraries with static types, it's a massive productivity boost to have everything integrated (source control, testing, profiler, ...). For languages that aren't in this category (such as C or JavaScript) the story is completely different.
If all you did was write code then, you're right, text editors are just as capable as IDEs.
However, a decent IDE often has options that make building and debugging easier to manage. For example, one of the 'killer features' of VS is IntelliTrace debugging (a form of historical debugging). Does your text editor offer something similar?
For personal tinkering, that's great (as long as you don't mind running on Windows, which is no longer the case with most web developers these days).
However, if you work for any reasonably established company, then it is illegal for you to use that Community Edition for company work. Your company must purchase a license for you, and that starts at $600 for the licensed equivalent of Community.
Perhaps that's perfectly fair. However, it's a huge bit of friction for a developer trying to introduce C# into their shop for the first time.
In the past, I've been able to lobby Java-based employers to let me write some internal apps in Scala. I've been successful in introducing a Golang web service. In both situations, I was asking a manager to take a chance on some unfamiliar tech, and on the risk that it would be hard to maintain if I left the company. However, and this is key... I was NOT asking them to approve any budget. So I won!
If I have to convince a manager to take some risks, AND to approve budget for $600 per seat, then forget it. I'll just wait a couple of years and see if Visual Studio Code gets open-sourced and turns into a sufficient VS replacement. If it doesn't, then .NET will continue to be something I tinker with in my personal time for hobby projects only (at most).
The bottom line is that pricing for .NET developer tools is ABSURDLY out of line with typical pricing for other dominant platforms today (i.e. Java, Python, Ruby, PHP, etc). Shops that are all-in on Microsoft across the board are just used to that, but it makes .NET completely non-competitive for potential new users outside that bubble.
It's the 21st-century now. You make your money in production (i.e. cloud platforms, proprietary app servers, support services, etc). Trying to make a buck off developer tools is daft. Developers have too many options to choose from these days, you'll just bleed mindshare like that.
VS Code utilises[1] OmniSharp-Roslyn[2] (which is an open source project not started by MS) to provide intellisense and refactoring for C#.
If you want to use something that is fully open-sourced (since day 1) and also utilises OmniSharp Roslyn, then check out OmniSharp Atom [3], which is an Atom plugin written mostly in TypeScript. OmniSharp Atom and OmniSharp Roslyn are both very welcoming of contributions. So if there's something that you see that's missing, feel free to send a PR :)
That's a fair point. I tend to overlook Atom in general because its startup time is slow as molasses compared to VS Code (and especially Vim or Notepad++). However, it's still in early days too, and hopefully will improve over time. Still, VS Code is working toward debugger support and a general "IDE feel" that I'm not sure is in Atom's future. We'll see.
To be honest, as long as VS Code is free-as-in-beer, has a plugin-in system that's flexible enough for the community to go nuts with, and can adequately serve as the primary development environment for an ASP.NET app... then I'm delighted.
However, perceptions mean a lot, and in the long-run I just don't see it getting uptake from the Python/Ruby/Node.js crowd without being open source. More of a marketing issue than anything else (although there's also the concern that MS could abandon it someday).
If it's been a little while since you last looked at Atom, then consider trying it again, they've spent some effort on optimising it lately. I mean, it's still not the speediest around, but it's improved leaps and bounds from even a few months ago. It is obviously not the only editor with an OmniSharp plugin. There are many others. [1]
I believe that debugging support on VS Code is currently limited to Node and Mono (and that's only on OS X/Linux) [2]. The team(s) behind OmniSharp (that is the various editor plugins) do desire bringing debugging support to one or more editors.
Isn't it amazing that code can get to that point? I mean, even insanely complex things like space shuttles/stations are understandable. They're documented, compartmentalized in functionality, and maintainable. If they need to build onto it or swap out some functionality, they can do it. It's pretty sad that we let some software turn into behemoths that don't accept change.
I'm working on some C code now... functions that span a thousand (or more!) lines. With all variables declared at the beginning, many having one letter names or being reused at various points. With lots of chunks of code repeated. Shit, one chunk of code writes out a whole XML format to a file. Then the whole thing is is copy and pasted to write the same XML format to a socket.
To add to the incomprehensibility, add feature-hacks everywhere. "get_flag" just does "thing->flags[name]". But "set_flag"? Hah, that's about 500 lines long and has all sorts of secret logic. (Does your flag name have a '[' in it? Does it start with "from_" or "to_"? Then you get a special code branch!)
And then, just to give you the finger, we'll sprinkle newlines everywhere, seemingly at random, just to make the formatting look bad. Oh, and there won't even be a line of documentation detailing which structs do what, or any general logic or guide at all. But that's OK because code is documentation. Enjoy figuring out the custom "XML preprocessor" invented because "XML is too limited".
This project was started fresh because a previous one was "bad". If you don't have someone with a strong sense of aesthetics that can push back on feature hacks and cheap implementations good intentions quickly decay.
I don’t mind large functions if they make sense. I have one (god) function that is around 900 lines long, but it is just a series of function calls in order that checks each call for errors. Keeping the code linear like this reflects the data flow and makes it easy for me to remember the call order.
That physical artifacts only have 3 dimensions probably makes it more difficult to introduce the sort of interconnectedness that tends to make software artifacts harder to understand.
Others have already answered the question, but I think it's no longer really necessary.
There's Omnisharp which gives you much of the same intellisense and other IDE integration bits in the editor of your choice - Emacs, Vim, Sublime, etc.
Cool. Thanks. Definitely looks interesting and the're only on .5 preview but you can see it's starting to take shape. I don't really ever use the "Enterprise" stuff on vs professional, just the editor, debugger, and the git integration has been nice to have.
Their is a problem with that. First that is 15 years old and is not open source (it is just source open). This was for educational purposes and first ever implementation of the common language runtime. It was a prove of concept project.
"Shared Source." I.e. Never look at that code, ever. Just pretend Rotor doesn't even exist. There are projects that will not have you (Mono) if you've read Rotor code.
Yeah, the problem is that MS decided to not really do cross-platform, despite having paid the technical cost and design. Thus dooming .NET to coming second place to the JVM as far as neat languages and tech goes.
(Side rant: I wish they'd just upload stuff to youtube, the C9 codec/cdn support never works right for me, even on 100Mbit fibre the low quality streams stall out)
