May 9, 2018 - Undefined symbols for architecture arm64: '_OBJC_CLASS_$_CPTAnimationDelegate', referenced from: objc-class-ref in registrar.o.
If I had to really take a guess here, this is what I'd speculate. 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. I agree, but would add that I think their core motivation is to drive developers to microsoft azure. I am sure they believe they would love mac users to buy more MS software but targeting non-ms devs this hard seems like they want to compete with AWS && google. 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.
COM is the Component Object Model: 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. 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. Well it is just plain old COM, with a new base interface IIspectable that inherits from IUnknown and using.NET metadata instead of TLB files. 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.NET binaries can export COM components (just as C/C and other languages may), but are not COM components by themselves. 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.). Glad you asked! One of my favorite topics.;) COM is essentially a formal way of using C vtables 1 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 2. 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 4 method is essentially like C's dynamiccast 5. But it also adds some object aggregation features 6 that let you compose multiple sub-objects together by aggregation instead of using monolithic inheritance.
You could implement 'tear off interfaces' 7 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) 8, 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 9: 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' 10: 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 11 interfaces (for in-process and networked remote procedure calls), parameter marshalling 12, 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 13 (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) 13, their COM-like plug-in extension mechanism for Director and other products. And Mozilla came up with XP/COM 14, for implementing components in Mozilla/Firefox/XULRunner/etc, enabling programmers to implement and consume XP/COM components in C or JavaScript.
Of course it has its own IDL and tooling, and suffers from many of the same problems that COM did. 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 15. At this point in history, I think it's best to skip the 'component technology' middleman and integrate extensions directly into the JavaScript engine itself. Which brings us back to the sub-topic of VSCode!
1 Virtual Method Table: 2 VBX: 3 Variant Type: 4 IUnknown::QueryInterface: 5 dynamiccast: 6 Aggregation: 7 Tear Off Interface: 8 ActiveX Template Library: 9 Variant Types: 11 Distributed COM: 12 Marshalling: 13 Macromedia Open Architecture (MOA): 14 XP/COM: 15 deCOMtamination. Xamarin Studio didn't support.NET Core, so previously you had to use the CLI tools and an editor like VS Code.
You could run ASP.NET MVC in XS (version 5, Core is effectively version 6) but this ran on Mono. 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:. It's the last in a four part blog series about.NET on Mac. My intuition is that VScode and Visual Studio are likely to remain significantly different products for the foreseeable future. VScode is an Electron app. Visual Studio is more a 'native' app with deeper integration into the host operating system. 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. Wow, I did not know about this.
I just spent 30 minutes playing with it and am intrigued and hope this will reach its full potential, then it could be something rather special. For now though. 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. Thanks for playing with it! You cheated and went outside the scope of the VS REPL though.:-P.
![Visual studio Visual studio](/uploads/1/2/5/4/125445271/265623088.png)
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. 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 0 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 kind of feel like we are being astro-turfed by Microsoft. 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.). It's only happening because Microsoft's Connect conference started today.
A lot of new and updated things were announced during the keynote, and stories about them showed up here on HN shortly afterward. Since Connect is Microsoft's developer conference, a lot of things announced there tend to end up on HN. 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.
I gave AppCode a small spin recently. It worked pretty well — as I've come to expect from JetBrains. It builds and launches apps directly into your device or simulator (presumably using the command line tools of Xcode).
There is, however, no integrated Interface Builder, when you want to edit a XIB or Storyboard, it launches Xcode and you do the editing there. 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). Sure here are the logs: 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.ApiLevel23 or Xamarin.Android.Platform!
Is my number one question as well, as I use Unity/MonoDevelop combo all day every day. And, as much as Mono crashes on Mac, it's still a pretty darn solid IDE overall, especially coming from bare-bones tools like Sublime & TextMate.
I downloaded this a bit ago and the install just finished; thus far (.