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:
  • Re:Shit. (Score:5, Informative)

    by Lunix Nutcase (1092239) on Friday August 13, 2010 @11:06AM (#33241396)

    Have no fear then [netcobol.com].

  • Inaccurate headline (Score:5, Informative)

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

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

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

    by bbtom (581232) on Friday August 13, 2010 @11:10AM (#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.

  • Re:Shit. (Score:3, Informative)

    by Lunix Nutcase (1092239) on Friday August 13, 2010 @11:12AM (#33241482)

    ...and FORTRAN.NET

    Here you go [mpassociates.gr]. Though it's probably about 10 years old by this point considering you can find a codeproject [codeproject.com] page about it from 2001.

  • Re:Shit. (Score:3, Informative)

    by blair1q (305137) on Friday August 13, 2010 @11:17AM (#33241556) Journal

    BrainFuck.Net [soulsphere.org] FTW.

    You're welcome.

  • Re:BrainFuck (Score:3, Informative)

    by Lunix Nutcase (1092239) on Friday August 13, 2010 @11:22AM (#33241632)

    Whatdo you mean? [soulsphere.org]

  • Re:Using them? (Score:3, Informative)

    by bbtom (581232) on Friday August 13, 2010 @11:24AM (#33241676) Homepage Journal

    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.

  • by not already in use (972294) on Friday August 13, 2010 @11:29AM (#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).
  • by yyxx (1812612) on Friday August 13, 2010 @11:41AM (#33241944)

    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.

  • by Ironhandx (1762146) on Friday August 13, 2010 @11:53AM (#33242106)

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

  • by bonch (38532) on Friday August 13, 2010 @11:55AM (#33242142)

    - Controlled by Microsoft

  • by rantomaniac (1876228) on Friday August 13, 2010 @11:57AM (#33242178)
    LLVM really isn't comparable to JVM and CLR. It's a compiler toolchain for generating optimized code ahead of time. It's really slow, but it generates optimized code. It provides no object model, unified exception handling, memory management, it's really just a tool, not a platform.
  • by infamous_blah (1224522) on Friday August 13, 2010 @12:14PM (#33242432)

    Thank you for this, PInvoke is probably my biggest reason in prefering .Net (mainly C#) over Java.

    You can do this in Java with Java Native Access (JNA) [java.net]. From the JNA site:

    JNA provides Java programs easy access to native shared libraries (DLLs on Windows) without writing anything but Java code—no JNI or native code is required. This functionality is comparable to Windows' Platform/Invoke and Python's ctypes. Access is dynamic at runtime without code generation.

  • by obijuanvaldez (924118) on Friday August 13, 2010 @12: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.
  • by Richard_at_work (517087) <richardprice AT gmail DOT com> on Friday August 13, 2010 @12:33PM (#33242724)
    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 rpresser (610529) <rpresser&gmail,com> on Friday August 13, 2010 @12:35PM (#33242746) Homepage

    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.)

  • by Chris Newton (1711450) on Friday August 13, 2010 @01: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.

  • by Anonymous Coward on Friday August 13, 2010 @01: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 Gr8Apes (679165) on Friday August 13, 2010 @01:46PM (#33244012)

    • 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 better alternatives in JDK5 onward. Dynamic code generation is also available (BCEL).

    And then there's the documentation. I never thought I'd actually think highly of Javadocs, but a nice 9 month stint through MS's documentation made me pine for the relatively concise and accurate Javadocs.

  • by xMilkmanDanx (866344) on Friday August 13, 2010 @02: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.

  • by Mongoose Disciple (722373) on Friday August 13, 2010 @02:05PM (#33244262)

    ASP wasn't even released until 2002. That's even two years after PHP 4.

    ASP.NET, maybe. Old school ASP was circa 1998.

  • by JDAustin (468180) on Friday August 13, 2010 @02:21PM (#33244442)

    ASP wasn't even released until 2002. That's even two years after PHP 4.

    No idiot...ASP was originally released with IIS in 1996. ASP is interpreted/scripted while ASP.NET was released in 2002. ASP and ASP.net share as much in common as VB6 and VB.Net do..ie language syntax and name only. Everything else is different.

  • by ultranova (717540) on Friday August 13, 2010 @02:38PM (#33244706)

    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 cowdung (702933) on Friday August 13, 2010 @02: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.

  • by SplashMyBandit (1543257) on Friday August 13, 2010 @03:18PM (#33245260)
    You forgot to mention: .... and Android, and anywhere with a C compiler (so GCJ runs).
  • by shutdown -p now (807394) on Friday August 13, 2010 @07: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

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

    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 other hand, another lot claim that e.g. generics are "needless", and I recall that before 1.5 that same lot also claimed that first-class enums are "needless"...

    checked exceptions (better type checking)
    more libraries (from Sun, from apache, from jboss, spring, etc..)

    I love how this goes together. Maybe you should go tell Spring guys about the wonders of checked exceptions...

    defacto language standard

    As opposed to an ISO standard?

    G1 garbage collector and a bunch of other fancy GC options

    Matched in .NET 4.

    Camel case is not broken in Java

    Define "broken", and provide references as to why your definition is more correct. Or else admit that it is another subjective preference on the order of "how many spaces in a tab".

    Javadoc format much more readable that .Nets

    I'll grant you that, though it requires a separate special parser. For C# and VB doc-comments, the compiler just extracts them as-is into an .xml file alongside the compiled .exe/.dll. If you use any custom XML elements, they will be extracted as well. Then you can use your own tools to process the .xml file as you see fit - and they don't need to be just document generators...

    escape analysis and automatic allocation to the stack

    Largely unneeded in .NET due to presence of value types in the type system, which are allocated inline all the time (as opposed to escape analysis, which still gets things wrong more often than not).

There is no opinion so absurd that some philosopher will not express it. -- Marcus Tullius Cicero, "Ad familiares"

Working...