Slashdot Mirror
Android Ported To C#
New submitter Eirenarch writes "Xamarin has just announced that they got the Java part of Android ported to C# via machine translation. The resulting OS, called XobotOS, is available on Github. They claim some serious performance gains over Dalvik. For them, this is an experiment that they are not planning to focus on, but they will be using some of the technologies in Mono for Android."
....this still won't save you from the Oracle software apocalypse.
I'd like to try them sometime.
My AC stalker: " I personally agree with your posts most of the time, but that won't keep me from modding you troll"
with all the letters in the ascii table why can't you get past C http://www.asciitable.com/
I got to the chocolate box before you, that's why the hard ones have teeth marks.
1. The Microsoft patent grant for C# is more permissive than the patent grant for Java.
2. Oracle is suing Google over Java right now..
Mono is dead? Since when?
mono and mono programs was removed from ubuntu 12.04
Xamarin is now behing mono and more focused than ever before now that they are independent from their former bosses at Novell.
Maybe if Google ships this Microsoft and Oracle will fight to the death over who gets to sue Google...
I am TheRaven on Soylent News
Well, relatively easy, since at a bytecode level Java is a subset of CLR.
Now just try going from C# to Java.
There's no -1 for "I don't get it."
mono eats up batteries fast
This may not matter. If the litigious bastards at Oracle have their way, future Android builds will migrate to "all native code" just like on the iPhone and other non-vm based devices. They'll just sadly set aside Dalvik and declare ARM to be the official ISA of Android phones, or do some crazy thing where applications are compiled (perhaps in the cloud?) before installation to a device. I don't see C#/CLR/Mono becoming part of the Android stack, not now, not ever. Google wouldn't abandon one third-party managed code environment only to embrace another. Perhaps what Google should do is settle the case: "We will pay you a royalty for every Android if you make Microsoft go away."
Tired of FB/Google censorship? Visit UNCENSORED!
The order of the battle has already been decided. Oracle is the mini boss and Microsoft is the last boss.
Didnt know it was dead, but i do agree why do this when java works fine for this 'use case' ?
---- Booth was a patriot ----
From the README file: "XobotOS is a Xamarin research project that explored porting Android 4.0 from Java/Dalvik to C# to explore the performance and memory footprint benefits of C#."
I'm currently trying to learn the WPF in C# for a project and it just makes my life difficult! The combination of MVC, XML, LINQ and routed events just broke my ability to do real programming. You will really find yourself spend hours trying to do simple tasks and end up hacking up some weird solutions that will make your project into spaghetti code (talking about large projects at least).
game plan: Oracle's copyright lawyers fight Microsoft's patent lawyers over who gets to destroy them first. lawyers kill each other and the whole world wins?
Then, when that happens, I can do anything anywhere and everywhere, and not just run, either !!
Next wish: GoSub for Forth !! Now we be cookin !!
Microsoft is a bigger, more evil giant than even Oracle.
I'm not entirely sure you've ever dealt with Oracle...
It seems like they are "translating" the Java code to C#, then compiling it with Mono. I had expected support for running Android bytecode, or something like that...
I can already tell you how that will turn out: Microsoft won't be suing anyone.
C# and the core runtime are ECMA standards with strong patent promises, meaning Microsoft explicitly gives everyone in the world the right to implement their own C# compiler and version of the System.* libraries.
Their open-ness with regard to the CLR and C# is far and away better than Sun did with Java. They even contributed DLR code to mono itself.
Not to mention how much better the language is... With real co/contra variant generics (type erasure? GTFU), first-class functions with delegates, closures, lambda expressions, and LINQ. Plus the new async/await stuff. On and type inference just makes things easier on a day to day coding basis.
Meanwhile Java has spent the last 10 years standing still. They couldn't even get closures into the latest release and from my understanding of the docs they aren't going to do true first-class closures anyway. It's a freakin joke of a language at this point.
Natural != (nontoxic || beneficial)
Bigger? Perhaps. More evil? Not a chance in hell.
No. Ubuntu 12.04 includes a lot of mono packages, including mono runtime.
Doesn't matter. Microsoft is a bigger, more evil giant than even Oracle. They will always, always try to screw you over.
Oracle is perhaps the most evil of all the large software companies.
1. The Microsoft patent grant for C# is more permissive than the patent grant for Java.
Aaa.... No it's not. There is a defensive termination clause(I will be corrected if I'm wrong...) in Microsoft's grant, but not in Oracle's.
Freaking joke of a language? It's the number 1 or 2 language in use today (along with C) if you consult language ranking sources... The reason it stood still for a few years is due to Sun going under. But we can't complain. Sun created Java and languages directly inspired by it (such as C#) owe a lot to them.
There doesn't seem to be a perfect option to write cross platform, and this does require some porting, but it seemed the best option when we evaluated the alternatives last year.
The sun is the same in a relative way, but you are shorter of breath and one day closer to death
Microsoft is a bigger, more evil giant than even Oracle.
I'm not entirely sure you've ever dealt with Oracle...
Oracle vs Google is like "do no good" vs "do no evil".
I'm waiting for the COBOL port...
Having dealt with both I can say Oracle is much more evil than Microsoft.
Any insufficiently advanced magic is indistinguishable from technology.
Look, if you're going to troll that's fine. But at least make your trolling remarks internally consistent; first you complain that Mono requires Windows to run, then you claim it's unnecessary to create a fully FOSS CLR runtime.
Well, Windows is obviously not FOSS, so your two claims are mutually exclusive.
Or to put it another way: lern2trol.
There's no -1 for "I don't get it."
I don't know about you, but at this point, I consider a general-purpose language without closures to be a joke. In my experience, they are very useful and I would find it hard to work on a large project without them.
Even C++ has closures now.
They removed mono from Ubuntu 12.04, if you want Tomboy (I think that's the only package it was added for) you'll have to download it and its dependencies yourself.
1. The Microsoft patent grant for C# is more permissive than the patent grant for Java.
Are you a lawyer? I've been reading the promise Microsoft made, and it's all gibberish to me. And I doubt that even the original lawyer who drafted it would actually understand what he had written.
What are closures main advantage over anonymous class referring to final identifiers ?
Verbosity ?
Jehovah be praised, Oracle was not selected
Good point, I hear ubuntu is the only Linux distribution out there now too. Did they also remove the ability to install packages in 12.04 too?
I searched mono on synaptic. There are a lot of mono packages listed. The change logs show activity from April 4th, 2012, and the person listed as making that change has an ubuntu.com email address. The mono packages aren't on the CD, but the CD has only 28 packages.
LOL. Mono was removed from the default install on Fedora quite a while ago (I think around F13?), and is not in the default install on RHEL6.
I'm starting to think GNU is the problem with "GNU/Linux" these days.
Apparently Java is well on its way.
Mono was so valuable that Novell literally put it in the garbage and let Miguel and co run off with it.
Mod me down, my New Earth Global Warmingist friends!
Have to go with the above posts. Oracle > Microsoft when it comes to evil giants.
I must admit that I don't use Java, so I wasn't aware that you can refer to final local variables from anonymous classes.
But yeah, verbosity is a big deal. If LINQ used anonymous classes instead of lambdas, it would be almost unusable (and unreadable). A lambda that can be written in about a dozen characters in C# requires five lines when written as a Java anonymous class.
C# 2.0 had anonymous methods, which were already less verbose than anonymous classes. Then C# 3.0 introduced lambdas, with the main difference being that they are even less verbose (big part of that is thanks to type inference, which means you don't have to specify the types of the parameters of the lambda).
And I think the fact that you can use only final variables is quite limiting too.
Seems like a lot of work to translate Java to C# for 'performance'.
I would've first attempted to target IKVM.NET. It already runs Java bytecode on mono.
There are performance and memory footprint benefits of C# ? Benchmarks?
Java has something C# lacks: a good IDE. ... ? Monodevelop? Yeah right. Visual Studio. LOL!
Java has eclipse.
C# has
2. Oracle is suing Google over Java right now..
I am following the Oracle suite very much, because I'm myself a Java developer (and I searched long [Python, C#, C, C++, Php, Ruby] but I can't find any other language that suites my needs better). So this statement is just wrong, because Oracle is not suing over Java, but the use of the Java API and the structure, sequence and organization (SSO).
For me, the whole suite is just a stupid attempt by Oracle to get a piece of the mobile pie from Google and such a suite can only happening in the USA with it's more then confusing laws about copyright and patent laws which can patent everything.
Such suite can be easily happening with Microsoft over C#'s API or SSO, they don't hire 100s of layers for nothing.
http://www.mueller-public.de - My site http://www.anr-institute.com/ - Advanced Natural Research Institute
Answering my own question, I read the article.
It compares the performance of Dalvik to Mono. Java's Hotspot has been shown in the past to beat dalvik on most performance benchmarks, so if the Oracle suit ruled in their favour, Android might get a real JVM. :)
What is a CD? Oh... you mean those round disks that Linux used to come on before net installers?
Because C# is awesome, Oracle and Larry are douche bags, and Java is a sucky security risk vector?
Maybe the language (C#) is better (with is a personal opinion anyway, for example I don't like C# with the class/struct distinction, the unsafe delegates, the clumsy syntax for properties, the two collection frameworks [one with generics, one without] and many more issues)
But where it counts, Java is clearly the better choice, it's not for nothing the #1 used language now.
Where it counts is the Open Source Community, the build tools (is there any equivalent of maven for C#?), the libraries, the IDEs. There is C# still the underdog.
http://www.mueller-public.de - My site http://www.anr-institute.com/ - Advanced Natural Research Institute
Well, the thing is, this is actually happening with Oracle right now. It has not happened with C#.
So why is it that C# is the "trap" here, but not Java?
Android on Pascal++
So the fact that Oracle has sued someone over their language while Microsoft hasn't doesn't matter, it's still Microsoft that is more evil.
I mean, what exactly does matter, then?
It's neat that Xamarin used machine translation to port Android, but the hype is silly. There have been several Java -> C# translators out there. Microsoft used to provide one. IBM iLog open sourced their translator. I know it's much more fun to re-invent shit and hype it like a crazy car salesman, but Xamarin is smoking crack. There's nothing new here. Over the last 15 years, there have been a few products that could translate C/C++ to Java. Glad to see Xamarin still has NIH syndrome.
I've never been terribly impressed with eclipse. It's good, but a bit short of awesome. Resharper, on the other hand...that's the bee's knees.
Wow, where did you get that opinion from? Using a beta version of VS2005? VS2001?. The team I'm in right now is coding Java for Android in NetBeans because Eclipse sucked hard. But coding in C# in Visual Studio 2008/2010 is way better, way more productive. Hell even coding Javascript / HTML in VS2010 is better than this.
Australian running a company that does C# / C++ / Java / SQL / Python / Mathematica
Wasn't Larry Ellison a good friend of Steve Jobs? Is it possible that the whole Oracle Java thing is simply 'Steve Job's going thermonuclear' on Google/Android?
Both are "Do No Good". Theres a Google rap sheet a mile long stemming from the last 4 years.
You're arguing that one trap is better than the other. As long as "no trap" exists as an option, that's silly.
Help stamp out iliturcy.
Sorry but Visual Studio >>> Eclipse. It may be proprietary and not support the 100 languages Eclipse does, but for the languages does support, it is hands down 100 times better than Eclipse. Hate Microsoft all you want, but their developer tools have always been first class - which is why their OS had such widespread adoption (its about getting applications on your platform, not the quality of your platform itself).
P.S. get Resharper and NUnit.
AccountKiller
The original lawyer can understand it, but only when drunk on mead made from the tears of babies and kittens.
Got to have something to initiate the install. I've heard of doing a net boot, but does that work over the internet (as opposed to a LAN)?
C# closures can capture mutable variables as well.
But yes, this isn't actually a big deal. Verbosity is, though. You can write code in map/filter/fold style in Java, but it'll be insanely verbose with anon inner classes - whereas C# lambdas are as compact as those in, say, Scala or Ruby (thanks to type inference).
C# is a far superior language, and I would much rather work in Visual Studio then tear my eyes out everyday dealing with Eclipse.
AccountKiller
The chart from TFA:
http://tirania.org/s/71de890b.png
Whoa. Those benchmarks show Java/JVM about 7 times slower than C#/DLR. (I thought "DLR" in TFA was a typo, but it's correct. DLR stands for Dynamic Language Runtime.)
I'm not entirely surprised. I remember reading the history of IronPython, where Jim Hugunin (the original author of Jython, which is Python running on the JVM) did some experiments with the CLR, intending to prove how sucky and lousy the CLR was; instead, he found that the CLR was faster than the JVM, and he went ahead and created IronPython to run on the CLR.
steveha
lf(1): it's like ls(1) but sorts filenames by extension, tersely
Thanks for the tip. I was looking into AIR alternatives. It's good to know I can leverage our .NET assets in the mobile space.
I don't like C# with the class/struct distinction
You must then positively hate the primitive/class distinction in Java, since it's exact same thing, except that you can't add your own primitives.
the unsafe delegates
What's unsafe about delegates? They're exactly equivalent to a single-method interface implemented by an anonymous inner class wrapping a method call - except that they're several times more efficient (because they're represented as a simple pair of object pointer + method pointer internally).
the clumsy syntax for properties
Not sure what's clumsy about it, especially since you can have it auto-define the backing field and all plumbing for you since C# 3. But it sure beats the lack of properties on language level...
the two collection frameworks [one with generics, one without]
Yep, I'll give you that one. That's the price for proper (reified) generics, though - Java could retrofit old collections with generics because its generics are a compiler sham which can be discarded if needed, so old code doesn't even notice they're still there - it's all just objects. Since C# generics are runtime type-safe, there's no way you could retrofit them onto the old collections.
Why is that? Has Ballmer stood down as CEO or something?
I know Oracle is a horrible, horrible company, not worthy of our money but comparing it to Microsoft is perhaps like comparing Robert Mugabe to Atilla the Hun.
"Nine times out of ten, starting a fire is not the best way to solve the problem." - my wife
So the fact that Oracle has sued someone over their language while Microsoft hasn't doesn't matter, it's still Microsoft that is more evil.
Oracle being more evil has nothing to do with the current Java/Android case. You think Microsoft screw their customers and users over, Oracle do it 10x more. You think Microsoft's products are ordinary, Oracles are 10x worse.
Actually I think the solution would be neither.
Python FTW!
I am biased by my years of enterprise java so while I sometime do read lines and lines of lines consisting of }, the representation given by my IDE is quite ordered,
Also I do not type that stuff in, I know my IDE well. To achieve a fake lambda (copy the variable to a final identifier in a new scope in an anonymous class) I need about 15 key stroke and no mouse interaction. While I would love the have the lambda expression, I don't feel bad about resorting to lines of generated }.
Jehovah be praised, Oracle was not selected
But it's not just about writing. Reading is at least as important. And you need to read thought a lot of noise to get to the signal if you're using an anonymous class.
Both are "Do No Good". Theres a Google rap sheet a mile long stemming from the last 4 years.
"Do No Good"? Isn't there anything they might have done recently that might earn them a little karma? Like say, pulling out of China when every other corporation is busy sucking Comrade Dick for the mere hint of market access.
It's costing them, too. For instance, the PRC government has been threatening to disrupt the Motorola merger -- since Motorola has a major presence in China (including a lot of development and manufacturing), they could seriously work Google over using their regulatory agencies.
IANAL but unless they did a clean room conversion to C#, then Oracle's patent, if valid, would still apply. In otherwords, if Android is found to infringe on Oracle's IP and they programmers examined the infringing code and converted it to C#, the the C# implimentation still infringes.
Because the .NET development space is about 20% of the Java space. If .NET were dominant (as Microsoft intended when it created C# from their implementation of Java, via the intermediate language 'Cool') then it is likely that any compatible implementations would have been destroyed a long time ago.
One thing a lot of critics of Java in this thread miss (scared by the headlines created by Oracle, without actually understanding the situation), is that Google is being sued but the vastly more important *OpenJDK is not*. The importance of OpenJDK is that is it is *Free Software* (and is supported by, but not owned by, Oracle). If Google wanted leverage the vast popularity of Java they should have made a compatible implementation and paid for the Test Compatibility Kit (peanuts given their revenue); or based their stuff on OpenJDK (once it was Freed). Making an incompatible 'Java' was not very clever - especially in the insanely litigious US. If Google had used or made a Real Java (as IBM did) then users would benefit from having Java everywhere (including a compatible version in Android) and Google would also avoid the legal headaches brought on by (relatively evil and certainly avaricious) Oracle.
The team I'm in right now is coding Java for Android in NetBeans because Eclipse sucked hard.
A couple of years ago I tried out Eclipse on Ubuntu and I thought it sucked horribly.
Recently I started doing some Android development , and based on the tutorials and references and such I started using Eclipse again. I was pleased to find that the current Eclipse, "Indigo", is much better than what I tried out in the past.
So now I'm wondering what version of Eclipse you were using before. I'm also wondering if I should try out NetBeans.
steveha
lf(1): it's like ls(1) but sorts filenames by extension, tersely
their developer tools have always been first class
This is what I have noticed about Visual Studio users, and I will preface the list with this; it may be that someone just doesn't know how to use the tool, but with C#, VB.NET, C++.NET, etc... Microsoft has very clearly made the .NET platform to be developed using their tools, so knowing how to use the tool (Visual Studio) is a key requirement to knowing how to program anything for .NET (which has a lot of cons in my opinion but that's getting off topic.) [PS: In case you need an example of how absolutely dependent .NET and Visual Studio are to each other look no further than the Entity Framework]
.NET APIs is usually rampant with Visual Studio people.
.NET, Java, RPG, C++, etc... However, the people who use Visual Studio tend to have (for lack of a better term) an addiction to the "Visual" part of VS. Now there are a couple of people I've met that have written some quality code using VS, but I'd hate myself trying to convince myself that I wasn't seeing a pattern here.
1. Visual studio users tend to be autocomplete hunters. I agree autocomplete is a handy tool, but lack of knowledge of the
2. Auto-generated boiler plates *usually* makes it to production and *usually* remains until version three or four. Again, it's handy that a lot of work is done for you, in this fast pace world we live in, it can be a life saver. However, sometimes it's time to retire the boiler plate code for something that is a better fit for your solution. Visual Studio coders tend to not even realize that this is going on behind the GUI.
3. Kill diff and commit new. I can't put my finger on it, but Visual Studio coders then to forego working on already committed branches and just start fresh every time or at least every other time. For the life of me, I simply don't understand why they don't tend to follow the "dozen little gears" approach... (which leads me into)
4. If Visual Studio didn't break up the functionality, VS coders tend to cobble everything into a handful of classes. Coders tend to have a single class that handles every, single, stinking, GUI event and possible combination thereof. Really?! Why?!
5. Visual Studio coders don't seem to build components, if they do, the component isn't very focused on task. Usually the library is something along the lines of "AllTheUsefulFunctionsThatWeKeepTypingOverAndOverForOurCompany.dll" As opposed to say, "FunctionsForASingleCustomer.dll" This makes rebuilding libraries, for me, a pain in the ass because every department has to approve the changes. I have no idea why Visual Studio coders feel that everything plus a chicken is a great idea for everything and the chicken?!
6. Exceptions! Catch them please! No one is immune to this, granted. However the forgot to catch an exception for Visual Studio coders is quite higher than say the guys that write C++ or Java and use Eclipse.
I've worked at several places coding on everything from
I like Visual Studio but the most frustrating thing is it always seems to get in my way, it always wants to think for me (usually doing a pretty bad job at it), and it really does so many things behind the scene that it tends to breed a "ignorance is bliss" attitude that carries over into actual user written code.
Now before you pick up the rock and bash my head in!! I totally understand that VS is just the tool. I get that and trust me, some of the coders that I'm talking about are some of my best drinking buddies, so I really don't want to think badly of them. But I just keep seeing this wherever I go when it comes to Visual Studio coders, not just my buddies, but others too. I can't help but feel that, "if the soldiers keep dying, it may not be the soldiers' fault." Like wise, if the code keeps coming from VS, in an ugly state, it may not be the coders' fault.
Okay I'm ready to hear reasons as to why I'm just crazy and dreaming all this up.
Or, more importantly, the base install.
They are essentially free add-on software that is supported by the free OS vendor, but they are no more part of the OS than Microsoft Office is part of Windows.
More like, VS >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anything else.
And with MVVMCross, you can target iPhone/Android/Wp7.
You don't actually read the noise... that is why you have to use an IDE, let me quote myself:
the representation given by my IDE is quite ordered
Each anonymous class are graphically represented in the methods where they appear, people just don't usually touch to those code representation options. An eclipse like outline view, is a powerful refactoring tool. I am pretty sure that visual studio have the same thing.
Jehovah be praised, Oracle was not selected
"Do no good" vs "do as much evil as you can get away with"
Was mono ever part of the base install? Did one ever require mono to run Ubuntu?
1. Agreed
2 - not sure it is that big an issue, but I don't believe you're wrong.
3 - not sure what you're saying here, this is about teaching people to use the code management tools available to them, not the IDE.
4 - are you contradicting yourself - you say VS coders break things up and Coders don't?
5 - isn't just VS coders.
I'd specifically like to call out statement 6 though:
Exceptions! Catch them please! No one is immune to this, granted. However the forgot to catch an exception for Visual Studio coders is quite higher than say the guys that write C++ or Java and use Eclipse.
I think you're conflating two different approaches here. On the class library side of things, I'm strongly against catching all exceptions. The only exceptions a library should catch - and this is one of many opinions I freely admit - are those where the cause of the exception is totally and completely within the method call. That means any method using external data, externally configured data sources, parameters etc should not hide the exception but allow it to bubble back to the calling app. The app can then decide what to do (example - a misconfigured database connection string).
A program/application, on the other hand, should almost never show a user an unhandled exception. Not that I'm great at that either but still, that's my viewpoint. Again an exception - things like exceptions in an exception handler might be good exceptions to the "don't show exceptions" mantra.
I can already tell you how that will turn out: Microsoft won't be suing anyone.
The amount of uncertainty here is huge, so that is extremely optimistic on your part.
As just one issue, C# 3.0, 4.0 and 5.0 are *NOT* ISO standards. It's been years since 3.0 came out, so this isn't just that Microsoft "hasn't gotten around to it". And Mono does implement 3.0, 4.0 and 5.0. So there is definite risk. Which way will it go? No one knows, so your certainty that it will be cool is grossly unfounded.
Not trying to bash your head in, but I think you may just have encountered the wrong developers. One thing about Visual Studio is its ease of use (as opposed to Eclipse). This makes the barriers for entry much much smaller, allowing non-developers to write simple but very bad WinForms applications, which grow into monolithic and dear-god-kill-me-now bad applications.
:)
This is similar to how Javascript in the late 90s was used by so many laymen (who wanted to call themselves web developers) to write the most god-awful code known to mankind.
So please don't judge a tool by a subset of its users. There are plenty of us out there that actually write reusable, testable, readable code using Visual Studio and C# (for the love of god I wish VB.Net would die in a fire) - and we do it very quickly and effortlessly thanks to the ease of use of VS (and Resharper
It also generally helps when your team does not *completely* drink the Microsoft Koolaid. Their source control and CI tools are just plain garbage. Use git, with a proper diff tool and some level of CI. Encourage constant refactoring and TDD. <-- generally these techniques are not practiced in Microsoft shops as MS does not preach this kind of stuff very loudly or very well, and some managers are deaf to everything but what MS has to say.
AccountKiller
Will Microsoft be coming after Xamarin for the Android tax?
AccountKiller
> What's unsafe about delegates?
Hints: "unsafe" is a keyword in c#
I guess it comes down to what you're used to.
I had to write some code for work in VS 2010 and found it confusing. Except for a couple of issues, I would have switched to Sharpdevelop, which although sparse, seemed more intuitive somehow.
Similarly, those used to VS would probably find Eclipse or Netbeans lacking.
Was mono ever part of the base install? Did one ever require mono to run Ubuntu?
Yes. Did you really never notice people complaining about this?
Sure, it is. And it's applicable to many things other than delegates. And it's an explicit keyword for a reason - when you need it, it's indispensable, but when you don't, just don't use it.
Hence the proposal(s) for closures in Java 8.
I'm actually curious about Mirah, which is a statically typed Ruby-like language. For those, like me, expert at the Java API but fed up with boilerplate, it generates normal java bytecode without, say, Scala's runtime library.
You need to say how VS encourages that behavior, not just that it happens. Horrible coders do horrible things. If you are claiming that VS makes a good coder do bad things, I think that is a weak position to have. A good coder will recognize bad things and wouldn't let the code stand, no matter what some random IDE encouraged/allowed.
If you want to justify your positions, you need to talk about a feature of Eclipse that forces you to catch all exceptions. Or that forces you to break your dlls on intelligent boundaries (which 'singleCustomer' seems a bit arbitrary and app specific there as well but whatever), or how it encourages you to break up into classes along intelligent boundaries, or how it helps one learn the API system without autocomplete. VS has integrated validation (maybe not the free version?) that can warn you on some bad design decisions like this - does eclipse provide that guidance as well?
No, I noticed neither the complaints nor the necessity of mono on Ubuntu 9.10.
I use NetBeans for PHP, but what a PITA it is to use it through remote desktop. Lags terribly and somehow copy-paste does not work.
Did you honestly compare Eclipse to Visual Studio only to let out "LOL!" ? Jesus christ, people these days will say the most retarded shit... I guess you're using vi/gdb because it gives you a bigger penis?
Lately I've been using both Eclipse (for Python) and VS2010 (for C#) at work and I really don't get why people are so crazy about VS. I work with someone who kept talking about how great it is and when I asked why his only response was "Eclipse is slow".
The first thing I did when I installed VS2010 was look for a way to turn on the 80 character vertical line. I couldn't find it under the options so I searched Google. I got some instructions to install a third party plugin then edit my registry. It also seems to make quite a mess with the folder structure when creating a new project or solution, though I admit that could be my own failure to configure it properly.
Aside from the lack of the 80 character line the editor is much like any other. You can write code, autocomplete, etc. It has a decent debugger, maybe slightly better than other IDEs but not drastically. Qt has a much better GUI editor. And you really can't ignore Eclipse's extendability and the fact that you can zip up a copy of Eclipse with a bunch of plugins and hand it to someone as a preconfigured development tool. I just don't see what VS has that makes it sooo much better than everything else.
The C# language and runtime specification is open. Full marks to Microsoft there. The *libraries* are not. Turns out, that is the important bit. Shame most C# proponents never grok this. Meanwhile the JDK license explicitly allows compatible implementations of the language, runtime *and* the all-important libraries. The term "Java" is trademarked, and an implementation can't use it without passing the Testing Compatibility Kit (which ensures the "write-once, run-everywhere" promise is kept).
Conclusion: Java is actually far more open and Free (as in liberty) than C#/.NET, just ask the OpenJDK guys, or the IBM JDK guys, or kaffe, or GNU GCJ/Classpath. Just don't try and pull a Microsoft and create an implementation that breaks Java compatibility (which Google could also seen to be doing, if you squint hard enough).
Bro, it is all a "compiler sham". Turns out whether you are prepared to sacrifice true cross-platform for a few extra keywords and features (which make fsck-all difference when your projects are *huge*).
True cross-platform is there with Mono, though that depends on project type (looks kinda crappy with Gtk# on Windows & OS X... then again, so does Java with Swing).
The many (not few) extra features make surprisingly big difference when you use frameworks that are designed around them. A similar case can be seen with Ruby, where the expressivity of the language itself was picked up by framework developers and driven to the extreme.
And some of those features have no replacement at all - if you're writing Java, it's the kind of thing for which you'd just need JNI (and have all the hassle of writing & debugging that).
You're right: anonymous classes (in particular, those implementing Runnable) are closures.
The anonymous class syntax is annoyingly verbose, but the proposed new Java closure syntax is much worse; the parameter and exception declaration syntax makes it virtually unreadable.
Sorry but Visual Studio >>> Eclipse
Not for C++ work, and most certainly not when you compare its C# niceties to the niceties offered for Java development in Eclipse. (Wanna see an *entire* inheritance tree [not just superclasses]? You can do that in Eclipse!)
If you haven't used CDT in the past three or four years, do give it a try. It's far better than the "Oh shit, Intellisense stopped working, better delete my NCB and restart Visual Studio, wait for five minutes while it gets rebuilt and hope that Intellisense actually works again!" workflow that was my five years in various versions of VS. Actually, that's not giving it enough credit. CDT's code completion is just as good or better than Intellisense's. Wanna correctly list the member variables of an element of an array of templated objects that's wrapped in a macro? CDT can do that. Plus, the GDB integration is no worse than my experience with the Visual Studio debugger. Additionally, you can use all of the fancy GDB config files that you might have acquired over the years.
The (irrevocable, legally binding) promise Microsoft made was not just related to C#, but the .NET framework. So long as it's implemented properly (eg. all elements Microsoft deems "required" for the implementation is implemented), Microsoft will not peruse any legal action on anyone using the technology. That includes the API. The reason Microsoft did this was so people would not be afraid to use it. They want people to use it.
The two situations are not comparable at all. Microsoft would not sue over someone implementing the API.
There are a lot of people using Java and the trap already sprung. Just because Java was a trap as well doesn't make .NET not a trap
So it's Windows only, except that it's not Windows only?
Is clean room relevant to patents? I thought patents covered the idea, so it didn't matter how you got the idea, while copyright covered the source of the idea, so clean room implementations should get you out of copyright hot waters. Am I mistaken? Or is there something special about Oracles patent that makes the situation different?
6. Exceptions! Catch them please! No one is immune to this, granted. However the forgot to catch an exception for Visual Studio coders is quite higher than say the guys that write C++ or Java and use Eclipse.
This is just wrong... you should rarely need to catch exception explicitly, let the VM/caller catch it and handle it properly. It's called EXCEPTION and not EXPECTATION for a fucking reason.
The proposals for closures in Java 8 are very similar to the proposals for closures in Java 7. These, in turn, were strikingly similar to proposals for closures in Java 6. There have been proof-of-concept implementations around for years and several other languages running on the JVM have had closures for as long, so I'm not really holding my breath...
I am TheRaven on Soylent News
Microsoft is a bigger, more evil giant than even Oracle.
I'm not entirely sure you've ever dealt with Oracle...
Oracle vs Google is like "do no good" vs "do no evil".
More like "do evil with pride" vs "do evil and hide".
Even C++ has closures now.
Is there any language feature-of-the-day that C++ hasn't collected yet?
All my Ubuntu installs are installed through the internet. I use a USB Stick to boot the installer.
I can already tell you how that will turn out: Microsoft won't be suing anyone.
Just like Microsoft is not persuading anyone to pay them for Android phones presumably violating their patents in the linux kernel? Surely you jest, they are only waiting for the correct moment to milk the cow.
So you're saying Oracle is more honest than Google?
I haven't personally used Eclipse for 3 years but, as I'm primarily a C++ developer, I left the IDE choice to my full time Java developing peers who informed me that Eclipse sucked hard. I had assumed this was an informed opinion. The problem I've found with NetBeans is that we are using Ant for the build process, which seems to work like a shell script rather than a makefile. I've found I'm faster in C#/VS2010 mainly because the intellisense seems to work better with that combination. As someone who is continuously changing languages and platforms I find intellisense quite valuable.
Australian running a company that does C# / C++ / Java / SQL / Python / Mathematica
Isn't there anything they might have done recently that might earn them a little karma? Like say, pulling out of China when every other corporation is busy sucking Comrade Dick for the mere hint of market access.
No, not really.
After years of sucking Chinese cock....when you suddenly decide to stop sucking cock, you are still a cock sucker.
So the fact that Oracle has sued someone over their language while Microsoft hasn't doesn't matter, it's still Microsoft that is more evil.
I mean, what exactly does matter, then?
So basically, is your judgement that defines something as "evil" instead of, you know, doing "evil stuff", why don't you just do what your username says and just go away, what a moron
This would actually be a great slashdot poll!
Who is the most evil?
Apple
Microsoft
Google
Oracle
AT&T
RMS (there is always a nonsense option)
In the mean time, closures have been implemented since at least 1975 in Scheme. Funny how at first functional languages were seen as "too abstract" and "for researchers only" but with time people slowly realise that they have in fact useful features that other more mainstream languages lack.
FFS even C++ has closures now. The fact that they are still not present in Java says a lot about the skills of the average Java programmer, who clearly doesn't have a use for such obscure and abstract stuff.
(disclaimer: I am language agnostic and sometimes use Java)
Sigh. You again, with your erroneous statements.
Nimbus with Swing looks awesome. My customers tell me so (without prompting). Do your customers tell you this?
True cross platform with Mono >> horsehit. The language is cross-platform, the libraries are not - and it is the libraries that matter! The Mono libraries aren't used by the Windows folks and the Microsoft libraries can't be used on any other platform (if they exist, WPF does for Mono and apparently never will according to the project pages). Conclusion, your statement is incorrect - Mono is not cross-platform in the way that Java is.
You wouldn't write JNI (unless you were out of touch and didn't know any better) - although I happen to have written JNI interfaces many times (eg. controlling radars and large roadsigns from Java) and it wasn't as hard as people make out (I suppose if you were a nugget it might seem hard). You would either use JNA (vastly easier, and no native code required) or use a 100% pure Java library (which can be done for everything except device driver integration - are you doing device driver integration).
Ruby is excellent at what it was designed for (isn't everything?). It is a pretty piss-poor general purpose language (device control in Java is palatable; in Ruby? square peg, round hole).
The ability to create stack-allocatable objects, give them their own functions, and access them by reference instead of by value if you wish... Yeah, these are features of a good language.
Java has primitives (stack-allocated, can't invoke functions on them, can't add your own, can't add any sort of complex type). C# has a sub-set of its "structs" that are simply slightly fancier versionns of the Java primitives, plus some more complex structs. If you don't *like* your Point to be a pass-by-value type, use Nullable (which is conveniently available in shorthand Point?).
C# also has a number of types that Java could stand to pick up, like unsigned integer types. Especially when working with native code, which is sadly a requirement of a number of real-world programs, the lack of unsigned types in Java is messy.
Delegates are exactly type-safe function pointers. The concept of calling them "unsafe" is ridiculous. In what possible way are they unsafe?
You don't have to write properties. They're handy at times, but are completely optional. Having lots of Java-style
public fooType getFoo() { return this.foo; }
public void setFoo(fooType f) { if (validateFoo(f)) this.foo = f; }
public barType getBar() { return this.bar; }
functions is hardly shorter to write, and doesn't seem any easier on the user of your API either. You can certainly do it that way if you want, though; C# won't stop you. Java will, however, prevent going the other direction...
Java's generics system is just broken. This becomes especially apparent if you want to create an array of any generic type. The existence of a separate namespace for the generics classes may seem awkward at first, but the actual experience of using a well-designed generics system is well worth that little bit of hassle.
A few other points:
There are good uses for operator overloading. Not the extremes that C++ takes it to, but things like being able to implement an addition operator for a numeric type, or a multiplication operator for a vector times a scalar, or other intuitive uses.
Somewhat similarly, another aspect of peroperties, being able to define your own index operation is really nice (there's no good reason why ArrayLists and Arrays need different syntax to use them; in C# they don't).
Being able to define both implicit and explicit casts manually is lovely. Yes, you can still use
public bazType toBaz()...
functions, but if it makes perfectly good sense that somebody might want to use your type as a bazType, and it's safe to do so, why not let the cast be implicit?
The existence of the "preprocessor" in C# is great. Your debug code isn't even compiled into your release binary, resulting in more compact files and better runtime performance without needing to maintain debug branches (debug being merely an example here, but one of the most common). No C-style macros, though - both a blessing and a limitation.
Out and Ref parameters... the ability to return multiple values from a function call is incredibly handy sometimes. It's never technically mandatory to implement an API this way, but it's frequently convenient.
P/Invoke (DllImport) is an incredibly easy way to call native code from managed code. Of course, it requires that the managed code support the same types and behaviors as the native code, or directly analogous ones, so things like unsigned types and user-defined structs and out parameters do become quite beneficial again...
There's no place I could be, since I've found Serenity...
Together, nothing will get done.
Do you print out source code on a dot-matrix printer as well?
... and the Larrytards/Ellishills.
Confucius say, "Find worm in apple - bad. Find half a worm - worse."
The nonsense option is Cowboy Neal. Always. Even if the question is "what is your favorite sandwich?"
Now get off my lawn!
Confucius say, "Find worm in apple - bad. Find half a worm - worse."
JVM beats Dalvik and Mono VM in speed, but uses a lot more memory.
Performance alone means nothing. A mobile can't use 100Mb per process.
Aaa.... No it's not. There is a defensive termination clause(I will be corrected if I'm wrong...) in Microsoft's grant, but not in Oracle's.
There is a termination clause:
I.e. you can sue Microsoft for infringement of your own patents by SQL Server or Windows, but if you sue claiming that one of the specifications/implementations covered under the open specification promise infringes your patents, Microsoft reserved their right to countersue you for infringement of the same specifications.
This is a standard defensive mechanism. Sun/Oracle has one as well:
If you were to rely on these specifications for a product you are building, it actually benefits you that there is a defensive mechanism in there to deter against crippling lawsuits.
So, not much difference. Standard defensive mechanism in the common interest of the users of the products.
Reading slashdot one-liner: (irm http://rss.slashdot.org/Slashdot/slashdot).rdf.item | fl title,desc*
The word is SUIT, you fucking squarehead.
What.
So basically, since Microsoft has not sued anyone, we can just imagine that they would sue people, and then call them evil?
Am I the only one who wonders why in tarnation they didn't do exactly that?
Confucius say, "Find worm in apple - bad. Find half a worm - worse."
the unsafe delegates
As I understand correctly, C# delegates are only signature-safe. So the delegates are "safe" as Pythons functions if they follow the method signature. But from a strongly typed language I expect "safe" to mean "type-safe" not "signature-safe". So for example you have the following code:
public Fire fire;
interface MissleLauncher { void fire(double, double); }
interface FireIgnator { void fire(double, double); }
public FireIgnator ignator;
In C# code, fire can mean different things in different contexts. You can assign fire everything, it just have to meet the method signature. But for ignator you can assign only a FireIgnator.
Not sure what's clumsy about it
It's just so many { and } in C# (4 levels of braces):
namespace foo {
class Foo {
public int Xx {
get { }
set { }
}
}
}
Other language have solved that problem in a more elegant way, for example Groovy:
class Foo { // automatic setter and getter // override the getter // override the setter
...
def xxx
def getXxx() { }
void setXxx(def foo) { }
}
Foo foo = new Foo()
foo.xxx = "new value"
println foo.xxx
That there are other issues with C# that I dislike. For example:
Unless you know more about the C# language than I do, it is typically best to avoid structs entirely. If you use structs, you must be careful to not pass the struct as a parameter to methods often, or performance will degrade to worse than using a class type. The reason for this is that structs are copied in their entirety on each function call or return value.
http://www.mueller-public.de - My site http://www.anr-institute.com/ - Advanced Natural Research Institute
Not to mention how much better the language is...
You missed out that amazingly advanced feature that C# has and which Java is still working on. i.e. The ability to pass arguments by reference. Can you believe that? The inability to pass by reference! I was in disbelief for a whole day over that. I've had to work with Java a lot recently and the language is so crippled it just makes me want to punch everyone involved in it's development.
I don't know about the possible legal issues, but C# would be great for game development on Android. The stack-allocated structs alone would be a real boon.
made a compatible implementation and paid for the Test Compatibility Kit
I was under the impression that Sun had refused for years to let any non-Sun-derived Java implementation get the Test Compatibility Kit, and that was a big holdup for Apache Harmony and GNU Classpath.
Was I mistaken?
In that sense, I also installed through the internet, as the CD has only 28 packages.
What can you do in C# that can't be done in .Net's version of VB?
What can you do in C# that can't be done in .Net's version of VB?
How about, write readable code?
AccountKiller
Oh, you can only read curly-brace languages. You should have made that clear initially.
Nimbus with Swing looks awesome. My customers tell me so (without prompting). Do your customers tell you this?
I don't write in Java. That said, you only need to look at the bug tracker of any Java Swing app to see the user feedback - which tends towards negative when it comes to L&F. Try IDEA (or any IntelliJ IDE) or NetBeans for starters.
I don't care whether Swing looks awesome or not. What I do care about is that it looks alien regardless of the platform (and "native" L&F has gaping holes in it - are they still using that crappy self-written file open dialog on Windows?).
I mean, seriously - do you think that people who wrote SWT, and people who use it in their Java projects, did it for the fun of it?
True cross platform with Mono >> horsehit. The language is cross-platform, the libraries are not - and it is the libraries that matter! The Mono libraries aren't used by the Windows folks and the Microsoft libraries can't be used on any other platform (if they exist, WPF does for Mono and apparently never will according to the project pages). Conclusion, your statement is incorrect - Mono is not cross-platform in the way that Java is.
Not all .NET libraries are cross-platform, but enough is - e.g. ASP.NET is, and so is MVC, so everything you need for web apps is cross platform. For GUI, there's nothing precluding you from using Mono libraries on Windows, so ditch WPF and use Gtk# - and you get your cross-platform capability.
You wouldn't write JNI (unless you were out of touch and didn't know any better) - although I happen to have written JNI interfaces many times (eg. controlling radars and large roadsigns from Java) and it wasn't as hard as people make out (I suppose if you were a nugget it might seem hard). You would either use JNA (vastly easier, and no native code required) or use a 100% pure Java library (which can be done for everything except device driver integration - are you doing device driver integration).
Oh cmon. Sure, you can do "anything" in any Turing complete language - but in real world the questions are also cost and speed. It so happens that some things can be written to run much faster when you can ditch VM checks and use raw pointer arithmetic and such - that's one use case for C (or C# unsafe).
For another, a great many things have already been written, tested etc - as C or C++ libraries. In C# you use P/Invoke to access them, and it's easy to use and fast because it is backed by a type system that can fully match anything that you can see on the C side (again, raw pointers, but also structs, unions, unsigned types etc). All similar solutions in Java suffer from the fact that Java type system is not expressive enough. Sure, you can use signed instead of unsigned, and you can represent structs as classes, and you can provide some wrappers for pointers... except that the result is often more verbose, and it's certainly slower (a blittable C# struct is layout-compatible with a C struct, so P/Invoke just passes the pointer directly; a Java class has to be marshaled field-by-field).
Ruby is excellent at what it was designed for (isn't everything?). It is a pretty piss-poor general purpose language (device control in Java is palatable; in Ruby? square peg, round hole).
Ruby is a general purpose language, it wasn't designed for anything in particular. Device control is certainly not a common task for most general purpose languages out there, but if you really need it, it can be done in exact same way as in Java - by using a wrapper written in C (whether a special one you write yourself, or a generic customizable one that's written for you).
In C# code, fire can mean different things in different contexts. You can assign fire everything, it just have to meet the method signature. But for ignator you can assign only a FireIgnator.
There's nothing precluding a malicious person from implementing the wrong interface in Java, either.
Anyway, in practice, how many listeners have you written where you actually care about anything but the signature? I know that nothing in Swing would qualify, for example.
But from a strongly typed language I expect "safe" to mean "type-safe" not "signature-safe".
"Signature-safe" is type-safe - it requires types to match (sans co/contravariance). What you want is "semantics-safe". A language cannot verify that without behavioral types.
It's just so many { and } in C# (4 levels of braces):
Why do you count namespace and class braces as part of property syntax? That doesn't make sense.
And, sure, Groovy has more concise syntax - as do most other languages that deviate further from C-style syntax. But we were comparing C# with Java. I very much doubt that C# syntax for properties is more verbose than Java syntax, given that in the latter you have to repeat the name and the type of property twice (and gotta make sure that it matches yourself!).
the IXxxx for interfaces. I mean really, what is the point? You shouldn't care less if it's an interface or not, since it's OOP, which means that you should not known which specific implementation you are programming to.
It's a naming convention that you can adhere to or not. Partly it's just COM legacy. Partly it's convenient in that it lets you define the "standard implementation" for the interface with the same name sans the I - for example, the standard library has IList, and then it also has List (which in Java would be ArrayList). It's convenient, because 99% of users that need a concrete instance of IList want an ArrayList.
the 100s (exaggerated a little) of keywords, also see Ten C# Keywords That You Shouldn’t Be Using
More keywords provide for clearer code - for example, where in Java "final" has several very different things in different contexts, in C# that difference is made explicit by using "sealed", "readonly" and "const". Furthermore, there is a difference between final variables in Java, as well - some of them can be used as compile-time constants (e.g. in switch), some can't - and in C# that is again captured in the difference between "readonly" and "const" - if you declare something "const", and give it the wrong kind of initializer, the compiler tells you right away.
Other keywords come from being more explicit - e.g. "virtual" is there because virtualness is not the default behavior in C# (to prevent inadvertent introduction of the brittle base class problem). "operator", "explicit" and "implicit" are there to support a feature that Java simply doesn't have.
As for the list of keywords you've linked to, it's plain silly. Don't use "sealed"? it's not just for classes, you know, it's for methods as well - and there are good reasons to use it from correctness perspective (I don't want to guard against the possibility of someone overriding every single method I declare), not just speed. Don't use "struct" because it has 'strange' behavior - WTF? it has the exact same behavior as any primitive type (because they are also value types). It just so happens that some things make much more sense when they don't have any implicit object identity, and are copied around by default - so you make them structs. unsafe/stackalloc/fixed/ref (they forgot "out", BTW) are all extremely useful when working with native code. "goto" is useful because switch in C# doesn't have fallthrough from label to label if you forget "break" (which is good!), so you can use "goto case" to do it explicitly.
the distinction between class/struct. Optimiza
For a general purpose language to limited to a single, if large, niche after all these years, considering that wasn't from a lack of trying, that's a joke.
That's likely for two reasons, the abysmal licensing terms, and suns focus on using it to sell servers. The licensing terms prevent anyone from adding useful features to the language except Sun. And remember Sun sued Microsoft when they tried exactly that. Afterwords no one was going to make any attempt at all to improve the language to serve other problem domains. Suns focus on server hardware meant they had no interest in adding language features outside of that domain. So the language languishes.
C# on the other hand was developed to make it easy to write desktop GUI applications and to be able to use standard windows dll's. That makes for a better and more capable language. Also Hejlsberg is a more capable language designer than Gosling
It all ends badly. It always ends in broken apps that need a rewrite. Or in court. Or in big fees.
It's not about programming and programmers. Its about creating valuable, unencumbered, portable, long lived assets. Do they build F1 cars out of duct tape and cardboard because it is easier on the constructors? Are the pyramids built out of Nerf because it is lighter than stone and easier on the slaves?
Either you code in C, or you do not. All the rest is folly. But don't take my word for it. Reality is a hard, unforgiving mistress, a sadistic bitch that will take great joy beating this into you.
How about we take the word of the man who actually created Java and worked for both Google and Oracle :
"Just because Sun didn't have patent suits in our genetic code doesn't mean we didn't feel wronged. While I have differences with Oracle, in this case they are in the right. Google totally slimed Sun. We were all really disturbed, even Jonathan: he just decided to put on a happy face and tried to turn lemons into lemonade, which annoyed a lot of folks at Sun."
Not a lawyer, not a PR drone, not an out of touch CEO but an honest to god real programmer and someone who has actually achieved something in this industry saying Google's wrong. Oh wait I forgot, Google said that they aren't evil, it must be alright then.
If all else fails, immortality can always be assured by spectacular error.
Yeah, that's like saying you're still a virgin if you practice "coitus interrupts."
If all else fails, immortality can always be assured by spectacular error.
So you're saying Oracle is more honest than Google?
If you think about how much of the worlds most critical data is being managed by Oracle software they have a much better track record than the privacy control evading, personal information snooping, data mining Google.
If all else fails, immortality can always be assured by spectacular error.
This would actually be a great slashdot poll!
Who is the most evil?
Oracle
RMS (there is always a nonsense option)
All the non-Oracle options are nonsense.
I think the word you're looking for is "ruthless", not evil.
If all else fails, immortality can always be assured by spectacular error.
So please don't judge a tool by a subset of its users. There are plenty of us out there that actually write reusable, testable, readable code using Visual Studio and C# (for the love of god I wish VB.Net would die in a fire) - and we do it very quickly and effortlessly thanks to the ease of use of VS (and Resharper :)
It also generally helps when your team does not *completely* drink the Microsoft Koolaid. Their source control and CI tools are just plain garbage. Use git, with a proper diff tool and some level of CI. Encourage constant refactoring and TDD. <-- generally these techniques are not practiced in Microsoft shops as MS does not preach this kind of stuff very loudly or very well, and some managers are deaf to everything but what MS has to say.
Agreed. Plus with the latest versions of Visual Studio there are some pretty cool testing options available.
I use Hg not Git, but same deal. Refactoring is not painful. The built in tools in VS11 are good (in VS2008 I couldn't live without resharper). Back in the day of Source Safe (arrrghhh kill me now!!) yeah that would have been hell and my experience with non distributed systems (CVS, SVN) has not been the best either. In this day and era there is no excuse to not switch to a distributed versioning system.
"If you are going through hell, keep going." - Winston Churchill
if the FBI guys just stayed home for a few days? My guess is very few, actually.
And Microsoft isn't?
---- Booth was a patriot ----
Fucking awesome.
Is that a quote from somewhere? or are you really just that clever!? (That not sarcasm at all. That kinda made my day.)
My installer was 120 ish MB.
I failed to include the squashed packages. Mine was pretty much a full CD (~700 MB).
the average Java programmer
That is true, the average Java programmer sucks,many claim to be Java programmer, and they to do so while ignoring fundamental classes like WeakRefence, ThreadLocal, Futures, and ConcurentHashMap. Those classes that are required to understand the java model correctly. And those who do not know about them should be called java as a second language writers ! Just as I am in English.
Jehovah be praised, Oracle was not selected
He just doesn't have a taste for code that looks like vomit. Which is what every single VB.Net developer ends up writing.
We can argue all day long. Funny, how you didn't address my main concern with C#, the Community, the Libraries, the Tools, the IDEs.
I prefer my language to be neat and clean, with as less keywords as possible. For example, I wouldn't care less if Java would drop Generics, inline classes or would never implement closures. My preferences are with the Community, the Libraries, the Tools, the IDEs.
Because with the 4 important pillars I can work around any issues with the language, and the less things are in the language, the less problems I will have.
I did mix in Groovy (or I would mix in Scala, JPython, Closure, etc.) because it is part of Java. The Groovy language is just a simple Jar file that I include to my project (plus an addon to Eclipse), it's really that simple. So yes, Java has no closures, but who cares, if you can just add a simple Jar file to your project and use Groovy, with is transparent to Java (meaning you can easily mix Groovy and Java code). Or if you like the new functional programming trend you add a different Jar file and have Scala.
Microsoft can only bloat up the language, until you end up with 100s of keywords, each with it's quirks. But really productive I can only be with a language if I'm perfectly sure that for each problem I encounter I will find a Open Source Library or an Open Tool.
http://www.mueller-public.de - My site http://www.anr-institute.com/ - Advanced Natural Research Institute
More keywords provide for clearer code - for example, where in Java "final" has several very different things in different contexts, in C# that difference is made explicit by using "sealed", "readonly" and "const".
That is no advantage. Human language uses the same words with different meanings all the time. That have a reason, so we don't have to invent (and learn and remember) yet another word. That can be applied to computer languages. A final method, a final class, a final field/variable, have all the same meanings. The meaning is: you can't change it. So why you need 3 different keywords?
That's wishful thinking.
No, that's user-friendliness, and only a technological problem (meaning it can be solved, you just need time and developers). Why should the user be suffering with a workaround that have it's own traps.
What's wrong about them? They're strictly better than packages, because they don't dictate physical layout, nor do they provide a false sense of security with package-private types.
That is a big advantage of Java and a great idea of the designers to dictate the physical layout. Because now not every single source file is in one directory, but have a structure that follows the code.
What false sense? The compiler is enforcing package-private, i.e. it gives you a compiler error.
Because they represent two different things - a 2D array is guaranteed to be a matrix (every row is the same length), a jagged one is not.
And why we need them for? You can just use a List. It's really funny then, if library A needs a normal array and library B needs a jagged array. Why we can't just have a List, with would be generic for both libraries.
http://www.mueller-public.de - My site http://www.anr-institute.com/ - Advanced Natural Research Institute
Mind you; I said "good IDE", not "terribly awesome IDE".
Eclipse has lots of shortcommings, and issues, etc.
But the rest is *so* far behind, that they make eclipse seem awesome (in comparison).
Visual Studio 2008 actually. Found it *way* too hard to use,. Really. Ended up not-using it. :)
I disagree. I've tried dozens of tools for plenty of languages, and have found Visual Studio one of the application with most usability issues *ever*, and by a very large margin.
No, I didn't "lol" at the comparison, I "lol"d at how funny it seems to consider VS a good IDE.
In case you need an example of how absolutely dependent .NET and Visual Studio are to each other look no further than the Entity Framework
The Entity Framework isn't integral at all to .NET. I program in .NET every day (have for about 10 years, since 1.0), and I've never used it. I don't understand how something that is built on top of .NET and has strong tooling in VS proves "how absolutely dependent" .NET and VS are on each other. EF may be dependent on VS (I wouldn't know, and don't care), but that's a whole other thing entirely.
Other than that, I'm only going to address a few of your points:
2. Auto-generated boiler plates *usually* makes it to production and *usually* remains until version three or four. ... Visual Studio coders tend to not even realize that this is going on behind the GUI.
So, incompetent coders are incompetent. Great. VS didn't make them that way, it just made coding easy enough for incompetents to be able to do a passable job at it. I don't think that "it's not hard enough to use" is really a valid criticism, sorry. Not in my world, anyway. Most of your arguments boil down to this. "I worked with bad programmers, and they used VS, so VS is therefore bad". Doesn't cut it, sorry. Correlation, causation, you know the drill.
I like Visual Studio but the most frustrating thing is it always seems to get in my way, it always wants to think for me (usually doing a pretty bad job at it), and it really does so many things behind the scene that it tends to breed a "ignorance is bliss" attitude that carries over into actual user written code.
Aha, so now we're at the real problem. You don't know how to use the tool well, so it must be a bad tool, in your estimation. In mine, you don't know how to use the tool, so that makes YOU bad.
Also, IntelliJ IDEA is ten times the IDE that Eclipse is.
Karma: Poor (Mostly affected by lame karma-joke sigs)
If VS isn't a good IDE then you must be using one from the future. It has an excellent debugger, plenty of very good extensions, and makes working with .NET a breeze. Barely anything matches it. Eclipse? Come on..
That is no advantage. Human language uses the same words with different meanings all the time. That have a reason, so we don't have to invent (and learn and remember) yet another word. That can be applied to computer languages. A final method, a final class, a final field/variable, have all the same meanings. The meaning is: you can't change it. So why you need 3 different keywords?
The meaning of "final" for classes is "you can't inherit from it" (you can't change classes anyway). The meaning of "final" for methods is "you can't override it" (again, you can't change a method once it's defined). And for variables, you'll see the difference as soon as you try using them in "case".
No, that's user-friendliness, and only a technological problem (meaning it can be solved, you just need time and developers). Why should the user be suffering with a workaround that have it's own traps.
Thermonuclear fusion is also "only a technological problem" that "just needs time". In the meantime, though, we have to get things done, and that means providing useful workarounds. C# does just that.
You are, of course, welcome to solve this problem for Java, and contribute the code to Oracle. They will be very glad to have it for Java 8, because it will solve a great many design issues in their lambda proposal.
That is a big advantage of Java and a great idea of the designers to dictate the physical layout. Because now not every single source file is in one directory, but have a structure that follows the code.
It is incredibly annoying to navigate Java source trees because of all those useless folders on the top, like ./com/sun/java/... - the top three are completely pointless for example, because they have exactly one subfolder.
For C#, it is also common to have file structure that follows namespace hierarchy (which tends to be flatter), and one file per class, but you're not forced to - and this is very handy when it comes to e.g. generated code (which can then be all just shoved into a single directory without recreating the whole package structure).
What false sense? The compiler is enforcing package-private, i.e. it gives you a compiler error.
The false sense of security stems from the fact that you can always add your class to any package out there, and thereby gain access to package-private stuff. And, unlike inheriting, it does not give you any disadvantages, and is always possible to do. In contrast, in .NET, you can't just randomly add your types to someone else's assembly, which makes "internal" (assembly-private) visibility actually meaningful when security is enforced in a sandbox.
And why we need them for? You can just use a List.
You mean, a List of Lists? Again, it's not the same semantically as a 2D array. For one thing, its elements can be lists of different lengths. For another, a list can have elements added and removed to it. If I'm writing a function that operates, say, on 2D matrices, I don't want to have to write code at the beginning that checks that the jagged array (or List) passed to it is really a 2D matrix and throw if it's not - it's just useless code that doesn't bear any relation to what the function actually does, and furthermore it will only catch any mistakes at runtime rather than compile time.
It's really funny then, if library A needs a normal array and library B needs a jagged array. Why we can't just have a List, with would be generic for both libraries.
If library A and library B both need a 2D matrix, they'll both ask for a 2D array, because that is the standard type that most closely models the concept. If library B actually needs a jagged array, it's likely that it does so because it actually needs something else, not a matrix.
Anyway, the argument from different libraries (assuming that one of them is badly designed) that you make doesn't make sense, because it applies just as well to stock collections. Suppose that, in Java, one library wants a List, and another wants a Set - what then?
I can be productive with a language so long as I can find a library or tool for my problems - I don't need them to be FOSS. There are plenty of libraries and tools for .NET - probably less than for Java, but I've never run into a situation where I didn't find something that I needed. A lot of them are FOSS, too.
The community is very big. Have you seen StackOverflow? The most popular languages there are .NET ones.
The IDE - by and large there's only VS, but it can certainly stand up against Java IDEs. In some areas (e.g. code editing) it is somewhat worse, which can be rectified by extensions like Resharper. In some areas (e.g. visual designers) it's better. In some it's vastly better - show me a Java IDE that lets you debug both Java and C in a single session, properly handling things like "Step into" on a JNI call, or C code calling back into Java via JNI; VS can do that with P/Invoke.
The tools are out there, too - you'll have to be more specific about what you need.
With respect to other languages, if you start bringing in Groovy, Scala etc into the picture, then for .NET you also have to bring in F#, C++ (not C++/CLI, the full thing - it can still compile to managed code), and, funnily enough, even Java - because CLR as a VM has a strict superset of the capabilities of JVM, you can run the latter on top of the former, but not vice versa.
In fact the context-assist (that's how Intellisense is called outside VS) is much better in Eclipse than Netbeans (and it has been so for years), and needs less memory, is more responsive. On the other hand it lacks a good GUI builder, and gettin JEE working with it is a little more complicated.
The Entity Framework isn't integral at all to .NET.
See point that it was an example. Read into that, if you may, that it is a single element of a set. Therefore conclude, that I have a list of items "that depends on VS" but as oppose to getting into an exhaustive list of that set, I have merely stated a single element from the list. I am doubtful that anyone would care for a post detailing how tightly coupled VS and .NET are to each other. If you wish to seek such a list, by all means, Google is your friend. You will find that I am not alone in this thinking that VS and .NET are nearly inseparable.
.NET can be used independent of VS, but the use cases are slim or for platforms that are not Microsoft made. The logic behind most of that is the XML cruft that is required for a lot of functionality related to anything within the System.Data namespace. But an even better example would be XAML and anything that has to do with the mess that is WPF. Attempting to do anything with those two outside of VS is simply a task of frustration.
.NET platform since v1.0 days. However, you might point out that there are other "wizards" out there. You would be correct. There are tools that developed for other DB vendors (other than Microsoft) to that the CSDL and MSL are created for you. However, they require Visual Studio, but that's not the point. The point being is why there is even a CSDL and MSL required for such a simple task... You will shortly see that Microsoft "fixed" the method by the Code first model in the EF, however, I would be doing a disservice to you if I just said that the Code first model fixes everything.
.NET since the EF v4.0 days. I won't bore you with details because little in the way was fixed in the line of VS to .NET inter-dependence. Go wherever you like and you will find, "use the wizard" as the only choice if you so choose to code with this model.
.NET in line with JPA 2.0 in most respects and if you were to ever use EF, I would highly suggest you stick to this model, it is much cleaner and nicer to work with, but alas, it is more manual and I would hate to increase the difficulty of your job. This model is new to .NET in EF v4.1 but PLEASE DO NOT USE THIS MODEL UNDER 4.1 use EF v4.2 or better and you will have little to worry about. (I'll spare you why you shouldn't use v4.1 for code first models, but it has a lot to do with commits, rollbacks, and transactions using that version versus the other version) See I'm getting off topic here, apologies. The code first model would be the first break from the VS + .NET dependency if it were not for the insane config file. Oh ho! You might say as you currently peruse the code first walk through, the config file addition is only but six lines and three elements of XML, that is way better than JPA with it's persistence.xml file! Guilty, I would say, yes the config file is indeed much simpler, however, for Microsoft DB products only. For you see, if you choose to use another DB vendor, prepare thyself for Step 7 in the walk-though! Setting an Initialization Strategy For you see, if you use another DB vendor, you will need VS 2010 and a pl
That said, there are cases where
However, you may not be fully convinced of my position, so therefore let us then move to a comparison of EF to something like JPA. EF requiring complex tangles of XML versus JPA which relies on annotations. However, let's look at EF 4.2 and go from there. Here we have three different models for coding.
1. Database first model - This is the original bad boy. If you look in any documentation from MSDN you will see that every single thing points to "use the wizard". This coding style has been in the
2. Model first model - This horrifically titled model is new to
3. Code first model - This model brings
Having dealt with both I can say Oracle is much more evil than Microsoft.
Impressive. How is that even possible?
--
Posted from my Android tablet
Life's a bitch but somebody's gotta do it.
Microsoft would not sue over someone implementing the API.
Sorry, but I just can't take your word for that.
Life's a bitch but somebody's gotta do it.
So let me get this straight. Microsoft makes a public promise not to sue over implementing the .NET framework, which they declare is both a legally binding and irrevocable promise, and you can't take their word on that?
You'll have to excuse me if I'm a bit skeptical you're not just a nut with a full bodysuit of tinfoil.
The meaning of "final" for classes is "you can't inherit from it" (you can't change classes anyway). The meaning of "final" for methods is "you can't override it" (again, you can't change a method once it's defined). And for variables, you'll see the difference as soon as you try using them in "case".
Oh com'on use some of your brains. The meaning is the same. If you can't inherit a class from, you can't change it. If you can't override a method, you can't change it. And I really don't know what "case" is suppose to do with final variables. Case is a Java language construct with have limitations, the limitations applied whether it's final or not. Yes, you can argue that it's a design flaw, but really when you are using switch-case anyway.
It is incredibly annoying to navigate Java source trees because of all those useless folders on the top, like ./com/sun/java/... - the top three are completely pointless for example, because they have exactly one subfolder.
That's an issue with the File Browser you are using. Also when are you really open the Java files in a text editor yourself, instead of using an IDE?
This enforcement is for example very handy on a smartphone, where many apps are coming from different vendors. For example in Android. If you have a package com.devent.myapp (with needs to have a registered domain devent.com) you can save your stuff on /com/devent/myapp/. First, this enforced convention is very handy to avoid file collisions, and second, Android will delete everything in this app-directory automatically at deinstallation of the app.
and this is very handy when it comes to e.g. generated code (which can then be all just shoved into a single directory without recreating the whole package structure).
Yeah right, that is the most difficult issue of a code generator, to create directories.
The false sense of security stems from the fact that you can always add your class to any package out there, and thereby gain access to package-private stuff.
With is handy if you do unit testing. Also I don't think package-private is a security feature. It is what it means: package-private.
You mean, a List of Lists?
No I mean, using arrays for matrices and Collections for jagged-arrays. because jagged-arrays are not arrays anyway.
And if both libraries just use a standard interface for arrays and jagged-arrays (Collections), instead of two incompatible types, we can actually have some interoperability. You can just convert a List to a Set without copying all of the elements, because a Set can be just a different view (or implementation) to a List. That's why a List and Set in Java have the same interface: Collection. So library A and B just use Collection and we all happy. The library that needs a 2D Matrix just use the toArray() method.
http://www.mueller-public.de - My site http://www.anr-institute.com/ - Advanced Natural Research Institute
The community is very big. Have you seen StackOverflow? The most popular languages there are .NET ones.
Only that you have more questions for a language, does not mean it's more popular. If you want popularity, then I guess Tiobe is a much better source. With C# at place 5. (down from 4.), overturned by Objective-C.
http://www.mueller-public.de - My site http://www.anr-institute.com/ - Advanced Natural Research Institute
Having dealt with both I can say Oracle is much more evil than Microsoft.
Impressive. How is that even possible?
--
Posted from my Android tablet
Easy. Once you work with both you realize that Microsoft isn't quite as evil as you thought (perhaps only about the 660th level of Hell evil) and Oracle is more evil than you could have possibly imagined. (667th level of Hell, they are digging out a new level just for Larry E.!)
Actually with an Enterprise contract Microsoft support is among the best I've worked with. Oracle support is among the worst.
Any insufficiently advanced magic is indistinguishable from technology.
Wow. Such generalizations about people who Visual Studio. You really have no idea.
You may have "encountered" people who fit what you have described above, but I'm willing to bet you have not "encountered" the thousands of VS developers who don't fit.
It's like saying, "...I've met 100 Americans who are rude, so therefore all Americans are rude..." Guess what, there are over 300,000,000 Americans...some are rude, many are not. You can't (or shouldn't) generalize about a whole population of people based solely on what you personally have experienced.
This doesn't just go for VS devs...the same can be said for any group of devs.
No offense. Just thought I'd point that out.
Good day.
If you want popularity, then I guess Tiobe [tiobe.com] is a much better source.
And you call me a troll? Have you looked at how TIOBE computes its index?
If you want popularity, you look at the number of job openings.
Oh com'on use some of your brains. The meaning is the same. If you can't inherit a class from, you can't change it. If you can't override a method, you can't change it.
I suggest we stop going in circles on this one, and just agree to disagree. It's clear to me that the meaning is different in these cases, and I much prefer for it to be reflected in different keywords for clarity. If "final" is clear enough for you, I'm not going to argue, but I think it's silly to claim that it's some kind of major advantage either way.
And I really don't know what "case" is suppose to do with final variables.
You can only use a variable in "case" if it is a final variable of a primitive type or String, that is initialized with a constant expression. Java language spec even has a special term for this, which is "constant variable". Switch was just an example - there are more places in Java where this is important - just open the JLS and search for "constant expression".
In C#, where similar distinction exists, it is distinguished when the variable is declared. If you want the variable to be used in constant expressions, you use "const" with it, and the compiler will ensure that its type and initializer satisfy all constraints (and produce an error if they don't). On the other hand, if you use "readonly", there are no constraints - you can use any type and any initializer - but the variable is no longer usable in a context where constant expressions are expected. It has other implications regarding versioning, as well: when you declare something as "const", you guarantee to all API clients that the value of that constant is never going to change in the future versions.
This enforcement is for example very handy on a smartphone, where many apps are coming from different vendors. For example in Android. If you have a package com.devent.myapp (with needs to have a registered domain devent.com) you can save your stuff on /com/devent/myapp/. First, this enforced convention is very handy to avoid file collisions, and second, Android will delete everything in this app-directory automatically at deinstallation of the app.
I was talking about source code, not class files. Java classes are normally distributed in .jar files, anyway. \
I agree that it's not a big deal, but then I'm not the one who started picking on minor things in a language...
With is handy if you do unit testing.
A good unit testing framework couldn't care less about visibility rules because it can circumvent them if and when needed. E.g. TypeMock, which lets you do even more insane things, like mock static methods.
Also I don't think package-private is a security feature. It is what it means: package-private.
Visibility specifiers are a security feature when you have a sandbox. Suppose someone runs a downloaded applet in the browser - this requires a sandbox to be secure. Said applet is exposed to a certain subset of stock Java APIs, the API surface of which is deemed safe. But the API surface is stuff that's public - if the applet can get access to private members of a class (that are often some representations of a wrapped lower-level API), it could do more than it's normally permitted to do, such as e.g. read/write files anywhere on the filesystem where the user has access.
Package-private is misleading in that it's a seemingly restricted specifier - much like private - that is, however, not really enforceable. If you have a private field, you can sandbox that in Java. If you have a package-private field, you cannot.
Granted, the security model of relying on VM sandbox is flawed in any case (on both Java and .NET, where it exists as well) - applets and such should really run under a different account with permissions restricted according to what is needed. But that's not how applets work in practice, so.
So, because your are an idiot, then VS sucks. That's pretty much run of the course for Slashdot opinions.
What is hard about opening up a code file and coding? Or starting a project from 100's of templates. I found that all Eclipse has done is try to play catch up to VS and has not come close. You even said Eclipse has many shortcomings, largely because they are trying to do things that Microsoft has been doing for decades in VS.
In fact with C#, VS is about the best IDE you are going to get with any development language. I would even accept that even C++ development on VS is lacking, but C# and Intellisense are about the most synergistic coupling I have yet to find in any language/IDE combination. Also, there are 2 new versions of VS since your first foray into "development" on VS.
To say VS is "hard" and therefore it sucks pretty much solidifies that your opinion doesn't count. Any new IDE is going to be a struggle to become efficient in, I found Eclipse difficult and annoying to set up an Android project environment at first and while I use it now to develop Android and web stuff, but it pails in comparison in so many ways to VS.
I haven't thought of anything clever to put here, but then again most of you haven't either.
Yeah
public bool MyProperty { get; set; }
Very clumsy...
The only thing unsafe about delegates is the level of intelligence of the coder using them.
Ah, you don't understand generics, that's ok, web development doesn't use them much anyways.
I haven't thought of anything clever to put here, but then again most of you haven't either.
Actually, it's not a simple as "creating a proyect"; you need to create a "solution". Beats me why they decided to change the terminology everyone else uses.
I found most of the IDE counterintuitive, with insane defaults, and it seemed it was deliberately trying to make things harder for the user (developer) at every turn.
Holy crap, I don't even know where to begin. Let's do this:
See point that it was an example. Read into that, if you may, that it is a single element of a set. Therefore conclude, that I have a list of items "that depends on VS" but as oppose to getting into an exhaustive list of that set, I have merely stated a single element from the list.
Uh huh, How's this for logic: If you were attempting to make an argument, and you had a "list" of evidence, you'd pick the best piece of evidence from your list to present. When that piece of evidence turns out to not be evidence at all, it bodes poorly for your entire list. You keep going on about EF. You seem to not like it at all. Why not simply not use it (as I have chosen to do)?
Then, you go on about XAML. Your argument there is, "VS is the best/only viable XAML editor, therefore VS and .NET are inextricably tied together". Again, you've taken something built on top of .NET that has strong VS tooling (yet could be used via notepad and the command line, if one were persistent enough), and presented it as evidence. It's not.
Why do we have static typing? Why is type safety important? It exists to help break programmers of bad habits.
There's a lot of language designers that would disagree with you there. Static typing isn't a programmer training tool. It's not my place to educate you on that, however. This particular argument boils down to, "VS is bad, so .NET is bad, so VS is bad (because it's built on .NET)". Does that mean that VS2001 (the first version with .NET support) wasn't bad, since it wasn't built on .NET?
Anyway, you seem to be a very angry person, and I wish you peace and luck in your endeavors.
Karma: Poor (Mostly affected by lame karma-joke sigs)
Generics Type Erasure: If this generics info at runtime is important to you, you can get that with JVM languages like Kotlin. "real" co/contra type variance generics: You can also get this on the JVM with Kotlin or Scala if this is an important feature. first class functions: Pretty much every JVM language except Java has this. Closures: Java has outer variable capture, which is the textbook definition of closures. Java has closures. Java does have the "final" requirement on outer variable capture, which some people argue that makes Java have not "real" closures, but this was done on purpose as letting programmers capture non-final variables would be a common source of programmer error as you see in C#. Secondly, I'd argue that for overall language cleanliness and conciseness, languages like Kotlin and Scala go beyond C#/Java. Thirdly, I'd argue that JVM has the broadest language support. Languages like Scala and Clojure and Fantom released both .NET and JVM versions, but only the JVM community really took them seriously and adopted them. The .NET culture is generally a very Microsoft-only place.
I wish you peace and luck in your endeavors.
Sure no problem. Same to you as well.
Why not simply not use it (as I have chosen to do)?
Some of us do not have the fortune to pick and choose what we do and do not like. Instead our job is a function of what we are told to do and how well we meet that goal that is set by people other than ourselves. You should consider yourself lucky if you have such a position where you can pick and choose what to use.
(yet could be used via notepad and the command line, if one were persistent enough)
Feel free to try XAML via notepad if you like. I assure you that you will find yourself quickly mired in all of the problems that have arisen from the back and forth that Microsoft has made of the markup language. The explicit reason given for most of these changes is, "to make it easier for IDEs like Visual Studio to use the language." It is the logic that we should craft a language to make it easier to implement in an IDE that I cite as Microsoft's goal to link VS and .NET together. Microsoft has gone forward with the notion that you will be using an IDE from step one when considering changes to the .NET platform. Head over to MSDN and you'll see no shortage of proof.
Static typing isn't a programmer training tool.
I never said that it was a training tool. It's there to catch bad habits of casting. Many people would logically think that a double can be cast to string with no need to rely on API conversions. We have boxing and unboxing to thank for that. However, people get so hung up on .NET's boxing method that they think that it logically applies to custom types. Which in some cases, it does if we are talking about a simple structure with primitive types. However, if you want to take a class and do boxing, either invoke the complex methods required to do so, or invoke the wizard to create that boiler plate for you. However, with any boiler plate, if you create your own list, BST, or other data structure you cannot rely on the boiler plate because it will not go deep enough into the structure to carry out whatever your intended wishes were. If you head over to MSDN, they are totally silent on this fact. Instead the argument is just use the built-in structures within the .NET platform, because they have the required meta-data for Visual Studio to hook into.
.NET platform and VS is designed, ground up, to be a cookie cutter platform and if you want to go outside of that and Visual Studio does not provide a tool for it, then woe be to you. The normal approach it to build a library that is central for the functions that you rely on, but the .NET platform makes it near impossible to build those because there are so many hoops that have to be jumped through, those hoops exist because Microsoft figured there was a need for those to make it easier to use the structure in question with an IDE. That kind of rationale is suspect at best.
That's bunk thinking in my opinion. However, I guess you are content with just using anything that is pre-fabricated for you. However, not all of us have jobs that allow us to just sit there and put puzzle pieces together and call it a day.
So yeah, you may have an argument if we were strictly talking about a world where everyone is expected to cookie cutter program. However, most programmer are tasked with much more than that. The
At any rate it doesn't change the minds of the people at my work from thinking VS is the best stuff since sliced bread, and I doubt the same arguments would sway you either for pretty much the exact same reasons they won't give up VS. Visual Studio is indeed a nice IDE but it's fault is its hubris. It is so good at what Microsoft intended it to do, that it sucks at anything that Microsoft didn't foresee. That's my chief comp
Are you a lawyer? I've been reading the promise Microsoft made, and it's all gibberish to me. And I doubt that even the original lawyer who drafted it would actually understand what he had written.
As far as legalese goes, Microsoft's Community Promise is actually pretty clear.
Basically, they grant you the right to use their patents to the extent of implementing the standards they've released under the promise. But in order to qualify, you have to implement the whole standard. (This is not a 'gotcha' clause so they can sue you if you have a bug, it's a clause to ensure that you can't take the patent grant and use it in a totally different context by saying you started from the standard specification and removed functionality until only the patented piece was left, then re-expanded it out to a totally different thing.)
Once you've implemented the whole standard, you can even continue and add additional functionality to your implementation, so long as the original standard remains implemented. (This is in key contrast to Java's grants, which only apply if you implement exactly what they specify and nothing more -- that "and nothing more" part is what got Microsoft in trouble when they extended the syntax of J++ to include anonymous closures.)
If you ever sue Microsoft over any patents involved in the specification you're implementing under the promise, the protection of the promise and its patent grants to you dissolve. It's "don't sue us, and we won't sue you", just scoped to a single standard -- in other words, you could sue Microsoft over other patents not related to the standard without losing your patent grant.
It's also irrevocable. They can't just decide one day to no longer honor the (legally binding) promise.
Compared to Java's grant, which even ends up involving things like field-of-use restrictions once you get the TCK license involved, it's incredibly permissive. Under the Community Promise, had Google used C# in the same way they used Java, they would be completely in line with the terms of the promise.
NO CARRIER