Forgot your password?
typodupeerror
Microsoft Programming

Microsoft May Back Off of .NET Languages 443

Posted by Soulskill
from the lost-the-spark dept.
An anonymous reader writes "Though Microsoft had initially made a commitment to create versions of dynamic languages that are customized for .NET, recent reports make it clear that the company may be stepping back from this plan. Much early speculation on this change in focus comes from Jim Schementi, previously the program manager in charge of Microsoft's implementation of the Ruby software known as IronRuby. Schementi reports on his blog that the team dedicated to working on IronRuby has decreased to one employee. According to Schementi, his departure from the company came as Microsoft began to display a 'serious lack of commitment' to any .NETized dynamic languages, including IronRuby."
This discussion has been archived. No new comments can be posted.

Microsoft May Back Off of .NET Languages

Comments Filter:
  • by bbtom (581232) on Friday August 13, 2010 @12:03PM (#33241322) Homepage Journal

    So, Oracle are suing Google and making the JVM a less viable platform.

    And Microsoft are pulling back on resources for IronRuby.

    Looks like it may finally be time for the LLVM to step up to the plate and provide an open source alternative. Here's hoping...

    • Re: (Score:2, Insightful)

      by odies (1869886)

      >

      And Microsoft are pulling back on resources for IronRuby.

      That doesn't really say anything. There's still C#, Delphi .NET, Visual Basic .NET, and a ton of other languages. The headline is wrong - Microsoft isn't dropping .NET support, it's just lowering their support for dynamic languages. Static languages are better anyway.

      Also remember that Windows Mobile 7 will only have .NET apps, which is actually quite good, since .NET is actually a lot better than Java.

      • by pitdingo (649676) on Friday August 13, 2010 @12:23PM (#33241652)
        how is .net better than java?
        • by not already in use (972294) on Friday August 13, 2010 @12:29PM (#33241756)
          • Unsigned data types
          • Checked arithmetic (on overflow, they throw an exception)
          • Support for tail calls (for Lisp, F# and other functional languages)
          • Value types, these are structs that are not wrapped in an object
          • VM-level support for generics
          • Platform-invoke allows developers to call native code without having to write any glue in C++ using JNI, it can all be done in the managed language.
          • The Common Language Specification: a spec that set the rules for interoperability across programming languages (for example: the rules for public identifier casing, handling of int vs uint and so on).
          • Delegates allow user to keep a reference to a method or an instance method and invoke it. The VM also can turn any delegate invocation into an asynchronous invocation, so you can turn any method into an async method, like this: mySortFunc.BeginInvoke (array)
          • Support for dynamic code generation through the Reflection.Emit API.
          • A database file format allows for efficient reading of the metadata from assemblies. It does not require decompression and the database format is suitable for lazy loading.
          • Attributes were special objects that could annotate most elements in the virtual machine, you could annotate classes, methods, parameters, local variables, and at runtime the VM or the runtime could do interesting things with it.
          • Unsafe code (pointers) to support C++, Cobol and Fortran compilers running on the CLI.
          • Native support for talking to COM-based APIs. Although mostly Windows-specific, its used to talk to Mozilla, VirtualBox and OpenOffice APIs in Linux.
          • Covariance and contravariance introduced with .NET 4 make even more generic cases a pleasure to use.
          • 64-bit arrays (although part of the spec, only Mono implements this).
          • Re: (Score:3, Insightful)

            by ratboy666 (104074)

            Positive things Java has over .Net:

            - Supported on Unix, Linux, Windows, z/OS, including AIX, HP-UX and Solaris.
            - Supported on Blackberry, and other hand-held devices.

            And, no, Rotor doesn't really cut it for support. For some limited uses, Mono on Linux may be usable, but .Net has very little, if any, penetration into z/OS, AIX, HP-UX and Solaris.

            So, it's fairly reasonable to not bother supporting "ultra-portable" programming. After all, if its single-platform, just build it there to begin with. Just like th

            • Re: (Score:3, Insightful)

              by FrangoAssado (561740)

              I am curious about your claim for "tail call support". Mostly, compilers are smart enough to replace a pure tail call with a simple transfer, and the run-time doesn't have to be aware. If the optimization is contemplated, there cannot be any partial results needed, and this must be maintained through the entire recursive sequence (direct tail call, or through another function). How does the run-time itself assist with this?

              I'm guessing that if the transformation (from a tail call to a branch) is done by the compiler, then the generated bytecode loses nice properties used by the checker to ensure it's well formed. If you do it like CLR (with a "tail" modifier to a call), the checker can verify it's a simple method call (and not a branch to some place outside the current method, which might or might not be valid) and then the JIT, seeing the "tail" marker, ensures the proper semantics for the tail call (stack doesn't grow, etc.

              • Thanks for the description. I definitely see your point. Marking a tail call to allow the elimination of a stack frame, and allow static verification.

                But, mutual recursive functions that are compiled separately cannot be so marked. Of course, attempting to check for stack non-growth is probably not included -- the call can only be marked as a tail call if it is within the same source unit, and when doing the analysis prior to marking it has already been determined that no stack growth would be needed. The t

            • Re: (Score:3, Informative)

              You forgot to mention: .... and Android, and anywhere with a C compiler (so GCJ runs).
          • by Anonymous Coward on Friday August 13, 2010 @02:24PM (#33243624)

            >Checked arithmetic (on overflow, they throw an exception)
            Eh. This isn't always what you want.

            >Support for tail calls (for Lisp, F# and other functional languages)
            IBM's compiler does do tail call optimization (for self calling)

            >Value types, these are structs that are not wrapped in an object
            Again, not that useful. Esp, since hotspot can compile objects down to stack-based if it wants

            >Platform-invoke allows developers to call native code without having to write any glue in C++ using JNI, it can all be done in the managed language.
            J/Invoke, JNA both do this

            >The Common Language Specification: a spec that set the rules for interoperability across programming languages (for example: the rules for public identifier casing, handling of int vs uint and so on).
            Do int's in scala work differently than ints in java?

            >Delegates allow user to keep a reference to a method or an instance method and invoke it. The VM also can turn any delegate invocation into an asynchronous invocation, so you can turn any method into an async method, like this: mySortFunc.BeginInvoke (array)
            java.lang.ref.Method.invoke and java.util.Runnable(and friends)

            >Support for dynamic code generation through the Reflection.Emit API.
            javax.tools.JavaCompiler

            >A database file format allows for efficient reading of the metadata from assemblies. It does not require decompression and the database format is suitable for lazy loading.
            Jar files do not have to be zipped

            >Attributes were special objects that could annotate most elements in the virtual machine, you could annotate classes, methods, parameters, local variables, and at runtime the VM or the runtime could do interesting things with it.
            java.lang.annotation.Annotation

            >Unsafe code (pointers) to support C++, Cobol and Fortran compilers running on the CLI.
            A bad idea. If you must use pointers, use an opaque interface like sun.misc.Unsafe (stores pointers as a long)

            >Native support for talking to COM-based APIs. Although mostly Windows-specific, its used to talk to Mozilla, VirtualBox and OpenOffice APIs in Linux.
            Win32 Specific. Apache jakarta has an implementation anyway

            >Covariance and contravariance introduced with .NET 4 make even more generic cases a pleasure to use.
            Java has covariant return types. Not sure why you'd want non-explicit contravariance or covariant parameters.

            >64-bit arrays (although part of the spec, only Mono implements this).
            Eh. If it's really a problem, use JNI/JNA or a DB

            Stuff that java does that .net doesn't
              - Work well on non Windows OS's.
              - Work on non-x86
              - GPL'ed reference implementation

            • by shutdown -p now (807394) on Friday August 13, 2010 @08:46PM (#33247760) Journal

              Eh. This isn't always what you want.

              That's why you get a choice:

              int x = int.Max;
              int y = unchecked(x + 1); // int.Min
              int z = checked(x + 1); // OverflowException

              The default is unchecked for C# and checked for VB.

              IBM's compiler does do tail call optimization (for self calling)

              It's trivial for safe calling. CLR has a special instruction to permit cross-method tail calls (it even handles function pointers), which is crucial for getting languages such as ML or Scheme to work right.

              Again, not that useful. Esp, since hotspot can compile objects down to stack-based if it wants

              Practice shows that global escape analysis is nowhere near as good as programmer's knowledge about how things should be. Yes, HotSpot can theoretically optimize those things away completely, but in practice it often cannot do even trivial stuff, such as avoiding boxing overhead in many common scenarios.

              J/Invoke, JNA both do this

              Yeah, and it's a mess due to Java's poor type system. .NET can directly map to anything that can be described in C - it has structs with explicit layout control (this covers custom alignment and unions), unsigned integral types, portable pointer-sized integral types (IntPtr & UIntPtr), raw data pointers, and function pointers. With J/Invoke, you have to jump through various hoops to tell it how to map your data structures.

              Do int's in scala work differently than ints in java?

              The real question is - do classes work differently? Can you take any Scala class and reuse it in Java?

              mySortFunc.BeginInvoke (array)

              CLR delegates are actually more like magically created (by the runtime) instances of anonymous inner classes implementing callback interfaces. Their advantage is that they're implemented very efficiently by the runtime (effectively just a function pointer + a captured "this" pointer).

              javax.tools.JavaCompiler

              That's not the same thing. Reflection.Emit lets one emit bytecode (CIL) into a byte array - optionally with a higher-level helper API - and then have it compiled into a method, and have a delegate to it returned. JavaCompiler would be more akin to CodeDOM, but they are heavyweight solutions. Reflection.Emit is used for stuff where speed is of importance. For example, .NET regex engine can compile regexes to bytecode (which is then JIT-compiled to native code, same as any other bytecode) for greater efficiency.

              That said, you can still generate Java classes on the fly in memory as well, so it's a draw here.

              java.lang.annotation.Annotation

              CLR allows annotations to be placed on more things than Java. For example, on method return type.

              There's one other thing in CLR type system - type modifiers, modopt and modreq. Those are somewhat like annotations in that they let types be decorated with other types, with VM ignoring it, and specific compilers interpreting the decorations as they need. Unlike attributes/annotations, though, those things decorate types (and not methods/fields/classes - i.e. not declarations), in any context (including parameter & local declarations, type casts... anything). This is used by C++, for example, to encode "const" and "volatile" - something like "const int* volatile" in C++ would become "int modreq(IsConst)* modreq(IsVolatile)" in IL, where IsConst and IsVolatile are classes declared in System.Compiler.RuntimeServices namespace. Any other language that has const/volatile semantics similar to C/C++ can reuse those, and can parse the existing declarations in assemblies compiled by Visual C++.

              The VM furthermore considers two types with different modifiers to be distinct for the purposes of signature ma

          • Re: (Score:3, Informative)

            by Gr8Apes (679165)

            • VM-level support for generics

            Hmm, yep, except there is no run time checking for type safety. You can merrily pass any (pointer referenced) object through any number of function calls and not throw any exceptions. All that's required is a little reflection.

            • Unsafe code (pointers) to support C++, Cobol and Fortran compilers running on the CLI.

            And this is the reason there is no type safety - because in the VM, LCD forces this upon you.

            • 64-bit arrays (although part of the spec, only Mono implements this).

            And there are features in the spec that MS doesn't support after 4 major versions? Say it isn't so!

            Then there are .NET collections which are .... basic at best. The concurrency toolset - much

          • Re: (Score:3, Informative)

            by ultranova (717540)

            Value types, these are structs that are not wrapped in an object

            Is that a strange name for a tuple?

            Support for dynamic code generation through the Reflection.Emit API.

            Technically speaking, you can create new Java classes at runtime by defining them in a byte array, there's just no API for creating those byte arrays from a parse tree.

            • by lgw (121541) on Friday August 13, 2010 @04:24PM (#33245332) Journal

              Value types, these are structs that are not wrapped in an object

              Is that a strange name for a tuple?

              Are Java tuples passed by value (I haven't seen them)? Certianly, "tuple" is an odd name for a struct! Of course, it's far odder that C++0x is adding "tuples", which seem indistinguishable from structs. Is there some buzzword compliance thing here?

          • by cowdung (702933) on Friday August 13, 2010 @03:49PM (#33244846)

            Java is better than .Net in the following ways:

            - Good timezone support (.Net is a mess)
            - JDBC is a solid database library (unlike Ado.net)
            - java.util.concurrent
            - simpler, stabler language without a lot of needless features
            - checked exceptions (better type checking)
            - more libraries (from Sun, from apache, from jboss, spring, etc..)
            - more options
            - more mature
            - platform independent
            - defacto language standard
            - G1 garbage collector and a bunch of other fancy GC options
            - Camel case is not broken in Java
            - Javadoc format much more readable that .Nets
            - pointer compression in 64bit
            - escape analysis and automatic allocation to the stack
            - several open source implementations and several commercial versions
            - integrates well with several high quality application servers (standardized app servers)

            See.. I can play too.

            • Re: (Score:3, Informative)

              JDBC is a solid database library (unlike Ado.net)

              JDBC has API that is horribly designed. One only needs to look at Statement and PreparedStatement - where one derives from the other, but they actually work very differently. Can you explain what the inherited PreparedStatement#execute(string) is supposed to do?

              java.util.concurrent

              TPL [microsoft.com] and PLINQ [microsoft.com] (and Java doesn't even have anything as high-level as the latter).

              simpler, stabler language without a lot of needless features

              That one is purely subjective. On one hand, a lot of people seem to want some features for Java that have been in C# for ages (such as properties or lambdas). On the oth

        • by CasperIV (1013029) on Friday August 13, 2010 @12:57PM (#33242174)
          Wait? Someone likes java?
      • Re: (Score:3, Interesting)

        by psbrogna (611644)
        If static languages are better, why is the bulk of web development done with dynamic languages? I'm not picking a side, just interested in your response.
        • by not already in use (972294) on Friday August 13, 2010 @12:32PM (#33241794)
          I think the reason for this is that a lot of web programming isn't overly complex and the brevity of a dynamic language is an advantage in these cases because you can't code something up pretty quickly. Anyone writing any sort of really complex web app in a dynamically typed language is just asking for trouble.
          • by Ironhandx (1762146) on Friday August 13, 2010 @12:53PM (#33242106)

            A lot of people have asked for and received said trouble.

          • Re: (Score:3, Interesting)

            by Touvan (868256)

            That's why I once held hope for Adobe's Actionscript 3.0 - it promised static (I read lower level) language support with the richness of ECMAScript (JavaScript) - but they seem to have implemented their static class system on top of ECMAScript underpinnings, without addressing the shortcomings of their dynamic runtime (it's still crazy hard to debug dynamic code written in AS3, and it's slow). So we ended up with all the bondage and discipline of a static language, without any of the performance benefit. I

          • Re: (Score:3, Insightful)

            by Unequivocal (155957)

            Last I checked there are a pile of python and ruby websites out there doing fairly complex things -- are they all misguided? I obviously have an opinion, but I'm not trying to flamebait you - I'm actually curious what you think of that market segment.

        • Re: (Score:3, Insightful)

          by beelsebob (529313)

          The usual reason given is that it saves on the write/compile/run cycle taking up your time. In practice, it's a pretty crappy reason though.

        • Ignorance, mostly. (Score:5, Interesting)

          by Anonymous Coward on Friday August 13, 2010 @12:53PM (#33242114)

          You need to understand the history of web development to answer that question properly.

          The earliest dynamic web sites were implemented mainly in C and C++ by software developers who practiced the craft first and foremost, and treated web development merely as a particular application of their software development skills.

          Starting around 1996, however, things started to change. Many non-developers started getting involved with the web. Some of these people had absolutely no programming experience, and thus just couldn't handle C. They ended up using Perl instead, which was basically the only practical scripting language at the time, since it was significantly easier to use than C or C++. PHP soon arose from this group of developers, and followed its own path.

          Given the amateurish origins and background of this community, there wasn't much emphasis put on security, reliability, quality, maintainability and proper language features like static typing. That's why web applications from that time period are poorly written, and full of bugs and security holes.

          On the other hand, Java soon became widely adopted by business users at roughly the same time, and soon enough they started developing web applications using Java. Many of these developers were former C and C++ developers, rather than Perl developers. After ASP.NET was released, they were soon joined by C# and VB.NET developers. These applications, being written by professional developers, are often significantly better than what was produced by the amateurish PHP/Perl community.

          By the mid-2000s, the Perl/PHP community soon welcomed Python and Ruby, since they were more sensible dynamic languages that addressed many of the issues with Perl and PHP. Microsoft, Sun and others tried to draw these developers over to their platform by offering dynamic language support for .NET or the JVM. That's where IronPython, IronRuby, Groovy, JRuby, Jython and other language implementations come into play.

          Given the history of web development, dynamic languages became widely used mainly out of ignorance, and have remained widely used due to continuing ignorance. There's no technical argument in favor of dynamic languages. They're just used because their users and proponents often don't even know about how much better and easier static languages make the development of both small and large applications.

          • Re: (Score:3, Informative)

            by rpresser (610529)

            You conveniently omit "languages" -- really, glorified macro platforms -- like ASP and ColdFusion, which were a big if not bigger influence on PHP than Perl ever was. And ASP was ... guess who? Microsoft.

            (Damn. I was gonna moderate on this story, but couldn't resist replying.)

          • Re: (Score:3, Interesting)

            What would you consider to be a "better and easier static" alternative to, say, Python?
            • Re: (Score:3, Interesting)

              D (version 2). It has most of the flexibility of Python, but lacking 90% of the danger and general lack of clarity that typifies Python code.
          • Re: (Score:3, Insightful)

            by gbjbaanb (229885)

            After ASP.NET was released, they were soon joined by C# and VB.NET developers. These applications, being written by professional developers, are often significantly better than what was produced by the amateurish PHP/Perl community.

            got to disagree with this bit. ASP was released and the sloppy web programmers who used to slap something together were joined by a legion of Visual Basic programmers who used to throw something together, but thought they were uber-developers because they were employed to write t

          • by Just Some Guy (3352) <kirk+slashdot@strauser.com> on Friday August 13, 2010 @02:18PM (#33243542) Homepage Journal

            Given the history of web development, dynamic languages became widely used mainly out of ignorance, and have remained widely used due to continuing ignorance. There's no technical argument in favor of dynamic languages.

            Speaking of ignorance; pot, meet kettle! Dynamic languages became widely used mainly because they're so damn nice to use. I have a lot of background in C, functional languages, and various assembler dialects (which are really the ultimate in dynamic languages!), but I'd rather use Python than any of them for routine development.

            What specifically don't you like about dynamicism? Most of the complaints I've heard are that it forces you to write all the checks yourself!, as though the kinds of constraints you'd need in a static language are required (or even desirable) in a dynamic language.

            For example, I love duck typing. I can write a class that implements read() and pass it to almost any function that expects to receive a file-type object as an argument. I can write def add(x,y): return x+y and know that it will do the right thing whether I pass in ints, floats, or strings. (Side note: dynamic typing is not the same as weak typing; you can't add 1+"2" because those types are incompatible. I can't stand working in languages that attempt to do what I mean by guessing).

            So a static language adherent might complain that my definition of add doesn't check for every possible combination of input datatypes. That's kind of the point, though; in Python you wouldn't want to prevalidate everything. Just run the operation and let it do its thing. If you've passed in, say, a file handle and a PDF, then the "+" operation will fail, but every sane case will actually work as you'd expect.

            I guess I can summarize it this way: the only type errors I've ever received while programming in Python have been when I passed None to a function by accident because (for example) a database call returned an empty set. In each of those cases, I'd have gotten the same kind of error if I'd accidentally passed a null pointer to a C function - except that the Python program threw an exception instead of opening a security vulnerability.

            I can program in plenty of static languages. Now that I'm far enough along in my career that I can pick my own tools, I almost always choose not to. I love dynamic languages and I won't voluntarily go back.

            • by xMilkmanDanx (866344) on Friday August 13, 2010 @03:00PM (#33244192) Homepage

              +1 duck typing is awesome.

              I'd bet, part of the problem the GP is griping about is really people forcing problems that aren't meant for ruby or python or php into a web application. If you have 1000's or even 100's of models, why do you need a web interface for all of it?

              Ruby on rails (and in particular my personal favorite flavor hobo) makes for awesomely quick development for small - medium sized applications. I wouldn't use it for a behemoth application, unless said behemoth is really 100 medium sized problems that got stuck together for no good reason.

              Also, I couldn't imagine trying to develop a website in c or c++ with having to worry about memory management and poor string support.

          • Re: (Score:3, Insightful)

            by ChronoFish (948067)
            Syntactically PHP is actually a lot more like C/C++ than it is like Perl. It's basically a typeless "C/C++". It had a huge following because you could easily pepper HTML with embedded scripting - and hosting companies could offer PHP because it made for a convenient and sandbox. Yes you could easily kill a PHP script - but the PHP executable has always been stable (I've never seen the executable itself crash - nor have I ever seen PHP crash Apache or the OS - and I've been developing in PHP for 10 years
        • Because there aren't a lot of good interfaces for statically-typed language to web development. Believe me, if I didn't have to rewrite half the world to write web apps in C++ with a good Apache interface, I would do it in a heartbeat.

          That said, don't forget that a whole lot of development is done in ASP.NET now. It's changing.

        • by Chris Newton (1711450) on Friday August 13, 2010 @02:13PM (#33243450)

          If static languages are better, why is the bulk of web development done with dynamic languages?

          I don’t know how much of that is reality and how much is popular perception. In any case, here are some general trends in mainstream statically-typed languages and mainstream dynamically-typed languages today that might contribute to the popularity of the latter for web development:

          • The dynamic languages do not require the extra compilation steps in a build process. This probably speeds up prototyping. A lot of the web development in dynamic languages is probably done by small businesses or start-ups, and that sort of culture places a lot of emphasis on rapid prototyping.
          • The dynamic languages tend to have much easier basic text processing. Basics like string formatting and regular expression parsing are a horrendous chore in languages like C++, Java and C#, relative to the trivial one-liners widely available in “scripting” languages.
          • The dynamic languages also tend to have built-in support for structured data like nested hashes and arrays, where again you need to jump through hoops in typical mainstream static languages today. That kind of structured data is widely useful for defining easy interchange formats between browser-side code and server-side code. For example, on a current project, we have standardised JSON data that is accessed using several different programming languages in different contexts. In JavaScript or Python, it’s a breeze. In Java, it’s a chore.
          • Integrations of popular dynamic languages with popular web servers are widely available and easy to set up. Setting up a Java-based web application is the sort of thing people write whole books about, dropping the names of half a dozen different technologies along the way.
          • Likewise, integrations of popular dynamic languages with popular database systems are widely available and easy to use.
          • A lot of web development projects are, rightly or wrongly, not treated as critical software systems where bugs are unacceptable. Encountering an error at run-time and dumping the visitor to some sort of error page is often considered an acceptable response, and people seem to expect and tolerate this behaviour without quite the same level of loathing they reserve for “Your application has crashed” dialogs or blue screens of death.
          • Perhaps most important of all, most web development software is small. More formal systems with static typing and well-specified interfaces probably have a better cost/benefit ratio on larger systems where it is harder for developers to see the big picture and more difficult to co-ordinate people working on different parts of a system without such tools.

          I think these are more reflections of the languages in current use and their surrounding cultures, rather than inherent traits of static vs. dynamic typing, but if we’re talking about the state of the industry today, there doesn’t seem to be any practical distinction.

      • "Microsoft isn't dropping .NET..."

        My understanding has been that Microsoft created .NET for others to use. Are there any Microsoft products of importance that are programmed with .NET?
        • SQLServer 2005 Management Studio for one.

        • by DAldredge (2353)
          Large portions of Visual Studio 2010 are in .Net.
        • Oh and most of the UI for XP Media Center Edition. From here [winsupersite.com]:

          The greatest challenge was taking the complexity inherent in the new technologies we created, and from all the partners we worked with, and integrating it in a seamless way. We worked with a very sophisticated and complex set of technologies--the user interface is done in DirectX, most of the Media Center code was written in state-of-the-art C#, and we worked with a ton of partners, all of whom have their own code--and integrated it all together in an attractive, simple and straightforward package

          From a technical standpoint, Media Center user interface functionality is almost entirely written in C# managed code, on top of native Win32 and DirectX Windows XP components. These operating system components render video and draw fluid animations smoothly on the screen at 60 frames per second, with hardware acceleration and MPEG decoding provided by 3rd parties. Getting all these technology components to work together well was our biggest challenge.

          There are other examples that you could find with a simple google search.

        • by lena_10326 (1100441) on Friday August 13, 2010 @01:11PM (#33242378) Homepage

          Are there any Microsoft products of importance that are programmed with .NET?

          If you search for a Microsoft job, most are working with C# and C++. I interviewed at Microsoft in the past and there appears to be an extreme preference among their programmers to use C# because the majority of Bing/MSN code is in C#. I think Microsoft lacked the commitment because the prototypical Microsoft developer isn't interested in Ruby or Python. Those languages come with the baggage of social stigma: rogue developer, "non-enterprise", web monkey, low pay, low performance, 1 man startups, and "only for prototypes". It was clear to me developers inside Microsoft prefer C#.

        • Re: (Score:3, Informative)

          Yes, most of their core serverside business platforms are based on .Net in whole or in part, including Dyanmics CRM, SharePoint and SQL Server 2008 (the core has a dependency, while the additional services are also largely .Net based these days, including Reporting Services).
    • by CAIMLAS (41445)

      Regardless of which language picked, it's not going to be a perfect fix. For instance, perl + library bindings would likely fit the goals of many .NET projects, as well as many java projects. And there's python as well, which has similar if not greater applicability. Both of which are very stable and well developed.

      I also have to wonder how the lack of IronRuby makes .NET any less viable. Could someone else not develop IronRuby? I see no reason why not, as I believe the same has been done for perl, python,

    • by Bill_the_Engineer (772575) on Friday August 13, 2010 @12:36PM (#33241864)

      So, Oracle are suing Google and making the JVM a less viable platform.

      What?

      Oracle is suing Google for making a non-compatible VM call Dalvik that uses technology found in the JVM without paying a license. Since Google wasn't using JVM, how does Oracle's actions against Google make JVM less viable?

      Looks like it may finally be time for the LLVM to step up to the plate and provide an open source alternative.

      LLVM is a low level virtual machine used to optimize compiler operations and runtime linking. JVM is a high level virtual machine providing objects, garbage collection, and according to Oracle technology patented by Sun. From LLVM website:

      The LLVM Project is a collection of modular and reusable compiler and toolchain technologies. Despite its name, LLVM has little to do with traditional virtual machines, though it does provide helpful libraries that can be used to build them.

      LLVM is not a drop in replacement for JVM.

      • by Lunix Nutcase (1092239) on Friday August 13, 2010 @12:38PM (#33241904)

        It wouldn't be a drop-in replacement but there is no reason that a Java front-end couldn't be created and combined with the LLVM JIT compiler.

        • by Bill_the_Engineer (772575) on Friday August 13, 2010 @12:54PM (#33242124)

          Technically you are correct.

          Except for the white elephant in the room which are these patents that Oracle owns and have tested in court already when a 2003 court settlement with Microsoft created a 10 year cross licensing agreement that allows Microsoft to develop CLR.

          I'm not advocating Oracle's position, and I'm against most software patents.

          I was asking how a lawsuit that doesn't affect any of the JVMs in existence, or any Java or other JVM implemented languages that run within them, make JVM less viable? I would actually think the lawsuit could make the JVM more viable since it strengthens the power of the consortium that defines the Java standard and its related technologies.

  • Shit. (Score:5, Funny)

    by AnonymousClown (1788472) on Friday August 13, 2010 @12:04PM (#33241346)
    I've been hoping for COBOL.NET.
  • Using them? (Score:5, Insightful)

    by 0racle (667029) on Friday August 13, 2010 @12:04PM (#33241360)
    Was anyone actually using them? We have Python and Perl scripts running on windows and always preferred ActivePython and ActivePerl.
    • Re:Using them? (Score:5, Informative)

      by bbtom (581232) on Friday August 13, 2010 @12:10PM (#33241450) Homepage Journal

      Yes. I have used IronRuby - it is pretty nice. I don't know much about the Windows platform, and it is really pretty useful to be able to write simple Ruby scripts that can interact with .NET stuff. Scripting languages running on top of the CLR (and JVM) is pretty damn useful for a wide variety of applications and situations.

      • by LWATCDR (28044)

        I have never used IronRuby so I may not understand it.
        Does this take Ruby and compile it so I can have and executable?

        If so I can really she the use for it.
        I have a lot of perl code that I would love to give to other people to run.
        It is a real pain to have to install perl and several extensions just to get a script to work.
        So I can see the value of a compiler. Yes I know that they would still need the .net stuff but that is an easy install.

        • Re: (Score:3, Informative)

          by bbtom (581232)

          Yes, you can build DLLs and EXEs from IronRuby projects. I haven't done so - I just use it as an interpreted scripting language and a familiar REPL when on the Windows platform - but I've heard it is possible to do so.

          On JRuby - which I am more familiar with - you get both an interactive runtime and a compiler (jrubyc) which can turn Ruby into Java .class files.

      • Re:Using them? (Score:5, Interesting)

        by raddan (519638) * on Friday August 13, 2010 @01:18PM (#33242502)
        In fact, it was this one feature that made me realy, really like .NET. I know that .NET is anathema around here, but I think most of that ire comes from people who have never tried it. I'm a longtime UNIX developer, and after I took the time to learn .NET, I was pretty much floored. A lot of thought went into the language, the runtime environment, and even the IDE-- and I generally hate IDEs. The fact that I could run C#.NET on Linux (Windows Forms included-- there's even a GTK# interface!) was just icing on the cake. What I used to be able to do in a week takes about a day in C#.

        Microsoft constantly does this: make something incredibly cool and then fuck said product over. Despite being the most schizophrenic corporation out there, they still make money hand over fist. Baffling...
    • by AndrewNeo (979708)

      For pure Python and Ruby implementations? Probably not. But, IronPython is a wonderful way of introducing scripting into an application. You can hook IronPython into say, a C# application, provide variables/classes/etc. from the code side, and have it execute a user script with the given data. And dynamic languages like this can be embedded with only a few lines of code.

  • IronRuby (Score:2, Offtopic)

    by ultrabot (200914)

    Also one good question is - why bother with IronRuby when they already have IronPython?

    Rails isn't *that* important or special anymore.

  • C# (Score:3, Funny)

    by Anonymous Coward on Friday August 13, 2010 @12:05PM (#33241368)
    As long as Microsoft continues to make C# and ASP.NET more capable and effective than anything else out there, I don't care if they throw IronRuby in the same trash bin as RegularRuby.
    • Re:C# (Score:5, Funny)

      by MightyYar (622222) on Friday August 13, 2010 @12:20PM (#33241596)

      I know, right? Whenever I use C# all of these unicorns and ponies keep popping into existence. It was literally created by the Lord Himself.

      Can I come work as an astroturfer now?

  • Inaccurate headline (Score:5, Informative)

    by Anonymous Coward on Friday August 13, 2010 @12:06PM (#33241398)

    The headline "Microsoft May Back Off dynamic .NET Languages" would be better?

  • by cracauer (6353) on Friday August 13, 2010 @12:07PM (#33241408) Homepage

    The truth of the matter is that it is very hard to support random other languages on VMs written for certain languages.

    All these dynamic languages do one thing or another that puts a hole in your plan. Ruby with it's continuations is right up there but Python with "modify anything fundamental anytime" isn't much better. The native environment has a huge headstart.

    We should all move to LLVM.

  • by ciaran_o_riordan (662132) on Friday August 13, 2010 @12:11PM (#33241472) Homepage

    With Oracle attacking Google over Java patents [swpat.org]...

    One lesson to be drawn, as suggested by Miguel de Icaza,[4] is that people should move to Mono and C# because Microsoft's patent terms are better than Sun's.

    On the other hand, one could draw the lesson that it's foolish to use languages / platforms controlled by companies that use patents aggressively.

    Another point is that if Google had used IcedTea (the GPL'd version of Java), they never would have been at risk from Sun/Oracle's patents.

    • by perlchild (582235) on Friday August 13, 2010 @12:23PM (#33241646)

      They wouldn't have been at risk from the copyrights and trademarks, but just how would they have avoided the patents?

    • Re: (Score:2, Insightful)

      by Anonymous Coward

      I don't think you have it quite right. From what I can tell, the issue is that Google implemented their own "JVM" in the form of the Dalvik VM. They claim compatibility with java, even though it's not technically a strict J2SE implementation, meaning it's NOT covered by the patent grant. They used the open source version of the java libraries from the Apache Harmony Project as I understand it. Where they went wrong was by adding their own libraries, and removing the bits they didn't want (AWT, Swing).

    • Re: (Score:3, Informative)

      by yyxx (1812612)

      Another point is that if Google had used IcedTea (the GPL'd version of Java), they never would have been at risk from Sun/Oracle's patents.

      Yes, they would have. You only get a patent grant if you provide a full J2SE implementation, which would have been totally unreasonable on a phone. Merely building on top of the GPL'ed version is not enough.

  • No BrainFuck.NET [wikipedia.org]? WHY!!!?!?!!

    >+++>+++.>+.+++++++..+++.>++.+.>.

  • Story title fail (Score:2, Insightful)

    by Com2Kid (142006)

    "Microsoft may back off of dynamic .NET languages" would be more appropriate.

    Sad to hear though, I just started a project with IronPython.

    • Mod parent up.

      However..I did have to look up what a dynamic language [wikipedia.org] actually is. It surely will need extensions in .NET for support, but since .NET is a interpreted language there is no basic problem. Just possible performance isssues....

  • Oracle's legal action against Google over Android has already created confusion among developers about the future of Java as a platform. And, if Oracle is to able to stop Google from developing Android, Java will likely be avoided by any large companies for their new product. And, now this news that M$ might give up developing .NET any further adds to serve more confusion. With the recent news, there is another programming area likely to be severely hit i.e., the development of Mono. If .NET is gonna stop,
    • Re: (Score:2, Flamebait)

      And, now this news that M$ might give up developing .NET any further adds to serve more confusion.

      This isn't news that Microsoft isn't developing .NET any further. It is about Microsoft cutting back developers for dynamic languages being developed on top of .NET. Maybe you need to go back to 1st grade and learn some reading comprehension?

    • Wow, a whole lot of speculation followed by "Seems RMS was right"...

    • by obijuanvaldez (924118) on Friday August 13, 2010 @01:32PM (#33242710)
      If there is any confusion, you are adding to it. Microsoft is not going to "give up developing .NET," they are simply trimming the teams that were developing CLR implementations of Ruby and Python for the .NET Framework. This probably means the end of the Microsoft implementations for those languages, but that is all. It is foolish to think that if those languages are no longer supported by Microsoft for the .NET Framework that Microsoft will just give up on .NET Framework entirely.
  • Does this mean that the .NET 4.0 dynamic type will exist only for people to abuse it?
  • by melted (227442) on Friday August 13, 2010 @12:39PM (#33241910) Homepage

    Then nothing was really lost with his departure. All Microsoft PMs do is sit in the meetings, "manage schedule", "report status", and take credit for devs' work. What's even more insane is that in some teams PM/Dev ratio is 1:1. So that remaining dev (assuming he was, in fact, a dev) has just become twice as productive, due to the decrease in the number of meetings on his calendar.

  • by segedunum (883035) on Friday August 13, 2010 @12:52PM (#33242090)
    While this is slightly different, creating dynamic language environments on top of .Net, language neutrality in .Net has always been a myth. It's why there is only one language for .Net in C# and how VB.Net has become totally pointless because it's merely a syntactically different but identical .Net language. After attempts at those languages failed, such as those by ActiveState, we then got reasonably API compatible Ruby and Python environments being developed on top of .Net. Unfortunately, people already had API compatible versions of Ruby and Python - the official ones - and as a result no one has seen fit to run anything under a .Net Ruby or Python environment en masse. Environments like JRuby just clouded the landscape still further. All Microsoft really wants to do is try and get a critical mass of developers deploying to their versions of Ruby and Python probably for embrace and extend, and there is no sign that this is happening. They're trying to keep on with PHP because it's still the dominant web scripting language that they need for Azure to look semi-credible, but this is likely to meet a similar fate for the same reasons.

    The one environment that Microsoft should have created on top of .Net they simply didn't do. They should have created a rapid application development environment on top of .Net, free of the strict confines of C# and object oriented development, that aimed to be at least API compatible with classical VB so people merely had to recompile - as they had always been able to do. Alas, all that Microsoft did was force developers to throw lots of lines of existing code down the drain if they wanted to upgrade or either stay on the platforms they were on permanently or convert their applications to web based ones, which many did.

    Microsoft don't appear to have learned a thing after ten years of .Net.
  • by Dunbal (464142) * on Friday August 13, 2010 @01:34PM (#33242732)

    Microsoft is a company that is trying to point in all directions at once. This wouldn't be the first idea they have poured time and effort into, only to drop it. I am sick and tired of having to learn new development techniques just because Microsoft thinks that this year MFC/WPF/XNA/.NET/C#/F# is going to be **IT**, skimming through thousands of completely unhelpful reference pages on MSDN that merely hint at what functions/objects/libraries/tools are supposed to do but point to other pages in circular references worse than any 1990's porn sites.

    Programming is supposed to make life easier, not harder. Microsoft is the expert in obfuscated standards, obfuscated libraries, and especially obfuscated documentation. It's a wonder they get anything done at all.

  • by acid06 (917409) on Friday August 13, 2010 @01:34PM (#33242742)
    And this is why I believe there should be more people supporting the Parrot VM [parrot.org].
    It is already usable and could support a lot more languages decently with better community support.
  • Not really (Score:3, Insightful)

    by thasmudyan (460603) <{udo.schroeter} {at} {gmail.com}> on Friday August 13, 2010 @03:42PM (#33244764) Homepage

    Microsoft management knows full well that the only way to stay on top of their huge bloated codebase and architecture is to continue along the path of managed code. The only thing they're not fond of are dynamic languages, pure and simple. Support for dynamic languages was added to the .NET runtime very late in the game, and begrudgingly at that. Their current development and runtime environments rely on huge amounts of auto-generated boilerplate glue without which the simplest tasks wouldn't be possible.

    The reasons for this are probably largely historical, because there are still a lot of people from the old COM days working at MS. There are fact-based arguments as well: Dynamic languages tend to be more concise but are more difficult to automatically evaluate and optimize, especially considering the way Microsoft is relying on interface contracts and access policies (all of which are either generated by static language code or in turn serve to generate such code). Besides, none of the teams working on those much-needed tools and design-helpers wants to be put out of a job, so of course they have to stay firmly committed to their huge heap of statically generated code.

    A few years ago some Microsoftie told me about a new research OS they were working on, it was completely .NET-based and probably still reflects how MS would like Windows to be if they could start over from scratch today. I believe the project's name was Singularity, I don't know if it still exists. Anyway, the whole point of the OS was its completely static architecture. There was no support for dynamic languages, all executables were statically linked and completely rigid. There was no self-modification allowed for any application and as far as I remember applications couldn't even dynamically load libraries at runtime. So, in a way, they already made clear which road they are going to go down. Dynamic languages aren't in the mix anymore, but managed code will stay around for a long time at Microsoft.

If you had better tools, you could more effectively demonstrate your total incompetence.

Working...