Microsoft May Back Off of .NET Languages
443
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."
Re:Shit. (Score:5, Informative)
Have no fear then [netcobol.com].
Inaccurate headline (Score:5, Informative)
The headline "Microsoft May Back Off dynamic .NET Languages" would be better?
Re:Using them? (Score:5, Informative)
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)
...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)
BrainFuck.Net [soulsphere.org] FTW.
You're welcome.
Re:BrainFuck (Score:3, Informative)
Whatdo you mean? [soulsphere.org]
Re:Using them? (Score:3, Informative)
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:Getting screwed in both directions (Score:5, Informative)
Re:What Oracle v. Google tells us (Score:3, Informative)
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.
Re:Getting screwed in both directions (Score:4, Informative)
A lot of people have asked for and received said trouble.
Re:Getting screwed in both directions (Score:2, Informative)
- Controlled by Microsoft
Re:Getting screwed in both directions (Score:2, Informative)
Re:Getting screwed in both directions (Score:5, Informative)
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.
Re:Confusion likely in Programming sphere (Score:5, Informative)
Re:Do Microsoft products use .NET? (Score:3, Informative)
Re:Ignorance, mostly. (Score:3, Informative)
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:Getting screwed in both directions (Score:5, Informative)
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:
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.
Re:Getting screwed in both directions (Score:4, Informative)
>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
Re:Getting screwed in both directions (Score:3, Informative)
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.
And this is the reason there is no type safety - because in the VM, LCD forces this upon you.
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.
Re:Ignorance, mostly. (Score:4, Informative)
+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:Ignorance, mostly. (Score:3, Informative)
ASP wasn't even released until 2002. That's even two years after PHP 4.
ASP.NET, maybe. Old school ASP was circa 1998.
Re:Ignorance, mostly. (Score:3, Informative)
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.
Re:Getting screwed in both directions (Score:3, Informative)
Is that a strange name for a tuple?
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.
Re:Getting screwed in both directions (Score:4, Informative)
Java is better than .Net in the following ways:
- Good timezone support (.Net is a mess) .Nets
- 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
- 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:Getting screwed in both directions (Score:3, Informative)
Re:Getting screwed in both directions (Score:4, Informative)
Eh. This isn't always what you want.
That's why you get a choice:
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:Getting screwed in both directions (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 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).