This is only the first step for Visual Studio Mac. The next will be to begin bringing feature parity to the Mac version (My gut feeling is that VB.NET won't make the leap, but with Roslyn, maybe I'm wrong).
I feel this isn't stated enough. VSCode, albeit made by Microsoft, goes way beyond Microsoft's core interests. Given that you can now enable language support for around 470-ish languages, I don't think that their game here is to be a replacement for anything. I have an even crazier suspicion about what VSCode is really about.
So if you've lived with Visual Studio for years, you know that it's been COM based for a looonnnnggg time (since inception). I think VSCode serves two interests. The first interest is to bring non-Microsoft users in the fold with the hopes that they may go "This ain't so bad, maybe I'll give other stuff a try". I think the second is that they need a playground to figure out how to, excuse me here, "unfuck" the core architecture of Visual Studio. If they can write suitable replacements for core functionality, let them bake and mature for some time, then BOOM! they can replace the VS components.
Like I said, just a crazy opinion based on what I've seen so far.
AWS UX is a dumpster fire. Azure was quite nice from what I can tell. I love VS code and am a mac user. I also strongly dislike AWS as it is extremely complex and annoying. If there was amazing tooling, I would consider switching from digital ocean to azure.
I also agree that their long-play is Azure. You just wait, they'll put a major investment into IntelliJ or Eclipse to make it more Azure friendly too.
COM is essentially a formal way of using C++ vtables  from C and other languages, so you can create and consume components in any language, and call back and forth between them. It's a way of expressing a rational subset of how C++ classes work and format in memory, in a way that can be implemented in other languages.
It was the outcome of the C / C++ / Visual Basic language wars at Microsoft.
The original 16 bit version of Visual Basic version 1 through 3 had a plug-in extension mechanism called VBX -- Visual Basic Extensions .
They were extremely popular and became a victim of their own success, after a whole industry grew up around them, and people started using them for all kinds of things they weren't intended for, and wanted to use them from other languages and frameworks like Borland. Microsoft had to do something about that to mitigate the success disaster of VBX, so they invented COM.
At the time, Microsoft was transitioning from Win16 to Win32, so they came up with the 32 bit COM definition, also known as OCX's, or OLE Controls, which they later called ActiveX, because COM was so hard to search for, and they wanted to take the spotlight away from Java with a new buzzword.
So they brewed up a bunch of ugly C macrology that enabled C programmers (or Visual Studio wizards) to define COM interfaces in header and implementation files that just happened to lay out memory in the exact same way as vtables of C++ pure virtual classes.
While C++ programs would use other ugly macros to declare actual honest-for-god C++ classes to implement COM interfaces.
And Visual Basic programmers would ... do whatever it was that Visual Basic programmers did.
COM's IUnknown::QueryInterface  method is essentially like C++'s dynamic_cast . But it also adds some object aggregation features  that let you compose multiple sub-objects together by aggregation instead of using monolithic inheritance. You could implement "tear off interfaces"  that lazily create aggregated sub-objects on demand, useful for implementing callback interfaces.
MFC (Microsoft Foundation Classes) is a set of C++ wrappers around the lower level Win32 interfaces, plus a huge framework for implementing GUI widgets and dialogs on top of Win32, and for wrapping rube-goldbergesque OLE Automation interfaces around C++ classes. For some time MFC was the primary way of implementing COM interfaces in C++, but it was infamous for being horribly complex, with all its ugly macros, Hungarian notation, and bizarre programming conventions.
Later on Microsoft came out with the C++-only ActiveX Template Library (ATL) , which, although it was still necessarily quite ugly, was a more elegant and powerful way of implementing COM components in C++, didn't have the baggage of supporting C, and let you implement COM/OLE/ActiveX components without the hideous MFC framework. ATL was popular for implementing all kinds of Internet Explorer plug-ins.
OLE was actually a layer of COM interfaces and MIDL (Microsoft Interface Definition Language) on top of COM, which adds the IDispatch interface for dynamically querying and invoking methods and properties at runtime, and variant types : tagged unions for representing polymorphic data (i.e. VB data types) and passing parameters to OLE IDispatch functions.
OLE was the glue necessary for integrating COM components into the Visual Basic runtime, so it directly supported Visual Basic data types, calling conventions and semantics like indexed properties.
OLE also provided an interface definition language (ILD) you could compile into binary type libraries, use to generate boilerplate C and C++ interfaces, and OLE also had COM interfaces and structures for providing those type libraries at runtime. It also had a lot of persistence, runtime reflection, and user-interface related stuff for plugging components and dialogs together in windows, providing property sheets, editing and configuring controls, etc.
MIDL supported defining components with "dual interfaces" : both an OLE IDispatch interfaces taking variant type parameters, and also more efficient lower level COM interface taking primitive types. Runtimes like Visual Basic knew how to integrate dual interfaces and could bind to the more efficient underlying COM interfaces, instead of going through the slower generic dynamic IDispatch interfaces.
IDL also described the intricacies of DCOM  interfaces (for in-process and networked remote procedure calls), parameter marshalling , and all kinds of other bizarre stuff. DCOM is where COM went off the deep end.
At its core, COM was essentially a very simple and ingenious idea that elegantly solved some real world problems, but it eventually evolved into something extremely complex that attempted to solve many other unrelated problems, and which required a massive amount of tooling, and that depended on Microsoft's Visual Studio and Win32 environment.
Microsoft actually ported ActiveX to the Mac using ATL and Metrowerks Code Warrior, in order to implement Microsoft Internet Explorer for Mac  (which was actually the best web browser on the Mac at the time, by far). But not a lot of third parties (except for me and a few other crazy people) ever used ActiveX on the Mac.
However it did become quite fashionable for other organizations to create portable COM knock-offs to solve some (hopefully fewer) of the same problems, but which were incompatible with Microsoft's tooling and COM itself (which kind of missed the main points of COM, but hey).
For example, Macromedia came up with MOA (Macromedia Open Architecture) , their COM-like plug-in extension mechanism for Director and other products.
Mozilla didn't go nearly as far down the rabbit hole as Microsoft did, and later backtracked in their valiant "deCOMification" aka "deCOMtamination" and "outparamdelling" efforts .
 Virtual Method Table: https://en.wikipedia.org/wiki/Virtual_method_table
 VBX: https://en.wikipedia.org/wiki/Visual_Basic_Extension
 Variant Type: https://en.wikipedia.org/wiki/Variant_type
 IUnknown::QueryInterface: https://msdn.microsoft.com/en-us/library/windows/desktop/ms6...
 dynamic_cast: https://msdn.microsoft.com/en-us/library/windows/desktop/ff4...
 Aggregation: https://msdn.microsoft.com/en-us/library/windows/desktop/ms6...
 Tear Off Interface: http://www.codeguru.com/cpp/com-tech/atl/performance/article...
 ActiveX Template Library: http://www.drdobbs.com/windows/the-activex-template-library/...
 Variant Types: https://en.wikipedia.org/wiki/Variant_type
 Distributed COM: https://en.wikipedia.org/wiki/Distributed_Component_Object_M...
 Marshalling: https://en.wikipedia.org/wiki/Marshalling_(computer_science)
 Macromedia Open Architecture (MOA): https://www.adobe.com/support/xtras/info/moa.html
 XP/COM: https://developer.mozilla.org/en-US/docs/Mozilla/Tech/XPCOM
 deCOMtamination: https://wiki.mozilla.org/Gecko:DeCOMtamination
No, it is actually quite actual, I guess you haven't looked into how Windows 8, 8.x, 10 and UWP applications work.
Great summary, though.
This was how a lot of system and third party libraries provided large amounts of functionality in the windows ecosystem for quite some time. These are usually in the form of a DLL (Dynamic Link Library), libraries of COM components, packaged as a ".dll" file. This is related to the re-use and versioning issues known informally as "DLL hell".
Most COM components are native C and C++ based, exposing a standardized COM interface for component reuse.
Dot net was a new ecosystem, but much of the Win32 related dot net API is wrappers over existing native COM components. There are also extensive dot net facilities for repackaging and working with existing COM libraries through a Com Interop layer. https://msdn.microsoft.com/en-us/library/ms173184.aspx
The COM system provided an approach to interoperability and reuse for a long time, but compared to our current generation of cross platform compatibility, the venerable COM system components are proving to be a significant legacy challenge for cross platform implementations.
COM usage on Windows only increased after Windows Vista and is at the heart how UWP works and user space drivers.
Using it from C++/CX is quite painless compared with the old ways, as it is quite similar to .NET, Delphi and C++ Builder ways of using COM.
For a little pain ATL style, you can use Windows Runtime Library.
Kenny Kerr and his team are pushing for C++/WinRT, a new C++ projection (language binding), based on pure Modern C++, with the goal to eventually replace C++/CX. Currently WIP, though.
For those that really like to suffer, the old way of using MIDL compiler with C is still possible for UWP applications.
From our projects, I would say most UWP developers use .NET for UWP controls and only resort to C++/CX if integration is C++ code is required.
I believe that .NET binaries, at least on Windows, are actually built atop COM but I'm not sure. Been a while since I've cared =)
COM = Component Object Model.
There is some confusion here because the part of the "export surface" design for .NET binaries/modules was originally designed to replace COM's "interface design language" (IDL) in a version of COM that was never quite finished. Coming back full circle the .NET "export surface" design was indeed recycled for the WinRT component model (the COM replacement of the WinRT/UWP stack) in its library metadata format (.winmd), which to .NET tools look like a .NET binary that is missing all of its (IL) code.
Long story short, .NET was not built on top of COM but parts of it were designed to backwards compatibly replace it/inter-operate with it. (...and then some of those same parts reused in COM's eventual actual replacement.)
This is likely the reason we don't have a 64bit Studio too- just too much of a pain. Their arguments re speed and memory usage have been going on for years while I've gone from 2gb to 256gb and similar speed increases.
Those arguments are becoming irrelevant and headed for laughable.
Enter Win8 debacle and Sinofsky wisely decided he'd do other things.
I have been burnt too many times by MS. So now, the only ms products I use is skype & ms office.
Visual Studio for Mac (aka XS vNext) does now support ASP.NET Core so there is less need for VS Code. The re-brand makes sense (it's not just for Xamarin now). However, Code runs on more platforms (Linux, ARM etc.) and is also used in the browser as part of Azure.
I wrote a better summary of the differences here: https://unop.uk/getting-started-with-c-sharp-and-cross-platf.... It's the last in a four part blog series about .NET on Mac.
Xamarin Studio was built to provide a Visual Studio like experience regarding platform integration and to align with the architecture of Visual Studio. VScode does not appear to have those as the primary goals. It was already available for OSX.
To me, this is further evidence that Microsoft's acquisition of Xamarin was in hopes of accelerating cross platform product development along a roadmap that tends to be more open source friendly. It may turn out that Xamarin Studio provides the core platform for Visual Studio at some time in the future or at least that the code bases merge to a greater degree over time.
It's amazing how the rebranding changes attitudes.
I lost interest already.
I hope that the approach with the VS Mac installer ends up going the way of VS 2017 on Windows. I love the fact that I can choose say ".NET development" in the installer and turn off unneeded packages.
Then you can download just the IDE, the Mono framework, and the Xamarin.Mac or Xamarin.iOS pieces if you want them.
I have it and have installed it,Initial thoughts:
( I use VS Pro every day BTW)
here are some screenshots
-Great first step, I can only see raw code and code behind views
-No visual Layout view yet, but its greyed out in the View Menu, when selecting .aspx File (Source|Changes|Blame|Log|Merge)
-Looks like its so far, meant for lightweight projects
-Git integration is much simpler to setup/use
I'm used to Sublime and when I tried VS Code it felt kind of laggy.
^^ download link
So its just like the 3 versions of Skype that Microsoft offers.
Try a Console workbook for something quite similar to (and in some ways more powerful than) the Visual Studio REPL.
Workbooks go beyond the REPL and can include rich content so that they can be saved and shared. But I use it every day for random REPL tasks that I used to use `csharp` for.
Evaluation is painfully slow, especially when running in the Android context.
Restrictions and missing functionality around importing packages from nuget.
This could really do wonders for Android UI development, I've dreamt of having as tight a feedback loop on Android as I have on the web, and this could one day bring us there. Unfortunately I couldn't find any easy or obvious way to inflate views from xml, and/or supply my own custom activities that I can then manipulate from the workbook.
Would be great to know what your roadmap is for this product...
* On Windows, first evaluation can take a few seconds (and we're working on that), but subsequent evaluations should feel instant. If that's not the case, would love a bug filed so we can explore a bit more. Of course, there is the startup penalty of launching the Android app and potentially an Android emulator, but I assume you're talking about evaluations after the workbook has connected.
* Agreed! Our NuGet functionality needs a lot of work, but our goal is to have it work as easily as it does in the IDE.
* I don't personally know much about Android view XML, but creating new custom Activities or other Java subclasses at runtime is a significant technical challenge. We have a bug  to track it, if you want to subscribe to any updates. This is an unfortunate limitation on Android, for sure.
We don't have a published roadmap at this time, but you can definitely expect to hear more about this tool in the future. We have a pretty frequent release cadence, too.
I'm on a Mac. Tried it scoped to console and evaluations were not instant, but decent. Certainly slower than the Mono REPL. Then tried it scoped to Android and even after everything was warmed up the evaluations were still quite slow. Running against a six-month old build of the Xamarin Android emulator, running a Nexus 4 (Android 4.4) image.
My pleasure and thanks for your efforts!
Not sure why they went that route with the C# REPL, because the F# one prints out results after execution.
* Google joins .NET Foundation as Samsung brings .NET support to Tizen
* Visual Studio for Mac Preview
* Visual Studio 2017 Release Candidate
* Microsoft announces the next version SQL Server for Windows and Linux
* Announcing .NET Core 1.1
* Microsoft Becomes Linux Foundation Platinum Member
* Visual Studio Mobile Center Preview
* Announcing the Fastest ASP.NET Yet, ASP.NET Core 1.1 RTM
(And before you tell me I'm wrong because I can't PROVE it, let me remind you I said I FEEL like we are being astro-turfed.)
The same things tends to happen when there's a Google and Apple conference or event. No astroturfing involved; just HN members watching the keynote and posting things they think the community will find interesting.
Not complaining, it's great to see what Microsoft has been up to summarized in a single day or two, rather than a trickling of news that I might lose over a span of a year. It's a bit spammy, but since they moved to supporting Open Source, the announcements really check a lot of boxes for me.
I genuinely hope Microsoft is really changing. But there is a lot of bad history associated with the company. It takes a long time to change the culture of a company, and a long time to regain user's trust.
Blog posts from MacBU employees that you will find interesting (also their archives around this time):
Strictly speaking wrt this definition, if MPW had 10M users, it would be a runaway success. But nobody cared, even when it became free.
Anyone know why this would be? This runs fine on windows VS
Objective C has not had an official open source release, so far as I know.
ETA: Arguing of course how close the gcc/clang implementations of Objective C may or may not be to the Xcode compilers, of course.
Other than that XIB/Storyboard quirk it seems pretty solid.
EDIT: For me it wasn't worth it. There's something about Java applications that throws me off. I'm not sure if it's the difference interface or the small lag in input or both. (I do use PyCharm since there is no viable alternative in macOS)
I would say almost certainly not.
Good catch! I will request that we add system requirements to out page. I am going to suggest they are added to https://developer.xamarin.com/releases/vs-mac/preview/vs-mac...
Disclosure: I work at Microsoft on Xamarin
[art] Not late-enabling -Xcheck:jni (already on)
[AndroidRuntime] Shutting down VM
[AndroidRuntime] FATAL EXCEPTION: main
[AndroidRuntime] Process: com.greenrobot.testapp, PID: 3218
[AndroidRuntime] java.lang.RuntimeException: Unable to get provider mono.MonoRuntimeProvider: java.lang.RuntimeException: Unable to find application Mono.Android.Platform.ApiLevel_23 or Xamarin.Android.Platform!
[AndroidRuntime] at android.app.ActivityThread.installProvider(ActivityThread.java:5156)
[AndroidRuntime] at android.app.ActivityThread.installContentProviders(ActivityThread.java:4748)
[AndroidRuntime] at android.app.ActivityThread.handleBindApplication(ActivityThread.java:4688)
[AndroidRuntime] at android.app.ActivityThread.-wrap1(ActivityThread.java)
[AndroidRuntime] at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1405)
[AndroidRuntime] at android.os.Handler.dispatchMessage(Handler.java:102)
[AndroidRuntime] at android.os.Looper.loop(Looper.java:148)
[AndroidRuntime] at android.app.ActivityThread.main(ActivityThread.java:5417)
[AndroidRuntime] at java.lang.reflect.Method.invoke(Native Method)
[AndroidRuntime] at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:726)
[AndroidRuntime] at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:616)
[AndroidRuntime] Caused by: java.lang.RuntimeException: Unable to find application Mono.Android.Platform.ApiLevel_23 or Xamarin.Android.Platform!
[AndroidRuntime] at mono.MonoRuntimeProvider.attachInfo(MonoRuntimeProvider.java:38)
[AndroidRuntime] at android.app.ActivityThread.installProvider(ActivityThread.java:5153)
[AndroidRuntime] ... 10 more
[AndroidRuntime] Caused by: android.content.pm.PackageManager$NameNotFoundException: Xamarin.Android.Platform
[AndroidRuntime] at android.app.ApplicationPackageManager.getApplicationInfo(ApplicationPackageManager.java:304)
[AndroidRuntime] at mono.MonoRuntimeProvider.attachInfo(MonoRuntimeProvider.java:32)
[AndroidRuntime] ... 11 more
[Process] Sending signal. PID: 3218 SIG: 9
Email me at email@example.com if you have any questions and don't want to post them publicly.
Just emailed you via our support system :)
And no, MonoDevelop isn't the same thing. I'd like to be able to develop Android apps using Xamarin on Linux, but MonoDevelop provides me no way to even install Xamarin Android.
I downloaded this a bit ago and the install just finished; thus far (<5 minutes invested, admittedly) I'm at a loss as to how I'd even open the Unity project code, much less get the integration setup. Hopefully someone more familiar with VS & Unity on Windows may be able to provide some guidance...
Jetbrains is also working on their C# IDE, hoping it supports Unity soon:
My development Mac is pretty sensitive to the version of mono installed, so I don't want to screw around with it.
Moderator, can you update?