Xamarin Open-Sourced(open.xamarin.com) |
Xamarin Open-Sourced(open.xamarin.com) |
.NET CLR Managed Runtime - https://gitter.im/dotnet/coreclr
.NET Framework - https://gitter.im/dotnet/corefx
.NET Compiler as a Service ("Roslyn") - https://gitter.im/dotnet/roslyn
.NET Orleans Actor Framework - https://gitter.im/dotnet/orleans
Mono Framework - https://gitter.im/mono/mono
Xamarin iOS, Watch, Mac Bindings and Framework - https://gitter.im/xamarin/xamarin-macios
Xamarin Android Bindings and Framework - https://gitter.im/xamarin/xamarin-android
Everything is licensed under the MIT license w/patent pledges.
It's entirely possible you meant your comment for people who already have experience with the source in question, in which case I've misunderstood you.
http://dirkriehle.com/publications/2014-2/the-five-stages-of...
.NET CLR Managed Runtime - https://github.com/dotnet/coreclr
.NET Framework - https://github.com/dotnet/corefx
.NET Compiler as a Service ("Roslyn") - https://github.com/dotnet/roslyn
.NET Orleans Actor Framework - https://github.com/dotnet/orleans
Mono Framework - https://github.com/mono/mono
Xamarin iOS, Watch, Mac Bindings and Framework - https://github.com/xamarin/xamarin-macios
Xamarin Android Bindings and Framework - https://github.com/xamarin/xamarin-android
Before I clicked the link I imagined it to be some sort of annotated source code thing. (imagine the inline code with yellow "sticky notes" applied)
Turns out it's just an IRC type chat client. Still interesting.
The simple platformer has one source, but you should be able to compile it with Mono on Linux/OSX/Win or with Visual studio after you do the setup.
With Xamarin in the mix, your build targets can include Android and iOS.
Most of the time when I built with mono on linux, I was able to run the binary on windows, but I was creating smallish projects so far, so I don't know how well that works for larger projects.
But with libraries, there are often built in such way, that you have shared interface, that will be usable no matter the target and during compilation the correct platform version would be linked, but my memory is kind-of hazy on the details.
[1] https://github.com/MonoGame/MonoGame.Samples/tree/develop/Pl...
And links that contains no source code! A chat room with a broken image!
To truly support Open Source, they should show a willingness to work against Software Patents. The essence of Open Source is the freedom for anyone with a computer to turn their imagination into code. MS remains one of the biggest obstacles in that path.
Instead here is what they do:
1) Directly attack the Linux kernel in Android through patents
2) Sell patents to trolls like Intellectual Ventures, and directly fund them via investments
3) Support the cartel called BSA, which includes other luminaries like Oracle (http://www.bsa.org/about-bsa/bsa-members).
Honestly, say what you will about Google, but I can't imagine them ever threatening another software company with software patents.
Second thought: Every time I looked into Xamarin (and I do this every 6 months) there was a lack of killer apps created with Xamarin on both iOS and Android, users' experiences with Xamarin were either rare or negative and in total the community felt non-existent
Third thought: Ok got it, they open source to get PR, build a community; I hope that helps and it's not their last resort
So, is Xamarin really a viable solution?
'dotnet build' to build it.
but it isn't actually "out" yet (you can get your hands on it but it will be buggy)
still, will be 100% fantastic.
Forge is also worth checking out:
https://github.com/fsprojects/Forge/blob/master/README.md
One more suggestion, if you'd like an easy (but simple) all-in-one solution for F#, check out Ionide:
`mono` to run it, rough equivalent of java.
We code for the Unity game engine, but use command line mono tools for testing and feature development.
Meanwhile, Google has switched away from their Apache Harmony derivative to the officially anointed sources, so there's not much incentive to make the move away from Java entirely, anyway.
EDIT: It wasn't in the AMA after all, but it has been dropped:
Last time I used it (more than a year ago) it was still felt quite buggy. That being said, has anyone successfully used Xamarin or have an example of a large and successful app built with it?
Edit: I wonder if the Xamarin.Android developers ever considered compiling CIL to JVM bytecode (which would then be compiled to Dex bytecode), then reimplementing mscorlib on top of the Java standard libraries. So basically, IKVM.NET in reverse. Then there'd be no bridging between two environments.
With Android the most common mistake is cross-heap references, putting a large C# array into a java arrayadapter for example will result in objects that live in both worlds which makes it expensive for Java to see the C# object and C# to see the Java object. The objects are effectively being mirrored, the solution is to use C# all the way down. Where the object was created defines ownership, for example ArrayAdapter containing C# objects means owned by Java with overhead for Java to bridge the C# objects.
"For Unity developers, this means making sure the latest .NET APIs, tools, and language features are available to you."
– Support for C# 6
– Upgrade Mono Runtime and Class Libraries
etc...
So this is also partly just giving back from where they took it.
Is everything needed to actually be able to use it productively open source now?
Is Xamarin Studio open source?
For more details, you can listen to this podcast from founders of Xamarin - http://www.dotnetrocks.com/?show=1276
"Everyone Can Create Beautiful Apps with Material Design"
When the team I'm on open sourced an upgrade framework[1] of ours we did the same. There's hundreds of commits over the course of years where the only intended audience was internal, some of those may contain information that wouldn't be appropriate for external consumption (e.g. a reference to non-public information) and others (well most of them really) contain information that would be useless externally (e.g. links to builds or reviews that are accessible only internally, bug numbers, etc).
Very likely.
That is a naive fanboy outlook towards a company. Its a well known fact that Google bought Motorola only for the patents. Google has also managed to use the patents to sue other companies including Microsoft. Although I still believe it is the game that is flawed and not the players. Google has also done things that could hold back the Windows Phone ecosystem. However, none of that should discount how much Google has contributed to betterment of the web just like Facebook or Microsoft. Open-Source is open source, the only thing that matters is license here and it is as liberal as it could get MIT.
> Google has also managed to use the patents to sue other companies including Microsoft.
Can you post a link to Google suing Microsoft first (not in retaliation)? Google was way behind in the patent game until they got hurt. Google bought Motorola to have a defensive patent portfolio. Also, see their Open Patent Non-Assertion Pledge https://www.google.com/patents/opnpledge/
> Open-Source is open source, the only thing that matters is license here and it is as liberal as it could get MIT.
Open Source is where it is today from the decades of hard work by many, many people (in the early days, just for the love of it with no pay). MS is doing Open Source today because it really has no choice. There is no comparison between these two.
Open Source can welcome MS, but it should demonstrate a willingness to work towards the best interests of the movement. There are bigger goals here.
https://en.wikipedia.org/wiki/Smartphone_patent_wars
It's all Apple and Microsoft, and then Samsung started firing shots at Apple in retaliation. Google has never gone offensive with a patent suit.
Last time I checked Microsoft was still threatening Android OEM's with their prior art ridden / pile of junk patents (M-CAM analysis). I don't believe Google has ever used patents for offensive purposes, but Microsoft continues to collect quite a bit of money from shaking down Android OEM's.
Really? Which suits were that?
Google has never sued another company over patents. They've made counterclaims when themselves sued, but claiming otherwise is just a fiction.
And they bought Motorola because Motorola was threatening to start suing all of the other Android makers, causing infighting that Google didn't want. So Google bought Motorola....to stop those patents from being used to sue, further diminishing your point.
On the whole, Google is very much the good guys, and Microsoft are very much the bad guys.
However I will say it is naive to assume this will continue forever. There was a period where Microsoft seldom threatened anyone, and we all held quaint notions about all of their "defensive" patents. Situations and markets change, and suddenly desperation takes foot and the company that was hugs and kisses becomes claws and kicks, so I would never assume that Google will always be a fairly good citizen. It could change.
No one is taking away your right to hate Microsoft, but picking OSS as bull-work of your argument is not there any more.
edit: bull-work(tm)
He is not pretending to be an arbiter but speaking generally to what many people, including myself, believe. And in any case, you attempted to refute what you reduced down to his own subjective opinion, with your own subjective opinion.
Working against software patents is part of the larger essence of OSS, and it was just a specific example of it. If you are for software patents, and somehow magically "for" open source, then you aren't really "Open Source" you are just hiding behind that facade so you can now accept free labor when it serves your purposes.
So, in that regard, it isn't difficult to see where the negative sentiment is coming from in regard's to the recent media blast of the "new Microsoft."
Okay...but this isn't one nor is it really an "article". It's simply the page about Xamarin being opened source. That's it. It's MIT licensed and opened sourced.
Did you not read the page or did you just want to rant about the same things people complain about with Microsoft in almost every HN thread about their open source efforts? I'm not saying some of these are not issues but when they're unrelated and don't add anything to the context of the content I don't get the point.
The issue is the length of patents, the Software industry doesn't need 20 year-long patents, it's too much time, at most a patent should be valid for 5 years...
And well, we also need mechanisms to punish people who abuse the patent system with dull patents.
I'm guessing you mean overly broad or generic patents, i.e., not sharp and specific. I'm thinking something like a patent for adding an item to a virtual shopping cart. Am I inferring correctly?
Patents should only be applicable if the company can show it's actually working in a domain that will apply this patent.
With rules like this, patent trolls would cease to exist and software patents would go back to being extremely useful to software innovation, like they were designed to be.
See: http://www.cnet.com/news/google-microsoft-settle-long-runnin...
It is very hard for large software companies to unilaterally work against software patents because it puts them at a competitive disadvantage, at least temporarily. It's sort of like arms limitation talks where you can't put down your nukes before anyone else does or it's an open invitation to attack.
It's not that: Microsoft acquired Xamarin earlier this year [1].
Xamarin is also holding a conference [2] right now, so I suspect this announcement is part of that.
Edit: Yes, it was. [3]
[1] https://news.ycombinator.com/item?id=11169215
[2] https://evolve.xamarin.com/live
[3] https://adtmag.com/articles/2016/04/27/xamarin-evolve-16.asp...
Xamarin and Unity don't have anything in common, other than the fact that Unity uses C# for scripting (on an ancient runtime).
Cross-platform app development frameworks are generally awful because they don't tightly integrate with the native look and feel of every platform. Video games don't even try to achieve native looks on any platforms. They're always full screen works of art, without any hint of a UIButton (iOS) or TextView (Android).
To their actual comment, it is extraordinarily difficult to make a quality product with Xamarin. As they said, there are shockingly few wins built with it. There are loads and loads of teams using it, all sure that it's the short cut that will build for everything with one code base, but so few wins.
React native has a LOT of attention. It has a lot of support. BUT as of this writing if you are developing in corporate IT (meaning possibly running windows 7 systems) you actually CANNOT run react-native tools on windows easily.
I'm currently building an ionic project because I needed a cross-plat mobile app and work with a mix of OSX and windows 7 machines.
Now that said, windows 10 systems with the ubuntu emulator should be able to emulate all the calls you need to run react native on windows machines.
HOWEVER windows 10 bash has not yet implemented all 350 linux system calls (https://wpdev.uservoice.com/forums/266908-command-prompt-con...) and there is no guarantee that is bug free.
I'd hate to be 2 months into development to find there are deep internals that block me from using a critical feature.
None of this is to say Xamarin doesn't have its own baggage. The reason I web with cordova/ionic was for the good of the other developers on my team (html+css+javascript over C#) and, at the time, the additional cost of the Xamarin licenses.
I would have given XAMARIN a much closer look if it were bundled with a Visual Studio license, and all things considered, if I were looking today, it might beat out React Native.
That said, I do agree that react-native MAY be the way forward in the next generation, but, Xamarin does have more than enough upside to make it a reasonable contender.
1) The documentation seems good at first, but some parts are outdated and I did find myself stuck with it a number of times. iOS and Android docs are lightyears ahead.
2) The code editor in Xamarin Studio for OSX is mediocre. I've tried using VSCode instead but intellisense didn't work. I imagine using Visual Studio must be a lot better. Both Xcode and Android Studio are much better in my experience. Maybe with the upcoming C# IDE from JetBrain this will change.
3) You need to learn iOS/Android development anyway. Xamarin Forms works well for prototypes and such but in the end you need platform specific UIs and libraries. So you need to do the leg work in the native docs (Swift/Java) and understand how these APIs/languages work and be able to "translate" those to C#. It's double the work compared to writing directly in native code.
4) The community around Xamarin is minuscule. If you get stuck there isn't much material out there to help you compared to native iOS or Android. Also in my short experience their forums were not very helpful. I imagine with an expensive corporate account with dedicated support that must be very different, but for a solo developer it feels like you are on your own.
As much as I like C# as a language I really don't see the point of Xamarin in my case. I started learning Java/Android form scratch and I'm having better results in less time. I will have to work more to get both iOS and Android, but I won't feel miserable and the dev experience in OSX will be awesome with first class tools.
I'd say Xamarin would be perfect for someone that already knows how to develop for iOS and Android but hates working with Swift and/or Java, loves C#, and has access to Visual Studio in Windows.
There's a list with some more companies here: https://www.xamarin.com/customers
It's me not Vala. I enjoyed proper tooling: SCM (e.g.: maven), test automation (unit-test framework), some form of IDE.
The biggest hurdle has been dependencies, but support has been improving a lot every month. Getting deployed was initially a pain, but I've found a way to make it smooth. I think soon i'll be writing up how I deal with it. I deploy about 3 times a day without interruption on my single server behind an nginix reverse proxy.
There are some really cool things coming forward in the land of dotnet.core.
Specifically you can now build projects on linux machines. Command line and web are basically a "no brainer" already (even with RC1 and RC-here-be-dragons).
For anyone seriously considering linux desktop apps, the'll want to consider some sort of cross-plat gui library, but there are a number of threads discussing it over at the dotnet foundation and some of the suggestions there seem like real "contenders"
http://forums.dotnetfoundation.org/t/cross-platform-wpf/421
http://forums.dotnetfoundation.org/t/cross-platform-gui/514
(for example this one looked neat) http://www.noesisengine.com/
When you're looking at C# vs. Java, I wouldn't be surprised if you found the new openness of dotnetcore to chip away at some of the "base" of Java. Maybe you start to see C# as the goto choice for CompSci classes.
Maybe the face-melting performance benchmarks http://web.ageofascent.com/asp-net-core-exeeds-1-15-million-... (1.15 million requests per second vs. ~150k in nodejs and vs. 50k in .NET46) will have an impact on people interested in lowering their server costs.
We certainly saw NODEJS was adopted rapidly thanks to its performance in 2012 http://highscalability.com/blog/2012/10/4/linkedin-moved-fro...
and paypal followed suit in 2013 http://highscalability.com/blog/2013/12/11/using-nodejs-payp...
C# under dotnet core, when written correctly has the potential to lower latency, require fewer servers, and all sorts of fun stuff.
Fewer servers means lower costs, while lower latency has proven to convert into more users or sales.
Of course, this is all best-case, pollyanna & coming from a bit of a fanboy... so please take what I say with a tiny grain of salt, but I do think this is pretty exciting stuff.
To be fair, I'm so excited about this stuff I'd kindof like for someone to take me down a peg and push a bunch of counter points at me so I get a more balanced and realistic opinion (just be nice OK?).
The best option you're likely to get is to build on top of the older open-source RoboVM release:
The usual M4 headaches with autotools apply, but as long as you don't have some crazy build (just compiling libraries/binaries, linking with libraries, use pkg-config) it's not too bad.
As far as testing, GLib.Test [0] is part of the standard library. Since vala compiles to C at the end of the day there's no easy way to test other than just building a test runner, but it's not too bad to work with.
GNOME Builder is finally getting support for Vala in GNOME 3.20, it's still young but hopefully we'll have a first class IDE soon. Still, Builder has a long way to go before it even catches up with MonoDevelop, but progress is good, right?
If there were something like Gitter that showed README.md and the chat room and not the code, then yeah, that's probably a better home page.
Props for how you dealt with negative feedback in this thread, and this positive re-frame.
He's not dodging the question at all, he answered it directly. He obviously likes gitter and chatting with others.
The .NET community was, until recently, decidedly not-open-source, so the learning workflow of "open the repo, read the readme, browse the code" might be a new thing for them.
Perhaps it's not a bad idea for widening the community ( linking to gitter). I'm actually wondering if they ever used jabber, a not-well-known community for chatting about .net
You or I may not fully agree, but this is subjective. And it's an answer, even if it might not satisfy you!
The MSBuild logic, at least for Xamarin.Mac and Xamarin.iOS has been made completely open source, so all the logic to build your apps + the SDKs are all open source.
Microsoft has not open sourced Visual studio (VS) so similarly they will not open source Xamarin. You can also use .net framework without using VS. Just use command line tools
how so?
The first mistake was screwing Sun during their license agreement discussions for Android.
I'm not sure how much of that Google could directly benefit from but they could have definitely gain a metric fkton of community good will by opening many of the technologies Sun owned that have floundered since the Oracle acquisition.
"controls are mapped to platform-specific native user interface elements; for example, a Xamarin.Forms Entry becomes a UITextView on iOS, an EditText on Android, and a TextBox on Windows."
How does it abstract away the more fundamental differences between platforms Activities/Fragments vs. UIViewControllers?
For some things it's about the common talk-to-the-backend code, not true-code-once across iOS/Android...
Also, it seems you have no idea what you're talking about. Xamarin gives you access to the same native APIs that you use when developing a native app. You still need to know the native API if you want to build an iOS app. Xamarin.Forms helps, but doesn't support everything.
It is perfectly fine for some relatively simple things. Basic information apps, etc. But it isn't long in complex apps before the abstraction is leaking all over the place, and you find yourself fighting the tooling rather than leveraging the tooling. Which has been the case for virtually every similar "all platforms one tool" type solutions.
It worked between Mac and Windows on very complicated apps. It bridged Linux and Windows for tweaky MVC stacks a decade ago (then they wisely sharpened their focus.) It got the job done pumping data through hardcore game engines. The network stack is proven robust. You're talking about it like it's some stupid ORM wrapper or wonky Widget UI library. It is not.
BTW Xamarin Forms has or is about to receive a bunch of updates, perhaps it's worthwhile checking them out in case things have improved for you?
It's not just publicly accessible, it's MIT licensed with a patent grant. You could take the code, modify it in literally any way you want, wrap it in a commercial product and resell it. It doesn't come more free or open source without actually being public domain.
What you're asking for appears to be some sort of 'super open source' where not only are free to view, modify, and distribute your code, but also have to a right to have your code merged into the mainline of the code. What you're asking for goes well beyond the four freedoms.[0]
It's FOSS.
That's not true; we use the same code.
The PATENTS.txt file seems to suggest otherwise, you must stay within the bounds of "covered code". IANAL so I do not know what the side effects of this seemingly intersection of their patent/license coverage curtails, but it does seem like you lose protection and could have a Android/Oracle situation if you innovate something on top of the core CLR outside of the 'covered' bounds and then decided to sell it.
There's a slightly older writeup about it here http://endsoftpatents.org/2014/11/ms-net/
In any case, as the name suggests, it's only a promise, not a guarantee of rights.
I went to the repo. The "homepage" includes the readme, which includes enough detail and code examples that I'm all set as far as knowing what Orlean's is "about".
I'm not sure what kind of toxic communities and work environments you are apart of, but if a newbie to the community can't ask questions, that's not a community that will survive or flourish in the long run.
Our definitions of toxic obviously differ a bit. I wouldn't flame anyone but (in a non paid setting of course, paying customers have the right to be wrong) I would tell them (politely) that we were there to help them when stuck, not to pull them up to speed.
Before reading this I wouldn't have believed anybody would seriously suggest that.
As others have pointed out going straight to the chat without even trying to read up on the docs first comes off as extremely entitled and lazy.
I'm maybe to hesitant, I wont bother anyone before I've read the relevant docs twice, possibly also looked quickly into the source.
Perhaps this is my impostor syndrome talking, but I for one would be hesitant to tempt the wrath of the Great Unseen Masters that make open source software with potentially inane questions.
Read the code, try your best to understand it, and then get the documentation reviewed by someone who does know the software well. This works for code, too. Bonus points: Explicitly enlist feedback ("Anything I'm missing here? Any edge cases I forgot to note? Is my understanding of this correct?")
> I for one would be hesitant to tempt the wrath of the Great Unseen Masters that make open source software with potentially inane questions.
http://www.catb.org/esr/faqs/smart-questions.html
But if you're making an effort to contribute, that already counts for a lot. There might be some gruff redirection towards more effective means of contributing, if you're being a significant time sink and not helping that much, but hopefully that's a win/win in the end.
Eh? I use React Native on Windows. Works just fine. It's also very easy to install. Maybe you didn't try recently?
But my point was that for any community to survive, it should be welcoming to newbies and have an environment where people shouldn't be afraid to ask questions, even if they are "dumb" by some arbitrary metric. It's also a good way to convince someone of using your particular framework, programming language, etc.
A newbie may ask why should I use X, and if experienced veterans of the community give set Y reasons to use it, I feel that's way more convincing than "RTFM scrub". It's way less elitist too.
From a FOSS pov, both Google and Microsoft have positive and negative sides to it. They're massive companies, you can't judge them as one giant blob.
What MS is doing right now with .NET is fantastic for open source. Just like what Google is doing right now with Hangouts is frankly bullshit. Judge actions, not entities.
Apple, Microsoft, Oracle, and many other companies are known aggressors who use software patents as weapons of war to destroy competition and extort other companies. Google has consistently refused to participate in such immoral behavior without first being attacked by similarly sized companies.
And that's a good thing. It shows the strength of open source.
MS is a company. Just as Google. Companies will "work towards the best interests of the movement" as long as those interests converge with theirs: make money.
AFAIK large portions of Google's core business are closed source. They are not in open source for love.
Corporations aren't people where past behaviour predicts future behaviour. If MS's original executives are all gone, the fact that MS is behaving differently isn't surprising at all.
> eliminating the competition and making their products the only option available in the market.
This is business and this is how you win.
http://patentlyo.com/patent/2015/08/agreement-microsoft-moto...
https://en.wikipedia.org/wiki/Microsoft_Corp._v._Motorola_In....
Sure, the lawsuit was started 2 months before Google acquired Motorola, and it was in response to an MS lawsuit, but the continued abuse of FRAND patents and the ensuing 14M penalty happened on Google's watch. Literally no other company in the smartphone wars suffered this fate.
http://patentlyo.com/patent/2015/08/agreement-microsoft-moto...
Is it possible that since the superiority of the open source model in several places is so obvious (i.e. when the code itself contains no secret sauce) this political narrative of whose development model is better is no longer pertinent?
I would say privacy is partly a different arena altogether, as well are software patents.
My head is too small to fit all of this into a coherent view. All I see is a delightful and shiny MIT license.
I have heard other developers call them parasites and energy vampires.
Please do not recommend this.
On top of that, it's inefficient. I want a couple of paragraphs telling me what the project is about, not a conversation.
I think I could streamline that process a bit.
Again, this conversation is about Xamarin the mobile app studio. There is zero ambiguity in this, so it is perplexing that you keep bringing this up.
The context is the cross-platform app creation toolset. It generates extremely poor quality code, usually at a significantly increased development time (quite contrary to the promise). This is the case found by almost everyone who uses it, which is exactly why most teams have an Android project, fully using the tools of the platform, and an iOS project, fully using the tools of the platform. If Xamarin were heavily used, Windows Phone wouldn't be so generally unsupported.
There is a language: C#. There are bindings to native toolkits. There's yet another imperfect Forms package. And there's a slightly wonky IDE. I'm not sure what you're expecting but I think the "lossy abstraction" here is mostly your expectations. I also think you are applying your narrow experience (which obviously was not a great one) and trying to amplify it by using unsubstantiated statements like "most teams" and "few wins."
...when there's a magic solution that covers them all. Surely such a solution would completely take over the industry, right?
Crickets.
Extremely few successful solutions are built in Xamarin. Their case studies are limited, and are generally close to trivial apps. And when you point this out, Xamarin advocates tell you not to use most of the cross platform stuff, but instead use platform specific code that is layered on abstractions from the underlying tech, always a step behind and a mile too far.
I'm not amplifying anything: The market demonstrates every statement. Xamarin is something that floundering teams buy hoping it gives them a big heads up, and then some time down the path they just end up starting separate projects for each platform.
You obviously are heavily biased, and strangely confrontational, towards Xamarin. But this open sourcing has been met with a universal yawn.
Best case -- terrible abstraction. Worst case -- you're rewriting much of your code for each platform, working on a 3rd party incomplete abstraction that is always behind and full of unnecessary layered surprises.
What a win!
And for the next bizarre Xamarin sponsor that decides to wallow in and throw up this -- I worked on a large scale solution with Xamarin. We threw it out and just went with separate projects for each platform, sharing code with C++. Works wonders. Way better than Xamarin.
> "this open sourcing has been met with a universal yawn"
It happened 18 hours ago! Do you think the kinds of companies that code in C# even noticed yet?
Xamarin is a company, not a product
Xamarin the company has a primary anchor product that is a tooling and SDK to build cross platform apps (indeed, on Xamarin.com it is literally the only non-service product. There is zero ambiguity). To anyone not autistic, that is clearly the focus on this entire discussion. Your bizarre incantation of Unity using a very old version of Mono as a citation in support of Xamarin set the bar pretty low for this conversation.
It happened 18 hours ago!
Microsoft made it completely free. Yawn.. Microsoft open sources the entire SDK. Yawn.
Clearly you work either for Microsoft, or you hitched your wagon entirely to Xamarin or Microsoft. Your emotions on this are bizarre and completely out of touch with the reality.
> Microsoft made it completely free. Yawn.. Microsoft open sources the entire SDK. Yawn.
After your nap, click the "All Products" link. You'll see other products -- and 26 pages of components.
Give it up. Your initial comment about Mono was ridiculous and grotesquely out of context, and you've just continued this bizarre obnoxiously.
And the most ridiculous part of all is that this very submission, and Xamarin's own terminology, calls their app development stack "Xamarin".
No one is confused but you.
The Products menu has a fifth menu item, All Products. It will show you additional products.
Apparently you are not familiar with the (bumpy!) history of Xamarin's technology. Now that it's open source, you can actually trace lines of code from Xamarin Platform and Xamarin Forms and the Xamarin Profiler back to the early Mono and Unity days. They were a small team that bit off way more than they can chew, delivered more than seems possible even today, and gradually tightened their focus to mobile.
Now they are open source and have Microsoft fully behind them. I wasted a ton of time and money and performance running under Mono on Linux when I should've just used Windows server. But I got it back using Xamarin Platform on two recent large-scale mobile development efforts.
You win some, you lose some, and eventually you develop the maturity not to claim an entire industry had the same exact failures you did to make yourself feel better. Good luck.