Announcement

Collapse
No announcement yet.

MonoDevelop vs. Xamarin Studio IDEs

Collapse
X
  • Filter
  • Time
  • Show
Clear All
new posts

  • Originally posted by brosis View Post
    (...)
    When I "discovered" Mono, I found a crapload of dlls and exe in my system, weighting more than 300MiB and being much slower even than Python.
    I gladly associate myself with cautious and aware people, who remove the crap known to cause dangers to freedom, without even arguing or going into compromises.
    (...)
    So, I have the latest Ubuntu and a lot of Mono software. My footprint on disk is 162 MB. This includes the software we discuss like MonoDevelop, with a lot of things that most users don't use. So your numbers are B/S. In comparison, I have installed just QtCreator (that I do sometimes simple programs with it). QtCreator and Qt dependencies (so no other Qt packages on my machine): 345 MB. So arguing in disk space, I would argue that removing Qt is a better bussiness.

    But let's say it will be 300 MB (not Mono Runtime which is in some few MB). Would it matter that much?

    The second part of your B/S: May you say a case where Python is faster than Mono? How you measure this performance? I can make a program to show that signals and slots (C++) are much slower than delegate calls in C#, because I understand how QMake and MOC works and how in C# a delegate is basically a pointer that is checked for null and after that a direct call is made, when in Qt the signals/slots have a richer semantic so they have to be checked and they are tens of times slower than a virtual call (the Qt documentation specify that can be a bottleneck in performance!).

    I understand that even than Qt has a slower signals/slots call speed, is a bit faster than Mono because it has a bit better optimizer, and it doesn't check array bounds checking (which some are optimized by Mono runtime) but this is another talk. But slower than an interpreter?

    Comment


    • Originally posted by ciplogic View Post
      So Mono does not run (well) on Windows, so as long as Mono exists, seems that if Mono exists, the platforms that it support they are good as targets. You can write COM+ code (like WinRT code) that is Windows only and is C++, and you can write very portable C# code (like Pinta project). Also, Microsoft makes sure that Linux interoperates well with Windows HyperV virtualization.

      As for the sites that work with the latest Ubuntu and Moonlight: look for a MVC3 Pluralsight tutorials: they work flawlessly on Moonlight! And you can learn parts that Qt does not support: customizable http views with MVC3/Razor, DB persistence with Entity which the last Mono does support! Try it: http://pluralsight.com/training/Cour...net-mvc3-intro
      Thanks for the information, regretfully the web-sites my family would be interested in still does not work (for various reasons). I am very impressed by the progress of Mono and how much of .net is now supposedly supported, but I cannot escape the fear that Mono is doomed to playing eternal catch-up. In any case, as I said, I am very grateful to every Mono developer that provides this framework on linux with their best intentions. Xamarin on the other hand needs to be guided, fast.

      Silverlight is just about dead anyway, even the DRM lock-in seems to be falling into pieces these days with Netflix full support on Android. It still keeps Netflix away from me and my family mind you, and it is one of the services I was hinting at. In any case, five years from now chances are that Silverlight is dead and burried, at least that seems to be the direction of Microsoft on the subject after the Windows Phone 7 failure.

      HyperV is another example of Microsoft coming late to the party. I am pretty sure their linux support is only a consequence of them trying to be relevant for virtualization. Look around you, just about any relevant tech company the last decade is built on linux. The financial sector turned their back to windows after the London Stock Exchange fiasco. Without support for linux, HyperV would be dead on arrival.

      Comment


      • Originally posted by Del_ View Post
        This has nothing to do with religion, please do not bring the discussion down to that mud-throwing level. For me it is pragmatic, my life is too short to risk it on a framework designed to lock customers into Windows. I have no doubt mono developers see it differently, and I respect that. Steve Ballmer has been very vocal on this point. Microsoft sees any line of code written for another platform as a loss. As such it is very healthy to keep skepticism of the new Microsoft, which still has it's old management. Do you think an old dog learns new tricks?
        Pragmatism would be using the right tool for the job no?

        How does using a framework equates to risking one's life?

        If Mono was designed to lock customers into windows, then Mono would only support Windows don't you think?

        Just because Steve Ballmer sees it that way does not mean that is the way it is. Steve Ballmer has been known to be wrong about many things.

        Let me give a little background info on where I'm coming from. At the company I currently work for, my job is to implement solutions based on the clients needs. I use various technologies to do this without discriminating against any technology because of the company from which it originated. For clients that are heavily invested in the windows ecosystem, I usually end up using C#/.NET, MSSQL, C++, C etc...

        For other clients I use C++/Qt, Java, C#/Mono, C++, Ruby, PHP, MySQL, PostgreSQL and anything else that fits for the current project.

        I do not tell clients to migrate from C# to Python or from C# to Java because C# originated at Microsoft.

        I once encouraged and convinced a client to implement PostgreSQL instead of Oracle DB because PostgreSQL was sufficient for the project and they would circumvent the large licensing cost from Oracle.

        I view these technologies as tools. Different tools are better at different tasks. I would not try to use a flat headed screw driver to drive a phillips screw while I have a phillips screw driver available just because the phillips screw driver was made by a particular company that I may not like. The flat headed screw driver may work but it is not as efficient at driving phillips screws as a phillips screw driver is.

        That is pragmatism.

        At work I use both Linux and Windows, which one depends on the task I am performing. I have no Qualms about using Mono. Sure Microsoft may decide one day to go thermonuclear and Xamarin/Mono... On the other end, they may not. That is not something I will sit and worry about. Let Xamarin worry about that. In the same sense, I may die in a car accident any day while I'm on the road, that does mean I try to avoid using public roads or motor vehicles. The house I live in may collapse on me while I sleep because of an earthquake in the night, that does not mean I will sleep outside in an open area to avoid that. For similar reasons, I will not avoid tools and products from certain companies because they may turn "Evil" on day.

        Comment


        • Originally posted by Del_ View Post
          You should probably inform the idiots at Google about your discovery. Why on earth did they choose Java for Android?
          I would love to know this too actually, because the rationale I've heard in various quotes from the recent trial and such lead me to think it was a purely political decision made by Java developers. It's sounded like one of their requirements was that it had to be a managed language but why Java over C# in that case? I don't know, the statements don't really explain beyond that. Personally I probably would have done it in C++ and Qt, but I can understand wanting a managed language. Of course then they could have thrown their weight behind C# and Qyoto.

          Originally posted by Del_ View Post
          Keep in mind that Microsoft has put its full financial muscles behind pushing .Net on the world. Microsoft saw attracting developers as absolutely critical for the success of their ecosystem. The really astonishing part is that regardless of this technologies like Qt surfaced from underdogs to level the playing ground.
          Yep they've definitely been pushing .NET, however them pushing that is better for both us and them. Why do I say that? Well because it gets people off of win32 and moves them onto a largely open spec. Yes developers can still target win32 under .NET, but part of the point to my understanding is for them to not do that. Which is better for us as it allows better portability

          Originally posted by Del_ View Post
          That is not true. They ported Silverlight to Mac, and then due to existence of Moonlight marketed it as cross-platform. I have yet to find a web-site where moonlight works. This part of the history makes me furious (not furious with any moonlight developers mind you), as you see, I use GNU/Linux exclusively, and it shut me and my family out of a number of relevant web-services. You have dual-boot maybe since you are so casual on the subject?
          Well I don't use Netflix (Hulu fills the role nicely enough), and I haven't encountered sites that use silverlight beyond that so while I can understand you having issues with it, it hasn't really effected me. That said I do dual boot but that's only ever for games, although I've been thinking some about using visual studio 2012 express under windows, but to be clear everything but games that don't work properly under WINE (and potentially in the future a level of .net development), I use linux for.

          Comment


          • Originally posted by jayrulez View Post
            Pragmatism would be using the right tool for the job no?
            If you have a long term perspective, it makes sense to assess risk. I always make a thourough check before basing any development on an open project. Dependencies makes you vulnerable. Simply repeating "right tool for the job" is naive. You may be a young man, I am not that old myself yet, but have already experienced spending a couple of years on a proprietary software that was snapped away from under my nose. I have actually had it happen more than once. I have fairly strong reasons for being careful about what technology I put my bets on, and it is very pragmatic. I did of course not mean that I risked my life literally, the risk is years of work lost on a dead end, I thought that was clear.
            If Mono was designed to lock customers into windows, then Mono would only support Windows don't you think?
            Mono was designed to give the likes of me access to Microsoft technology on a free platform, or so was stated by Miguel (and I see no reason to doubt the initial motivation). What motivation drives Mono today is a bit of a mystery to me, maybe you can shed some light on that? C# and .net on the other hand..
            That is pragmatism.
            I would call it earning your paycheck. Not sure what more to put into it.
            At work I use both Linux and Windows,
            Me too. The only reason is Microsoft's success in continued lock-in. It has created rather large obstacles for me for a decade, and I see no improvement in sight. I much rather prefer a clean linux environment.
            Last edited by Del_; 02-24-2013, 06:49 PM.

            Comment


            • Originally posted by Del_ View Post
              Thanks for the information, regretfully the web-sites my family would be interested in still does not work (for various reasons). I am very impressed by the progress of Mono and how much of .net is now supposedly supported, but I cannot escape the fear that Mono is doomed to playing eternal catch-up. In any case, as I said, I am very grateful to every Mono developer that provides this framework on linux with their best intentions. Xamarin on the other hand needs to be guided, fast.(...)
              It is hard to say why Mono is in catchup? In which way? To support the latest and greatest .Net runtime?

              First of all Mono (as GCC for that matter) has a common core with .Net, and some extensions and various features. The page of Mono states it fairly nicely: http://www.mono-project.com/Compatibility
              If you compare the latest .Net with latest Mono, most of "catchup features" like AutoNGEN, MultiCore JIT, NGen Profiled Guided Optimizations are Windows speciffic. Support of the core platform are basically released in the same day with VS and with the latest Mono upstream version, maybe 2-3 months later (or earlier, if you would take Linq and Async/Await). So if you want to use Async/Await from the first day in Mono, I don't see why you have to wait to catchup on Mono side.

              In fact a feature that I like and as far as I know .Net doesn't have is this: you can set an environment option and Mono runtime will adapt fairly drastically to use Auto-NGEN (MONO_AOT_CACHE=1) and this was supported like some years ago by Mono, you can configure to keep various levels of optimizations (possible in Java command line, but again, is not supported in .Net!). If you want more optimizations and slower startup, you can pick --llvm flag, and you're having C++ like performance for your tight math code and SIMD intrinsics that are CPU neutral (using Mono.Simd). You can instrument your assemblies, functions, etc. using Mono.Cecil using live patching. There is even an iniative that start to bear fruits in the discussed MD, but is a shared codebase with SharpDevelop: NRefactory. This allows to parse big chunks of code and do refactoring and static code analysis. Both of the last topics are damn-hard in C++, isn?t it so? The single refactorings I mostly see in OSS/C++ are extract method and rename. And QtCreator is one of the few IDEs that does it correctly without breaking code!

              The last thing where I think that Mono did a great job was that because there is a pressure that some people want to try their Windows code in Linux/Mono, there were some half-backed implementation of WinForms to have something quick&dirty running, but otherwise, I for one I use Gtk# with no issues (with MonoDevelop). MD is a bit crashy as for me, but is good enough for a medium project.

              Comment


              • Originally posted by Del_ View Post
                Mono was designed to give the likes of me access to Microsoft technology on a free platform, or so was stated by Miguel (and I see no reason to doubt the initial motivation).
                Very few people actually cite the original motivation for Mono. Those who do tend to get it wrong. Here's the actual intention, from early 2002:

                Code:
                 * From: Miguel de Icaza <[email protected] com>
                    * To: [email protected], [email protected] org
                    * Subject: Mono and GNOME. The long reply.
                    * Date: 06 Feb 2002 01:06:50 -0500
                
                Hello everyone,
                
                   I am sorry that I have not been able to respond earlier.  I would
                like to apologize to anyone who might have been confused about my
                strategy with Mono and what I am trying to do.    Also, I want to thank
                everyone on the mailing list that has contributed to the discussion, I
                used a lot of your ideas on this email.
                
                   Before starting though, I would like to ask my readers to forget
                everything they have heard about .NET, because it is a marketing term
                used to describe many different Microsoft projects, and there is a lot
                of information both correct and incorrect about it floating around.
                
                   My goals with Mono are very specific, and I will address those
                shortly, but for the sake of getting things done, please forget
                everything you have heard about .NET.  
                
                [snip]
                
                * What is Mono?
                
                	Mono is an implementation of three pieces of technology:
                
                		* A compiler for a new programming language, similar
                		  to Java, called C#.
                
                		* A virtual machine for the Common Intermediate
                    	  	  Language (CIL) byte codes.
                
                		* A set of libraries that encapsulate useful routines
                    		  and classes: from hash tables, to XML manipulation,
                 		  to database management, to GUI applications, to web
                		  construction tools.
                
                        These are usually referred in the Microsoft world as the `.NET
                    Framework' as opposed to .NET.  When I say `.NET Framework' here,
                    I am talking about these technologies.   
                
                	Seasoned industry programmers will notice that the above is
                    very much like Java and the Java VM.   They are right, the above
                    is just like Java. 
                
                	The CIL has one feature not found in Java though: it is
                    byte code representation that is powerful enough to be used as a
                    target for many languages: from C++, C, Fortran and Eiffel to Lisp
                    and Haskell including things like Java, C#, JavaScript and Visual
                    Basic in the mix.
                
                	I wish I had the time to go in more detail, but for the sake
                    of this argument, the above will suffice.
                
                	Although Ximian can only finance the work of a C# compiler
                    (that is all the resource I have at my disposal), I want to
                    encourage other people to work on free implementations of other
                    compilers.
                
                	I want to encourage other developers to look at targeting
                    existing compilers and interpreters to the CLI: JavaScript, Basic,
                    Perl, Python, C++, and maybe even get gcc core to generate CIL
                    bytecodes.
                
                * The CIL and the promise of language independence:
                
                	Bertrand Meyer (the father of Eiffel) wrote an interesting
                    article that encapsulates my excitement about the possibilities of
                    the CIL:
                
                	http://eiffel.com/doc/manuals/technology/bmarticles/sd/dotnet.html
                
                	This technology allows programming languages to be considered
                    on the basis of how they will perform for a given task, and not
                    based on the runtime libraries that you will depend.  Any software
                    engineer should read this article:
                
                	http://www.fawcette.com/dotnetmag/2001_12/online/online_eprods/bmeyer/default.asp
                
                	So no longer should a software engineer pick Fortran, because
                    that is the only language where his math libraries are available:
                    he can now pick the right language for the problem at hand.
                
                * Mono and GNOME.
                
                	GNOME had always tried to have a good support for multiple
                    programming languages, because we realize that no matter how much
                    we loved C as a programming language, there was a large crowd of
                    people out there that would like to use the GNOME libraries from
                    their favorite programming language, which might not necessarily be
                    C.  
                
                	This strategy has paid off very well.  There are healthy and
                    striving Python, Perl, Guile and Ada communities out there that
                    use the Gtk+ and Gnome bindings to build applications.  From rapid
                    prototyping to robust applications: we wanted to empower
                    developers. 
                
                	Keeping language bindings up to date and shipping them on time
                    has always been a consuming process, because no matter how
                    automated this process has turned out to be, there is still a
                    considerable amount of manual work that needs to be done. 
                
                	I do go into more details about this at the following places:
                
                	http://www.go-mono.com/rationale.html
                
                	http://scriptingnews.userland.com/stories/storyReader$1275
                
                * An upgrade to the development platform: Part I.
                
                	Microsoft has terrible APIs to code against.  Anyone who has
                    used Win32 and any combination of the various layered cakes that
                    have been built on top of it has stuck to that platform only
                    because of the size of the market, but it is one of the most
                    horrible APIs ever built.
                
                	To make things worse, an evolution of APIs, components, memory
                    management contracts and patched up versions of COM have made the
                    platform horrible.  
                
                	Microsoft has injected fresh air into their platform by
                    building and designing a new programming platform that addresses
                    all these pains.  They have incorporated many ideas from Java, and
                    they have extended it to address new needs that developers had.
                    They took where Java left off.
                
                	Now, the Unix platform, GNOME included has some of these
                    problems: our APIs have been evolving.  Libraries have been built
                    by disconnected groups (PNG, JPEG, Gtk+, Xml, Bonobo, CORBA spec
                    apis, etc) and the end result is that a developer eventually has
                    to learn more than he wanted to in the course of developing a
                    large application. 
                
                	Ximian funded for a long time the work on the Perl bindings,
                    and we had a lot of work going into Bonobo (more than we do today)
                    because we believed that this would help us achieve language
                    independence and empower scripting language developers (that is
                    why we were so psyched about CORBA/Bonobo support all this time).
                
                	When C#, the CLR and the class libraries were launched, we
                    looked at that, and we saw how they were solving the problem in a
                    very nice way.  At least it appealed to me and others from a
                    purely technological standpoint.  This new platform showed a lot
                    of promise.
                
                	After much researching and debating, we decided that a couple
                    of developers at Ximian will join me in working on a free
                    implementation of these specifications.   These people came
                    precisely from the cross-language interoperability area: Dick
                    Porter had been working before on ORBit and our SOAP
                    implementation;  Dietmar Maurer came from the Bonobo development
                    world and Paolo Molaro was working on Gtk+/Gnome/Bonobo bindings
                    for Perl.  This is the original Mono developer lineup. 
                
                * Evolution, Gnumeric and GNOME.
                
                	I have written and maintained many lines of code as part of
                    my GNOME work.  Ximian has developed Evolution which consists of
                    roughly 750,000 lines of code. 
                
                	Large software projects expose a set of problems that can be
                    ignored for smaller projects.  Programs that have long life times
                    have different dynamics when it comes to memory management than
                    smaller programs.
                
                	There is a point in your life when you realize that you have
                    written enough destructors, and have spent enough time tracking
                    down a memory leak, and you have spend enough time tracking down
                    memory corruption, and you have spent enough time using low-level
                    insecure functions, and you have implemented way too many linked
                    lists [1]
                
                	[1] indeed, GNOME uses Glib which is a massive step up from
                    the Unixy libc APIs.
                
                	The .NET Framework is really about productivity: even if
                    Microsoft pushes these technologies for creating Web Services, the
                    major benefit of these is increased programmer productivity.
                
                	Evolution took us two years to develop and at its peak had 17
                    engineers working on the project.  I want to be able to deliver
                    four times as many free software applications with the same
                    resources, and I believe that this is achievable with these new
                    technologies.
                
                	My experience so far has been positive, and I have first
                    hands experience on the productivity benefits that these
                    technologies bring to the table.  For instance, our C# compiler is
                    written in C#.  A beautiful piece of code.
                
                	It can be argued that I could be wrong, and that these
                    technologies are too new.  But my personal experience and the
                    experience of some of my friends with this platform has been
                    amazing.   I want to share with others this simplicity.  And I
                    want to empower developers: I want to enable a whole class of
                    developers to create great desktop applications that integrate
                    with GNOME. 
                
                * Why is Mono related to GNOME?
                
                	It is no secret that I have been working on Mono as a new
                    platform for software development, and it is also not a secret
                    that I want to help the GNOME project with Mono.  This has been
                    the plan since the project was announced in July.
                
                	Mono will use Gtk+, Gnome-Db, Libart, Gnome-Print and other
                    GNOME technologies as part of its implementation of its class
                    libraries, because that is what my team and I are familiarized
                    with.
                
                	So when you copy your binary from Windows that was compiled
                    with the Visual Studio.NET and run it on your Unix platform,
                    it will just integrate nicely with your GNOME desktop.  
                
                	We are also exploring a port to MacOS X, and for that
                    particular case, we will integrate with Aqua, not with Gtk+, but
                    you get the idea. 
                
                * GNU was based on a proprietary technology.
                
                	GNU is a free re-implementations of Unix.   Linux is a
                    re-implementation of the Unix kernel.  Before the advent of Linux
                    and the Berkeley Unix, Unix was a proprietary technology, built by
                    ATT (which back in the day, was a monopoly).  
                
                	Still, developers took what was good from Unix, and
                    reimplemented a free version of it.   Down to the Unix programming
                    language: C (which was also invented at ATT).  Even C++ was
                    invented at ATT.  
                
                	Think of Mono as following the same process: we are bringing
                    the best technology out there to our beloved free software
                    platform.  And at the same time it serves to be a magnificent
                    upgrade on the development platform. 
                
                * I can not force anyone.
                
                	Whether people in GNOME or elsewhere will use Mono is
                    independent of my opinion.  Mono will have to stand on its own
                    feet, and will have to convince developers on its own merits
                    before it succeeds.
                
                	When I made my comments to the Register reporter, I was
                    envisioning that in a couple of years Mono would be a really solid
                    technology: a good JIT engine, good class libraries and would be a
                    useful platform for innovation: it would allow people to focus
                    more on the problems at hand and worry less about the low-level
                    details of the platform. 
                
                * Rewriting GNOME.
                
                	Havoc brought up an important point recently, an article from
                    Joel Spolsky:
                
                	http://www.joelonsoftware.com/articles/fog0000000348.html
                
                	The short story is: rewriting code does not pay off, and I
                    agree with the thesis of the article.  Rewriting GNOME in C# with
                    the CLR would be a very bad idea, if not the worst possible idea
                    ever.  
                
                	But what makes the .NET Framework technologies interesting is
                    that they are evolutionary technologies:
                
                	* The runtime can be linked into an application.  
                
                	   Example:
                
                		bash$ cat hello.c
                		#include <mono.h>
                		main (int argc, char *argv [])
                		{ 
                			mono_init (argc, argv);
                			mono_assembly_load ("classes.dll");
                			mono_ves_execute ("Class.Main");
                		}
                
                  	   So existing applications can be "extended" with Mono, take
                           a piece of code like Gnumeric, and write a new chunk of it
                	   using Mono for example.
                
                	* There is no language switch required.
                
                	  You can keep using your fav language, and gradually start
                	  writing new pieces of code in another language that runs
                	  with all the benefits of "managed" execution. 
                
                	I go into some more detail here:
                
                	http://mail.gnome.org/archives/gnome-devel-list/2002-February/msg00021.html
                
                
                [snip]
                
                * Fighting the System.
                
                	The .NET Framework will exist in the Windows world, and
                    because of this they will be widely deployed.  It is a pointless
                    battle to pretend that boycotting the use of those technologies
                    will have any kind of effect on their reach.
                
                	The .NET Framework stands on its own feet, and developers
                    in the Windows world love it.  Even if this was not the case,
                    Microsoft is using these technologies and distributing to as many
                    people as possible.  We are witnessing the creation and deployment
                    of a new standard.  Sure, it has a lot of corporate support, but
                    it will become a widely deployed technology. 
                
                * Other uses of Mono
                
                	Despite my love for Mono as a tool for writing GNOME
                    applications and giving developers new tools to write code in less
                    time, there is an extra advantage in having a free implementation
                    of the .NET Framework for Unix:
                
                	* Windows developers know how to write code for it.
                
                	* Lets make it easy to bring developers from the Windows world
                	  into our platform.
                
                	* Training materials, tutorials, documentation, tips and
                    	  tricks are already available in large quantities, lets
                	  leverage this. 
                	 
                * Mono Financing.
                
                	Right now Mono is financed by Ximian because we believe that
                    this will reduce our cost of development for future applications.
                    And thats why we are really focused on Mono for the desktop
                    (amusingly the ASP.NET support in Mono has evolved more rapidly,
                    because Gaurav and Leen have been very excited about this, and
                    just have been producing code like crazy).
                
                	So even in the Mono world, I do not get to make all the
                    decisions: people work on what they are interested in developing.
                    
                	The Mono community is great!  Lots of passionate programmers
                    work with us, and I feel very happy that I have had a chance to
                    work with all of them. 
                
                	At this point in time Ximian has only a small team of full
                    time developers working on Mono (five) and a lot of the work is
                    being done by contributors on their spare time, or hackers that
                    want to see the .NET Framework run in other platforms, or
                    people who share our enthusiasm for the platform, or people who
                    just like to hack on a particular area and just love to code.
                
                	But I would like to hire more full time developers: the open
                    source development model is great for getting the fun/short things
                    done, but it is terrible to get the long-haul, boring, repetitive
                    or dull things done.
                
                	I want to be able to bring more people to work full time on
                    Mono.  I would like to offer the services of Ximian as a project
                    manager to keep driving this project forward, and get cash
                    infusions to hire developers to work on this project.   
                
                	The only restriction is that all of our work has to be free
                    software.  But other than that, I am ready to take money from
                    anyone or listen to any kind of proposals for making this happen.
                
                	Some people wonder if we have got a Microsoft investment or
                    contract (because I like this Microsoft technology).  The answer
                    is no.  But I would take one if they wanted to fund my free
                    software project ;-)  Man, I wonder what that would be like!  
                
                	Implementing the .NET Framework is a massive effort, and I
                    want to enroll as many contributors as possible.  
                
                
                * API compatibility.
                
                	I believe that the `Embrace and Extend' philosophy is bad for
                    users and developers.  Whether its a large corporation doing it,
                    or ourselves.  I want to be as compatible as possible with the
                    APIs that were published by Microsoft.
                
                	This achieves various things:
                
                		* Allows developers to move back and forth.
                
                		* Reduces training.
                
                		* Helps us leverage existing knowledge.
                
                	Of course, this should not stop anyone from implementing new
                    APIs.  And I even encourage people to write new classes, APIs and
                    components that will be reusable both on Unix and on Windows.  	
                
                * What if we never can keep up?
                
                	There is the issue that we might not be able to keep up (right
                    now, we dont, as .NET Framework 1.0 is already out there, and we
                    are, well still underway).  Also, theoretically there is the risk
                    of a given API being unimplementable on Unix.
                
                	Even if that is the case, we still win, because we would get
                    this nice programming environment, that althought might not end up
                    being 100% .NET Framework compatible, it would still be an
                    improvement and would still help us move forward.  So we can reuse
                    all the research and development done by Microsoft on these ideas,
                    and use as much as we can.  
                
                	So far all it seems like everything in .NET can be emulated in
                    our environment. 
                
                * Richard Stallman
                
                	I am not sure what people told Richard Stallman about my
                    plans.  Given the confusion surrounding .NET, it is very possible
                    that people were asking `Miguel wants to depend on Passport' or
                    something just as bad as that.
                
                	My only intention is to write applications using the CLI as a
                    development platform, which is really not very exciting for a news
                    paper to report: "Programmer to use new compiler, new garbage
                    collector, news at 11".
                
                	Really, programmer's lives are boring, I wish my life would be
                    as exciting as other people's life appear to be.  
                	
                * Further debate.
                
                	I have just scratched the surface in this email, I do like a
                    lot the technology behind the .NET Framework as you might have
                    noticed from the interviews, no secret there.  I can go on for
                    hours, but I have to set a limit to this email.
                
                	I hope this explanation will get us through, feel free to
                    e-mail me if you believe I have missed something or if you are
                    interested in contributing to make this vision happen.
                
                PS:
                
                	I would like to thank Nat Friedman for providing moral,
                    technical support all these years and his unconditional
                    friendship.  It has been a fun adventure.  
                
                	Without Nat I would probably have gone crazy by now.   
                
                PS2:
                
                	I kind of got sentimental after reading all the nice e-mail on
                    the GNOME lists. After all, writing software alone is not that
                    interesting, the most interesting part is interacting with other
                    developers, and watching how community projects grow.
                
                	I would like to thank all the people I have worked over the
                    years: every GNOME developer past and present, every Mono
                    developer past and present and all my friends at Ximian who have
                    created a great place to work.  
                
                	This community is great, and I have loved working with an
                    increasing number of people as free software becomes more
                    popular.   I know sometimes I have been unreasonable, but I am
                    trying to learn from my mistakes.  Am just too good at being 
                    mistaken.
                
                Miguel.

                Comment


                • Originally posted by brosis View Post
                  Could you please be specific about what "megalomaniacal control freaks atttitude(sic)" is in Java and where specifically?
                  Have you ever actually programmed in Java, and then other languages? If you have then you should know exactly the crap I'm talking about. Stuff like overloading operators, default parameters, choosing to pass by reference, etc where the Java language designers decided "We don't trust the programmers to not 'abuse' these features so we're not going to let them do it". and as I've stated before in another thread even frigging Python has the ability to overload operators and it's a mathematicians wet dream response to perl.

                  Java's attitude is basically "You will do as we say, how we say it, and nothing more. Now go stab yourself in the hand for five minutes". Which is exactly the kind of attitude that pisses me off at a program architect of any kind. Particularly when it results in all sorts of brain damage.

                  Originally posted by brosis View Post
                  You look like another C#/MS reasonless fanboi, should I add you to the microtrojan list rightaway?
                  Actually I'm a C++/Qt/KDE fanboy thank you. C# is simply the first language beyond C++ that I'm not groaning in anguish at the crap design I have to put up with to use it. In fact in some respects I'm preferring C# to C++ but in others I prefer the C++ way of doing things, it's just how it is.

                  I however HATE java with a passion, and wish it would die in a fire and that it's language designers would be disbarred from programming, because it's so painful to try to work with. It's on that same list of evil languages that are forced on programmers that COBOL is.

                  Originally posted by brosis View Post
                  No, because Sun actually cared their specification is kept open and nobody produces a Java machine, that make use of proprietary extensions. You can read rest on wikipedia, its there for years.
                  So bribing universities to exclusively use Java in their CSC programs is caring? Not trying to seed the workforce heavily with Java developers in order to force their shitty language on the world with underhanded tactics? Also Java is now in the hands of Oracle of all monsters...So it went from bad (Sun Microsystems) to worse (Oracle) in terms of ownership. On the bright side Oracle is now doing the right thing and slowly throttling Java to death.

                  Originally posted by brosis View Post
                  I don't use C# crap, but use Java, so Sun did a hell a lot better job because its everywhere, unlike .net - which is microsoft only. No, MONO is NOT .net.
                  So... You're saying Microsoft is aggressively trying to push .NET on non-MS OSes and then you agree with what I was saying that, that really isn't the case. So which is it?

                  Originally posted by brosis View Post
                  Yes, microsoft has coughed up some cash for Miguel to write second class, patent-insecure, incomplete implementation that targets specifically non-ms systems.
                  You know I never really got this argument. The simple fact of the matter is that it's strongly against the interests of a language designer to assert patents against an implementation of a language. It's one of those things you just don't do if you're trying to build an ecosystem of developers. Now Oracle did it yes, however Oracle bought Sun Microsystems just for the purpose of suing Google, it really doesn't give a damn about the ecosystem itself. However Microsoft wants people developing with the .NET framework, now if Microsoft starts asserting patents against Mono guess what developers are not going to do? Particularly as you can see the effect it's had on the linux application ecosystem that there is that fear there. You've got to look at things from a motivation standpoint not just a what-if standpoint, otherwise you'll sound like just yet another of those crazy people running around with a tin foil hat.

                  Originally posted by brosis View Post
                  Miguel tried to attack Android, but Google did not care.
                  Which is why Unity isn't a popular engine on Android , or are you referring to Ximian's making a version of Android in C#? In which case there really hasn't been enough time for Google to care as they're still dealing with the whole Oracle lawsuit thing.

                  Originally posted by brosis View Post
                  He tried to invade Linux desktop, but a hefty majority boycotted his "effort".
                  Because people like you spreading the same kind of FUD you like to rail against Microsoft for.

                  Originally posted by brosis View Post
                  Now he tries to attack MacOS with his "parts".
                  I'm sorry what? Mono is Cross platform, and has supported OS X since OS X 10.3, which is to say for about 10 years now...

                  Originally posted by brosis View Post
                  Regarding Digia, yes, they do, they offer LGPL patent-free toolkit official for every single platform, which relies on solid patent-free proven and acknowledged language.
                  Yep and it's good stuff

                  Originally posted by brosis View Post
                  Javascript - Netscape "port" of Java.
                  Okay that is nonsense, and a common misunderstanding. Javascript (I prefer to call it ECMAScript and will henceforth in this section) has java in the name simple because Netscape wanted to capitalize on the "popularity" of Java at the time. ECMAScript is it's own completely different language that has nothing at all to do with the syntax or programming style or even the VM of Java.

                  Originally posted by brosis View Post
                  Unlike the old case of CP/M and its microsoft clone - QDOS , the patent system now works and will prevent clone from replacing original solution via higher usage rate.
                  When microsoft desires so, it will pull on the wire and MONO will back off.
                  Okay no what happened was that IBM wanted DOS, however the implementation they were going after wouldn't sell out to them so they told Microsoft to make one for them, Microsoft bought out a company and used it's product as the basis for creating MS-DOS and then over time replaced all that company's code with their own. There never was a real issue with MS-DOS in that regard.

                  In regards to microsoft pulling the wire, it's not going to happen, for the reasons I detailed above. It runs completely counter to their interests.
                  Last edited by Luke_Wolf; 02-24-2013, 11:48 PM.

                  Comment


                  • Originally posted by Del_ View Post
                    HyperV is another example of Microsoft coming late to the party. I am pretty sure their linux support is only a consequence of them trying to be relevant for virtualization. Look around you, just about any relevant tech company the last decade is built on linux. The financial sector turned their back to windows after the London Stock Exchange fiasco. Without support for linux, HyperV would be dead on arrival.
                    Well actually as far as I can tell basically what's going on is Microsoft is being forced to bend under market pressures. Microsoft is beginning to realize that they're not the only shark in the sea and that they're going to have to interoperate. The signs have been there for a while, but I think things are finally beginning to come to a head which is why I can actually believe that Microsoft is going to be bringing Office to Linux. My only question is how long before they realize that they can't really afford to try to force a vertical stack any more, because they can't really rely upon being able to force Microsoft Windows any more with government and business contracts which the rest of their major products rely upon, creating an all or nothing situation. With large sections pointing towards nothing.

                    Comment


                    • Originally posted by asdx
                      Qt.

                      Not QT.
                      As much as we appreciate that service, aren't you a little late on the ball this time?

                      Comment

                      Working...
                      X