Slashdot Mirror
Portable.NET Now 100% Free Software
rhysweatherley writes "Finally after months of hard work and bucket loads of caffeine, the
DotGNU community has finally got
Portable.NET
to the point of building our C# libraries on many Free Software
platforms with our own C# compiler.
This is a big deal! Portable.NET is now 100% pure Free Software,
with no dependencies on third party C# tools. The compiler, which
is written in C, bootstraps off gcc, so there are no icky 'how to
compile the compiler' problems. And it's fast! The DotGNU team consists of lots of contributors, many of whom are
coincidentially named 'Rhys Weatherley,' but this wouldn't have been
possible without the support of the DotGNU community, especially
the Weekend Warriors. .NET is not the only thing we are doing. We're playing around with JVM and Parrot (of perl6 fame) backends to the compiler. And we have a
C compiler front-end that generates pure bytecode apps that can run
on any decent CIL implementation (Portable.NET, Mono, etc). We are about 95% of the way towards our first milestone of an
ECMA-compatible C# implementation. There are lots of things still
to be done in the low-level C# libraries, runtime engine, and the
compiler. So, if you have some time on your hands, and like messing with
languages and stuff, like yours truly ... have look and maybe
have some fun!"
Time to re-evaluate... It might be good afterall...
So confused... Is it weekends that we like MS, or just Saturdays, or just 6-7pm EST...
Damn it...
Tournament Management Online &
So how do the two projects, DotGnu and Mono compare? I could be way off base here, but it seems to me like yet another of the great OSS wars. You know, vi and emacs, kde and gnome, etc.
Can someone please tell me I'm wrong and explain why?
Blink
all virii now cross-platform
This is a huge milestone. Now everyone who has two hands and 10 fingers needs to get in there and help rhys out! There are lots of things for people to work on. From Documentation to Libraries. so go to http://dotgnu.org and get started!
How long before Microsoft changes or adds something for "security" reasons and prevents you fron using open-source .NET? Maybe we need to start a betting pool.
You know - I'm a tried and true perl and open source hacker and believer. But then I got this job doing .NET and c#. It was hard at first because I've been of the opinion that m$ really sucks because they're a monopoly, they extort $ out of schools, etc. etc.
But in terms of pure technological merit, c# is a damn good language! Especially if you use the vs.net ide, you can get stuff done way fast. So keep an open mind w/ this language. It's very exciting to be able to build stuff using vs.net, and deploy on linux.
Keep up the good work on this project guys!!
we are all one consciousness experiencing itself subjectively - bill hicks
This is an excellent step forward for Linux on the Desktop. As Corporations begin to adopt the Microsoft .NET servers (for better or for worse), Linux desktop clients will be able to participate, and not be left out in the cold.
Congratulations to the development team on their achievement.
I'd rather be a conservative nutjob than a liberal with no nuts and no job.
before, the portable.net libraries had to be compiled using a certain proprietary C# compiler. Now, pnet can compile them by itself. So it is completely independant of proprietary software making it 100% free.
I doubt that will happen. They'll add something and make the open-source engine work mostly, but as a less-reliable system with fewer features.
.NET move was a pretty good move for MS.
And they aren't going to get MS sorts using it (even ignoring the pre-installed issue that beat even Netscape's best efforts), because MS put lots of money, time, and talent into their own VM, and the GNU one just ain't gonna be significantly better any time soon.
The
May we never see th
Yup they have copyrights but we are reproducing our implementation from ECMA spec (334 and 335) which are public
So their copyrights don't matter as we're not using their code . Their patents can be contested as ECMA does not look lightly on submarine patents
And we have GNu to support us !
Quidquid latine dictum sit, altum videtur
The C programming language does everything I need it to do.
.NET. Couldn't we have spent more time refining the applications, utilities, and system code that we already have rather than wasting time extending the Microsoft monopoly?
.NET succeed.
Writing a new operating system? I choose C.
Coding up your own desktop environment? I choose C.
Desire to write the next award-winning PC game? I choose C.
I'm not sure why so many man months were spent trying to hook into
Sorry, but you people really confuse me sometimes. I write a few sentences of praise for Microsoft's latest operating systems just a few hours ago and I get marked as a troll. Now I see an article praising those who work hard to let Microsoft's
People: Make up your mind, or find a new hobby. people.
If you celebrate Xmas, befriend me (538
Imitating MS when you should be beating them is a waste of time.
;-)
More often than not, imitating others is a way of beating them. I guide you to Microsoft if you need someone with better experience in this area.
Beware: In C++, your friends can see your privates!
It essentially means they wrote the compiler in C, and didn't write the compiler in C#, just to paint themselves in the corner and have a chicken and egg problem on how to compile a compiler written in C# if you don't have a C# compiler. I thought this was kind of odd myself, seems like a pat on the back for not doing something stupid, unless someone could point me to some need to compile a compiler in it's native language.
gcc itself has a bootstrap problem. The gcc code itself is actually pretty gcc specific, non-standard C code that can't be directly compiled correctly by other compilers. So there's an extra step, the gcc build routne adds a bootstrap compiler - youdon't compile the real compiler directly, you compile a small 'gcc-ish' compiler that though not complete, has a sufficent enough subset of gcc-isms to compile the real compiler.
Since Mono is written in C#, it needs a C# compiler in order to be compiled, while Portable.NET is written in C, so it just needs a C compiler, like gcc, to be compiled. If Portable.NET gets good enough, maybe it could be used to bootstrap Mono instead of the Microsoft C# compiler.
I like moft, and I follow their technological advances closely... and both of these platforms have got me wondering if some really high up technical person just made the call without consulting the lawyers...
Hah! That would be sweet: having a mole inside Moft.
I don't mean to be picky, but I think one should make sure the term ".NET" (which usually mean the entire platform) isn't mixed with the ECMA standardized C# language, which might be what you meant since you later said "... wish it was open like C, C++ or C#".
:-)
.NET, I use something like ".NET Framework" if that was what I meant.
I usually try to avoid this confusion by never using simply ".NET", since no one can really explain what it is due to how huge it is, just like the Matrix.
Instead of
Beware: In C++, your friends can see your privates!
Problem: if you write your C# compiler (let's call it csharpc) in C#, how do you compile csharpc itself? You can't use csharpc :-)
.Net) to compile a version of csharpc which will run under the Windows C# interpreter, then somehow make csharpc output Linux native code (because it can't output .Net bytecode and expect that to run on Linux until there's something to compile the interpreter for Linux, and we don't have a Linux version of csharpc to do that with yet). That's messy, to say the least.
You have to use the Microsoft compiler (from Visual Studio
On the other hand, if you're DotGNU and write your C# compiler in C, you can use existing C compilers like gcc to compile csharpc. Once that's done you can write the interpreter and runtime libraries in C# if you like, since you now have a Linux copy of csharpc to compile them with.
(Replace Linux with your non-Windows OS of choice)
It'd seem sensible for Mono to use DotGNU's compiler to bootstrap stuff now it's working, although there are probably obscure reasons why they can't.
If you are writing a C compiler in C, how do you compile it in the first place?
Traditionally, you compile by hand, which produces crappy but working code.. then you use the resulting compiler to re-compile, yielding clean code.
Get the release and report bugs if you can find !
PS: assigning them to me does not count as funQuidquid latine dictum sit, altum videtur
I guess I have some rather severe misgivings about this - how useful is this going to be given the lack of the proprietary MS libraries that you are going to need to run real-world applications, or move code in a portable fashion from one machine to another?
It's nice to have something like a this in the free software regime from a technical perspective, but is it really ever going to be anything but a little sister to the Microsoft version? Won't that reality diminish the corporate view that Linux is really just a hacker's toy, and if you want the real thing get Windows?
Interoperability and portability are good, but interoperability really occurs at the protocol level, and portability requires libraries.
I can see this resulting in are misleading market claims from Microsoft saying things like Lookie Here C# code is portable just like Java code !!
One good thing that could come out of this is that it might force Sun to loosen it's grip on Java a bit so that we get more serious open JVM's etc.
Very robust and well thought out language. Yes, Yes, I know blah blah blah M$ this and M$ that. But ya know what? I could give a flying crap about everyone's predisposition against Microsoft.
.NET -- not it's Windows-specific libraries.
I'm not sure Microsoft should be thanked for the greatness of the C# language on it's own, which I'm sure most of us agree is the best thing of
Thank Anders Hejlsberg, chief architect of the C# language, instead.
While I'm on the topic...
Anders Hejlsberg interviewed about C# #1
Anders Hejlsberg interviewed about C# #2
Pretty interesting, where he discuss the design goals of C#, how satisfied he is with what C# became, etc.
Beware: In C++, your friends can see your privates!
This is an interesing development. However: I wonder how useful this language is on non-windows platforms. Let me explain.
You see, I have just started a new job that is heavily leveraging the
If you haven't written JScript, VBScript, or WSHScript, you have no idea just how amazingly powerful this is. A database connection & query takes around 4 lines of code. I was able to master in-code LDAP (Lightweight Directory Access Protocol, aka Active Directory on Windoze boxes) queries in less than one day, having never touched an LDAP server in my life prior to that.
.GNU project aims to bring ActiveX functionality over to *NIX, and port all of the cool ActiveX objects like ADO (Database), DOM (XML), System.DirectoryServices (LDAP), FSO (Files), etc.
Sadly, *NIX has never really implimented anything like COM. Each programming language still has to be manually extended in some form or another to recognise new APIs -- headers for compiled languages (and remembering to link to the libraries), or worse, "extension agent" coding for dynamic languages like Perl and Python (assuming the API code is a binary shared library). And APIs are almost never identical accross multiple languages.
So, really: what is the need for C# on *NIX? None of my c# code that I am writing will port, because it is heavily dependent on the COM/ActiveX objects to get the real work done. Unless the
Is thes even feasible to do?
Well, Hejlsberg works for M$, so yeah, I think M$ gets a lot of the credit. I know my company takes credit (and blame) for the code I write.
Brevity is the soul of wit
-- Polonius
Nope.
.NET always faster then java if implemented properly on intel architecture. It is the fact that it is a little endian standard while java is big endian. Assuming everything else equal .NET will always win. That is besides the fact that many third llparty developers will actually prefer to deal with an ECMA standard language then with a Sun standard.
.NET. Sink Java. And so far it is proceeding very well on target and on schedule with the help of the GNU community. Nothing bad about it, I hate java so any means of killing it should be cherished and supported. The problem is that after sinking java MSFT can deal with competitors on their own turf exactly as you describe and we will be back to square one where we began. To perl and python as the only "portable" languages.
First, they are trying to do a full ECMA certification for NET and make it standard. In order to do what you are saying they will have to withdraw from the certification standard which immediately gives them a serious disadvantage in the war against java which is what this shit is about.
Second, deciding to apply for the certification process they have taken into account that making the language a standard will create alternative implementations. Not just GNU. There will be commercial ones as well. And that is the idea. Because there is something that makes
This is the idea of
Baker's Law: Misery no longer loves company. Nowadays it insists on it
http://www.sigsegv.cx/
In comparison, Sun has granted the Apache and all open source developers FULL access to the specs, test kits and granted the full rights to develop competing products under the JSPA. Sun mhas also fully opened up the Java development standards process under the new Java Community Process (JCP).
There those that claim that .NET is open to re-implementation, but until Microsoft make a simliar public legal declaration to Sun's JSPA, any .NET reimplementation represents a pending legal mindfield.
The sum of the alternatives makes you better. If you have everything + more, you are better. If you have your own strength but none of your competitors strength, you are not just better in the usualy sense.
.NET implementation doesn't take options away from you and people can do whatever they like with their time, so if they offer one more option, i don't see the problem.
.NET was "owned" by somebody else, so that there would be no fears of a danger of trusting that technology (patent and IP wise), that's the only danger i see.
Having a
We all wish
unfinished: (adj.)
real programmers write their first compiler in assembly of course...
MP3 Search Engine
1) .NET != C#
2) Not everything is part of the ECMA standard, i think just the language and part of CIL spec.
Being a standard, it doesn't mean it's not patented stuff, so it's free now, but will it be free tomorrow?
unfinished: (adj.)
"C$", at some point, someone is going to try to use it. Probably Microsoft. Or maybe they wanted to patent C$ but made a typo (they are next to each other). Or maybe it's just what they meant, but of course, they couldn't just go and name it C$, so they chosed the closest thing that looked right.
We know Microsoft choses names by methaphores or analogies, and never by pure luck or randomly.
Now the big question is what are the dangers of embaracing they IP that now looks "free" but may not be so in the future. I don't know, there must be something I am missing here.
unfinished: (adj.)
"mono is self hosting. meaning you can use it's own compiler to compile its self"
Yes, but somehow the *initial* Mono compiler had to be compiled, and to get that far MS's own C# compiler had to be used as a bootstrap compiler. After that initial compile, Mono no longer needs the MS compiler, but it had to be there originally to bootstrap.
Hehe.. Yeah, I guess I wasn't clear about what I meant with that post. What I meant with "I'm not sure Microsoft should get credit" is that I don't think the end result of C# would be what it became if Microsoft hadn't got their hands on one of the greatest language designers there are today. But I admit I should have said something more along the lines of "out of the C# design team, I think a lot of C#'s power depended on Hejlsberg's ability to give C/C++ developers a RAD language that is much more powerful than anything Microsoft has brought us before".
Beware: In C++, your friends can see your privates!
Microsoft isn't going to do anything - This is just peachy for them. When you have the universe breathing down your neck because you're financially abusing everybody else in the universe, having somebody else implement your system on another platform is really a *good* thing. Makes MS look pretty good where anti-trust is concerned.
I'm guessing that the angry one here is probably Scott McNealy.
Sorry, Scott.
I thought that traditionally you run your compiler on some other box that already has a 'c' compiler (and compile your libraries there too), then link and pop over the binary and off you go.
The first c compilers were written on a pdp-11 by K&R in a language called 'B', hence it's called 'C'
MP3 Search Engine
one more addendum to that, if you can get your hands on a bbc micro emulator (or the real thing if they are still around) and get the BCPL rom, that's as close as you'll get to running 'B'.
MP3 Search Engine
there is a thing called hand assembly, it's been a while, but in the 6502 days if you couldn't afford an assembler you coded your stuff from the opcode book (KIM 1 comes to mind). It's pretty hard and one mistake and you wipe out your whole program so you'll have to key it in all over again. Especially branch computation sucks.
:)
Lucky you if you have the tape interface
MP3 Search Engine
I use to strongly think/believe that Linux was THE alternative for Microsoft Windows. But all we have become is another emulation of it? I guess it's safe to say we are the no-fault stunt double and they never get fame or truly nobody knows they are. Shouldn't it be time for gnu, linux, et at; to produce and come up with their own standards? I just don't want to be a follower, I want the leadership position.
+++ David Watts 5495 0.0 0.5 1888 884
So what's the appropriate prior art on .NET? I know they didn't come up with this shit entirely themselves. How much of it is from prior applications (COM/DCOM) and how much of it is ripped off from CORBA... Also how much of it is ripped off from Java?
"You're right," Fisheye says. "I should have set it on 'whip' or 'chop.'"
The bigger issue is not so much COM or not. For example, there's always XPCOM that was developed as part of Mozilla.
The Microsoft advantage is the Microsoft disadvantage: there is a single vendor to cast interfaces into concrete.
In practice, I'd expect the most sucessful interfaces to become available as interface libraries to UNIX tools (in your example, that OpenLDAP would come with a C# interface in much the same way that Perl interfaces are ubiquitous in UNIX).
Having a choice between "vendors" in the UNIX world has advantages and disadvantages too, but plumbing between libraries and a language is a small matter of programming. How well it can be implemented is dependent on two factors:
How well the C# interface is documented
How well the MS code is written
The latter may sound surprising, but experience shows that the hardest thing in emulating MS libs more often than not is getting the implementation bug for bug compatible.
My experience has been mostly with C libraries and Perl interfaces, and I've never lost too much time gluing stuff together. Making that glue code reusable is much harder, and is helped a lot if you have an interface specification available (Java did a lot of good work in that area, and rumor has it C# does a good job at it too).
Documentation of the interfaces is what the success in practice hinges on.
Bert Driehuis -- All I asked was a friggin' rotatin' chair. Throw me a bone here, people.
"When all you have is a hammer, everything looks like a nail." -- Abraham Maslow
If you think C is the talismanic ne plus ultra of programming, I really think you need to get out more. Learn C++ and the STL; see what processor-intensive stuff you can do trivially with it. Learn LISP and grok the lambda calculus and the beauty of functional programming. Learn Python and Perl and see the coolness of executable pseudocode.
If the only language you let yourself use is C, then you're limiting yourself in ways which aren't good for either your mind or your career. C is a good tool and one that ought to be in every hacker's toolbox--but just like you can't be an effective carpenter if all you have is a hammer, you aren't going to be an effective hacker if you keep on swinging C at problems which call for LISP, Smalltalk or SPARK solutions.
I'd conjecture that Mono's commercial nature doesn't limit community participation any more than DotGNU's particular political holdups. In fact, I'd go so far as to say Mono is more open. It has many signs of a very healthy open source/free software project which DotGNU lacks, like localised groups of developers (mono-es) and active involvement with multimedia and GUI projects, dozens of active contributors and in this case a healthy followership in the Windows world. I've yet to hear of patches to Mono being rejected because of Ximian.
How did this get a score of 4? .NET will always be faster than Java on Intel because of endianness issues? There are so many other factors affecting performance that endianness issues don't even come up unless you are writing a streaming video codec or something. Why does this author hate java so much? .NET is not so different from Java in many ways. Java is great stuff.
This is all true, but right now people who choose to help or participate in the DotGNU/Portable.NET project are precluded from participating in mono-hackers which is the mailing list devoted to technical discussions about Mono. That is a clear limit placed upon the Mono project because of it's affiliation with Ximian. Miguel does not want Mono developers who are also affiliated with Portable.NET on the mono-hackers list because of confidential information relating to contracts Ximian has, or will have, with various groups. This limits Mono developers, who are also interested in Portable.NET, from contributing to technical discussions about Mono.
Then the community has an excuse to fork the standard. The FOSS community has an impressive degree of leverage -- just look at how Bruce Perens' threats to fork Web standards made the W3C reject RAND licensing.
.NET framework is a very useful tool in itself, without MS compatibility. It suits the FSF's need for a flexible, secure, fast, language- (as long as the app is somewhat C-like, anyway) and platform-independent infrastructure for the development of network aware applications and services.
Besides, the
OLPC Australia
The MS reps I've heard have stated multiple times .NET is a Windows-only system, only that it would "play nice" with other standards.
.NET on windows and windows only.
.NET vs Java: Java gives you multiple vendors while .NET traps you into one.
.NET run on other platforms, but you can bet the bank they'll do everything in their power to keep it a "windows preferred" platform.
They're quite frank about keeping
In fact that's what Sun is selling in every debate about
MS may let
Why not try writing them in Objective C. It's very powerful is flexible enough to have bridges to Perl, Java, TCL, Python and Ruby and allows you direct intergation of plain C as well as close integration of C++. Not only this but if you're into frameworks, you'll find that Cocoa has quite a lot of them.
This place is really getting full of M$ trolls.
.NET$ "innovation". Bill and his buffoons must be smoking a big fat one with a smile now.... And we are even lighting it for them...
.NET vital infrastructure source code real soon now, since we are so nice in contributing to the hype and fud ourselves. And of course, there is no way in hell Bill will pollute his own spec just for our own good and for the sake of his own pocket... Noooooo, of course not!
.NET$ aberration and you will be the one laughing, not Bill and his monkeys.
Dont you all see the pattern here? Oh geez, let's all begin developping using this so neat C$ language and let's contribute to this so great
The trap is set, and we are happily jumping on the trigger using both feet. Of course, Bill will help us out by releasing his
During this time, Java continues to die slowly, getting fewer and fewer developpers. Don't you realize that we are contributing in digging our own grave?
Java might be not so great, but it is still the only true alternative to this M$ obscenity.
Please people, read the J2EE spec, the Java language spec., and go play with JBoss for a while... Then, come back, and take another look at this
Wake up people!
Zruty
Zruty -- Ruler of Zrutland
This a classic bootstraping problem, you have plenty of them in computer science. Conceptually it's exactly like recursive fucntions
f(n) = n*f(n-1) if n > 0
f(0) = 1,
you describe the function f for (n) in a simpler (n-1) version of itself.
Saying that a compiler is written in itself is misleading, in fact it's written in a simplified version, but powerfull enough to letwrite the first version of the compiler.
For a compiler n usually is 3.
Hence here how the first C compiler has been written.
f(0) was the the initial version, (a subset of C) and if my memory serves me well has been written in Fortran and of course compiled with Fortran to produce the first binary.
f(1) which can compile the complete C syntax has then been writen but in the C subset which f(0) understands, to produce the first complete C compiler.
Last but not least f(2) the final compiler has been rewriten or extended using all the C syntax of f(1) and then compiled with f(1) to produce the final compiler.
And here you are, you process has converged, now if you want to make new enhancements to the compiler, you can use the previous comiler and the syntax it understands (minus the new enhancements)
Comment removed based on user account deletion
The biggest problem I see is that Microsoft is claiming patents on the CLI:
This has also been reported elsewhere and confirmed by Microsoft. What the patents in question are remains unclear; given that C#/CLI also really is just a copy of earlier technologies (and even Java/JVM hardly contains new ideas), the patents are probably bogus, but that wouldn't keep Microsoft from causing big legal troubles.
Note that the situation with Java/JVM isn't much better. Sun has been filing hundreds of patents on Java/JVM-related technologies, some of which look like they are essential for creating compatible implementations (e.g., the bytecode type checking), and Sun's intellectual property policy towards third party Java-related projects and implementations has often been hostile. Sun has repeatedly tried to kill third party Java implementations (all conforming Java implementations depend on Sun source code). Sun has had to be dragged kicking and screaming even to the point where they don't claim ownership of ideas developed by others (!) as part of the community process. And Sun renegged on their promise to make Java a language standard twice. Sun is not to be trusted either.
I think both Sun and Microsoft are equally duplicitous and manipulative when it comes to Java or C#, respectively. My conclusion is that, until either Sun or Microsoft or both make a firm, binding commitment on intellectual property issues, neither platform is suitable for widespread adoption by open source projects. Furthermore, until Sun and/or Microsoft create open standards without even a hint of patent encumbrances, even commercial software developers should consider both systems the equivalent of VisualBasic: a proprietary language that can be changed by its creators at will and for which there will be no viable independent third party implementations.
C# or Java could have been a great thing if they had turned out to be open, standardized, and widely used. But, frankly, there are plenty of better languages and runtimes than either C# or Java around anyway, so given that those languages remain proprietary, why bother with them?
There are four GUIs available for Mono which can be used for Portable .NET and Microsoft .NET too.
.DLLs for Windows.Forms to run on Windows.
1. GTK# - C#/CLI Bindings to GTK+ 2.0. Works on Windows and Linux. It also has C# Bindings for GNOME 2.0 as GNOME#, GConf as GConf#, Glade as Glade#, etc...
http://gtk-sharp.sourceforge.net
2. QT# - C#/CLI Bindings to QT 3.0 and KDE. Runs on Linux, but it is difficult to run on Windows though. It currently uses QtC for its C# bindings, but this will change.
http://qtcsharp.sourceforge.net
3. Windows.Forms - the System.Windows.Forms like GUI uses Winelib in Wine and monostub.exe in mono to run on Linux, and it uses native Windows
4. ASP.NET - System.Web works on Linux and Windows. It can be tested with XSP test server.
So, to test this, you will need mono, mcs, and xsp.
This is wrong, or at least highly misleading. Sun has granted rights only to standard developed under the JCP from here on forward (and then only to participants in the JCP):
Sun has hundreds of patents on core Java technologies that are unrelated to JCP efforts, and Sun has granted no licenses to those. You would likely run into those if you tried to create an independent Java implementation.
Both C#/CLI and Java/JVM should be considered proprietary platforms covered by numerous patents. And both Sun and Microsoft have demonstrated that they cannot be trusted on intellectual property issues or commitments to open standards.
There are plenty of high quality, truly open languages and runtimes out there. Open source software developers are fools to waste any time on either C# or Java until Microsoft and/or Sun make binding commitments to make those platforms truly open.
Be quite concerned about Ken Thompsons idea. now shouldnt they?
Why aren't they porting .NET/Windows Forms and so on to OS-X? For starters, it would make it easier to maintain their Office software base on a common platform. Are they worried that independant developers would do the same and mess up their master plan?
Sun has to strive for true platform independence with its Java, but since Microsoft is the Apple silent partner, what would be wrong, from Microsoft's dark, evil perspective, of running .NET on both Windows and Mac -- they run Office both places while there is no such thing as Linux-Office.
I see nothing in that patent application that has anything directly to do with C#/CLI. That patent has to do with distributed computation, and it would apply equally to systems implemented in Java or C++. I don't see anything in it that would apply to a conforming C#/CLI implementation.
I have a feeling that if Microsoft, a good-as-convicted monopolist, tries to sue a community of open source developers on a patent basis in order to prevent interopability, they will get their balls chopped off in court.
Or at least the defense will have a very strong case.
Erik
I've yet to see anyone address this point, which must be made. I'm not sure what that "remoting and web service architecture" is. I don't know. But I damn know one thing: in three or four years Microsoft will obsolete that technology, and it will be replaced with something else.
Microsoft receives significant revenue from training armies of MCSE, using endless arrays of certifications and development programs. And, as such, they have a vested interest in keeping the revenue alive with what I call a "steady technology churn." They can't just pick an API, and go with it for the long term future. They need to force all the MCSEs back into the training camps, in order to make sure that their paper certifications do not expire.
I dabbled with some Windows programming, many years ago. You wanna know one thing? Nothing that I've learned back then is worth today any more than a hair on my ass. VBX controls, DAOs, all of that has long been made obsolete. I've done _nix programming for quite sometime before trying the Windows waters, but I quickly figured out what was going on: that the primary occupation of a Windows developer is to provide revenue to Microsoft, in terms of continuing MSDN subscriptions, fees for an endless stream of documentation for Application Interface Of The Year.
"Developers, developers, developers", indeed...
So I quickly ended that short term experiment, and went back to hacking _nix. The thing about _nix -- which is 180 degrees opposite of Windows programming -- is that the skills and the knowledge that you've learned ten or fifteen years ago is still used, and is as valid today as it was back then. If you go and learn today's crop of Windows APIs, in just a couple of years all the time you've spent today would be a complete and a total waste of time, because nothing that you've learned now is relevant any more, it's been obsoleted.
On the other hand, things like file descriptors, pipes, sockets, and other basic POSIX APIs will still be just as useful ten years from now as they are today, and as they were ten years ago. That is not to say that you won't learn anything new in the mean time. On the contrary, I have learned many great _nix technologies over the years, and I'm sure that I'll keep learning more exciting stuff in the years to come.
The key difference is that everything that I will learn will only complement, enrich, and add to my existing, growing base of knowledge. Unlike with Windows, where its only purpose would be to replace stuff that's been obsoleted by Microsoft. As a Windows programmer, I'm in for a lifetime's worth of a struggle to keep churning through one API after another, one Microsoft language, or library, or interface API after another, all while being milked by Microsoft for the training and development fees in the mean time. As a _nix programmer, I'm in for a lifetime of enrichment and expansion of my technical skills and knowledge.
You really should have given objective-C a shot. It's damn nice and much much much much much better then C#. Plus webobjects is a tour de force.
War is necrophilia.
It may not be perfect, but at least it is fully open.
What would cause the court system to extract it's nose out of Bill Gates' ass?
War is necrophilia.
What precisely do you mean by "full ECMA certification"? Last I heard it was just the language itself and none of the libraries. Which is effectively the same as none of it being submitted since MS can still break compatibility across platforms that they themselves don't support. So it boils down to trust, which I have zero of in MS.
.class file, the constant pool contains
As for your endianness claims, here's part of two messages from a Google group search on the issue:
One:
"Java specifies the endianness used in object files, and (I believe) the
endianness used when writing numbers to binary data files, but the
language is defined in such a way that there is no way for a program to
tell which endianness is used for in-memory representations. So long
as the JVM (Java Virtual Machine) implementation does the correct
conversions when reading in `.class' files and when read/writing binary
data files, it is free to use a little-endian represention internally."
Two:
"If you'd bothered to study the JVM before jumping to such conclusions
you'd know that, in a
_unaligned_ data of _variable-length_, endianness is completely
irrelevant. The thing _has_ to be parsed byte-by-byte... Not even
the bytecode vectors are aligned within the file, although the
tableswitch' and 'lookupswitch' bytecodes are word-aligned within the
code vectors, so these are the only constructs that would require
extra work on a little-endian machine, and only in the 25% of cases
where the code vector happens to be word-aligned by accident....
Incidentally the format of the constant pool _inside the JVM_ is
completely undefined and up to the implementor."
"Gold still represents the ultimate form of payment in the world." - Alan Greenspan, 1999
The DOJ negotated Microsoft Communications Protocol Program effectivly grants Microsoft the ability to boycott GPL/LGPL licensed implementations.
That is, almost everything in the Java 2 platform is completely Sun proprietary. Sun even renegged on standardizing it through ISO/ECMA, which would at least have required them to disclose what patents apply.
C#/CLI has patent problems. But so does Java/JVM, and at this point, they look more serious than those with C#/CLI. If you want an open platform, you have to look somewhere else: neither C#/CLI nor Java/JVM fits the bill.
Go to the US Patent Office's website and do a search yourself ( hint "AN/Microsoft" ), there are plenty of examples of patents to be concerned about.
Here is a story talking about an open source version of the .NET arcitecture, and right below it is an ad saying, "BUY M$ Visual Studio .NET TODAY!"
Portable .NET sounds pretty neat. However, will it be useful? Assume that it's a success. It 2004 and several corporations are deploying Linux servers to serve department-wide .NET apps, hereby deprived MS from revenue it extracts from heavyweight .NET servers. What prevents MS to change critical parts of the .NET standard in the next iteration? Nothing. It's even likely that the new additions will be heavily patented to protect them against compatible servers. The next generations of .NET apps will then be uncompatible with the portable version and customers will have to revert to all-Windows shops.
Mind you, this is not a flame or anything, I am just trying to be practical here. Anything that can give people breathing rooms when it comes to MS standards is good. But here, I am really afraid that as soon as the portable .NET will start being successful, MS will notice it and intervene.
Any reason why the scenario above could not be implemented?
--
Mad science! Robots! Underwear! Cute girls! Full comic online! http://www.girlgeniusonline.com/
From Effort on the edge, Part 1
At least Sun is making concrete steps towards being more open.
Where are the equivalent public declarations from Microsoft?
of course, vi stands for 'visual', and we all know that anything that makes light of the fact that it's 'visual' has to be a microsoft product in it's roots, which of course, makes it inherently bad.
and the 'K' desktop environment? What are they thinking? With that white toolbar, and the blue background, we all know what they stand for. WASP (white anglo saxon prostestants)'s only for this desktop!
You are reaching if you think that combining Sun's statement on the JCP together with some minor revisions of Java2 mean that Sun makes available all their patents for free Java implementations.
At least Sun is making concrete steps towards being more open.
Sun has made no legally binding commitments on keeping Java open. Sun even pulled out of two standardization processes because they didn't even want to disclose their patents, let along license them.
Where are the equivalent public declarations from Microsoft?
There are none (well, they have committed to RAND, but that's of no interest to open source).
The upshot is that both Microsoft and Sun are spreading PR and FUD. Neither of them has made any legally binding commitment to an open system or language. Neither system offers anything technically new or interesting. That's why the open source community shouldn't waste any more time on either of them.
Personally, I really don't see the advantages of Java or C# outside a specific application domain. For heavy systems level work, C++ is superior, because once your needs branch away from what is provided in the standard libraries of Java or .NET, there is a far deeper and broader collection of libraries available for C++. Plus, both Java and C# have an overhead that C++ simply does not have. For applications where performance isn't critical, a *real* high level language is in order. Java and C# claim to be high level, but in all truth, outside of their standard libraries, there is not a whole lot (aside from removed features) in the base language that seperate them from C++. Assuming you have the same libraries for both, and are a competent C++ programming (meaning you use the STL to the point where new/delete are rare in your code) Java/C# code is just as long (or, in the case of Java longer). Python, in comparison, feels like a real high level language. Python code is an order of magnitude shorter than most Java/C# code and much easier to read. Once the new Parrot VM comes out (supposedly it has JIT compiling) these higher level languages will get a significant performance boost, and will be far more appropriate for many applications than Java or C#.
A deep unwavering belief is a sure sign you're missing something...
If you want to talk about patents more generally, yes, Microsoft is patenting a lot of C# related stuff. But so is Sun. Both companies are lying when they say that they are creating "open systems". We have no more reason to trust Sun than Microsoft.
The best approach for the open source community is to give both Sun and Microsoft the cold shoulder. Let McNealy and Gates play out their megalomaniac power plays and let us get on with writing good software.
Shinoda: "The age of Millennium."
Io: "What does that mean?"
Shinoda: "A thousand year kingdom. It wants to create a home for itself.
A thousand year Reich. Wasn't that innovated by someone else?
As a .NET developer I don't give a rats *ss on which platform my software runs, but currently it's just Win2k + .NET (from MS), fine by me. If Mono succeeds on Linux, I can run my software without modification on Linux too, which is a good thing since then the amount of servers which run my software increases, and thus my potential customer base grows too.
.NET on Linux however, and .NET really takes off (it already begins to do that), Linux won't be a logical choice for the application server platform. In other words: linux will go down the same road Novell took years ago.
If there will be NO
Never underestimate the relief of true separation of Religion and State.
Ok, that some people don't understand the big importance of a good, solid, 100% compatible .NET framework on Linux, fine.
.NET framework on linux so ALL the developers who understand the importance of .NET on Linux join forces and work on 1 platform only (I prefer Mono for this, since it's intentions are better: 100% compatability with MS' .NET api).
.NET: DotGNU!
.NET first so Mono will be behind that release for another year) and another platform, DotGNU with functionality that only complies on the ECMA standard, and thus is pretty useless in everyday applications, since System.Data, System.Web.* and System.Windows.* are pretty useful. (understatement).
.NET developer on Windows I'd like to see a solid .NET platform on f.e. Linux which is compatible with .NET from MS so my customers won't have to use Win2k or Win.net server to run my ASP.NET applications, but have more of a choice. When there is no .NET platform on Linux, Linux is not interesting for me or for my customers, and believe me (looking at what power is inside ASP.NET f.e.) in the future also not interesting anymore for a LOT of developers.
But... why 2 frameworks? (Mono and DotGNU). Why is it so damn hard to just focus on the importance of a solid
Now, Mono can use more developers but these developers are working on their own port of
I know this has something to do with politics, something to do with licensing. It DOESN'T have anything to do with different technical views on the matter.
I simply can't understand why people are so far fetched focussed on politics instead of the art of software development. Now Linux will probably end up with Mono being finished way too late (if it's not finished in 2003, MS will release generics in
As a
Never underestimate the relief of true separation of Religion and State.
just look at how Bruce Perens' threats to fork Web standards made the W3C reject RAND licensing.
You know, this is pretty hysterical. You're looking at the world through the microcosm that is Slashdot. The W3C didn't reject RAND because of Bruce Perens, they rejected it because their members didn't want it, and because many people in different communities (the XML community, the Web community, the vector graphics community, etc) fought against it. RAND was really unpopular in all but the larger members of the W3C (e.g. Microsoft, Adobe - and even they fought internally about it), because companies realised that they were better off with RF specifications.
Matt. Want XML + Apache + Stylesheets? Get AxKit.
Your ignoring the last paragraph quoted from Effort on the edge, Part 1
g4dget wrote:"Sun has made no legally binding commitments on keeping Java open.".
At least Sun's Robert A. Gingell Sun Fellow & Vice President has published a Letter of Intent which includes the declration
Which at least is an effectively legally binding commitment for the aformention JSRs.
It's a start, and it's value should not be dismissed lightly. Once again, Where are the equivalent public declarations from Microsoft?
Why will not Sun pull out of this accord? - Because, increasingly, it is not in Sun's self interest to do so.
Sun has adopted the LGPL/GPL licensed GNOME Desktop for both it's Solaris and Linux systems. In fact so much more open sourced software is being deployed on their systems, adding value to the platforms, that it is not in Sun's interest to limit free lisenced code interoperation with the Java frameworks.
For similar reasons IBM and other Java licensese are pressuring Sun to further open up the Java enviroment.
In it's comments of the voting for the new JCP IBM even commented:
Forces are moving into place which is going to make it very difficult for Sun to backslide to a close model again.
As for FUD, it seem to me that over time, Microsoft is becoming the sole dominant player in lies based on untruths.
By the way g4dget, are you any relation to John Carroll?
Sun will be submitting the updated J2SE, J2EE etc to the new JCP, and therefore are effectively granting open source developer members full rights to re-implement the standard.
Do you need to be cautious, yes. But is it safer to create an open source Java framework than to re-implementing .NET - Hell yes.
There is nothing legally binding there. Sun can do whatever they want at any time, and they can define whatever they like to be part of the JCP or not.
But is it safer to create an open source Java framework than to re-implementing .NET - Hell yes.
Why re-implement either if neither company is playing fair? There is nothing technically particularly interesting or novel about either language.
I have. I have learnt that allowing Microsoft to set "standards" is like walking up to a tiger with a plate of raw meat and thinking that it won't eat you too.
TWW
"Encyclopedia" is to "Wikipedia" what "Library" is to "Some people at a bus stop"
If you think that a statement of intent on a web page somewhere is a legally binding contract, I have a bridge to sell you.
Once again, Where are the equivalent public declarations from Microsoft?
Who cares? Neither Java nor C# break technically any new ground. They would have been interesting if they had become open standards, but neither did. Instead, they have become a quagmire of patents and intellectual property claims. Why argue about which one is the lesser of two evils? The open source community should not touch either of them. Let Sun and Microsoft battle it out; let's hope they'll sue each other out of business.
By the way g4dget, are you any relation to John Carroll?
What an idiotic question. You think everybody who isn't enamored with Sun must be a Microsoft shill? I don't work for either Sun or Microsoft. As far as I'm concerned, Microsoft management consists of a bunch of megalomaniacal sleazeballs, but so does Sun management.
Now, what about you? You keep deflecting criticism of Sun by making completely irrelevant comparisons with Microsoft. Do you work for Sun by any chance?
And Why re-implement either? - Opens source development often follows the successful strategy of finding a standard that works and re-implementing it and building upon it. Linux from Unix, JBoss from Sun's J2EE specs, etc. .NET, who should open source developers choose?
If it comes to a choice between one of the dominant webservice standards, Java or
It's interesting to compare his previous work (Delphi) work .NET
Delphi was and still is rightly praised for being incredibly kickass. Outside of indie Windows development, Pascal is a dead language, but there is a truly astonishing amount of code written in Object Pascal for Windows - even Microsoft have used it for some products.
So I found it interesting to do a comparison. He clearly took some ideas from it to integrate into C#. For instance language integrated properties are something I constantly wish that Java had. The "uses" clause became "using".
Anders pats himself on the back for using XML comment tags though. Big mistake IMHO, xml comments are one of the most irritating things about C#. The start and end tags serve no purpose except to make the file larger and harder to read. JavaDocs are more elegant and easier to write. Using XML in many cases is a good decision, but here it is not. But then there are some curious omissions. Delphi doesn't use an IDE that generates gobs of code for user interfaces, it uses binary resources that are reconstructed from data embedded in the EXE/DLL files at runtime by the class library. It's clean and elegant. But what does VS.NET use? IDE generated code of course.
I guess it's only realistic that most of the innovation in .NET comes from perhaps one or two people, while the rest merely reinvents what came before. After all, the reason that innovation (whatever that is) is so highly prized is that it's rare.
On the other hand source code is much more preferable to separate binary resources. Firstly it all in the same file, so your project management becomes much simpler. Secondly it's trivial to support source control systems (CVS, SourceSafe, etc...) - with binary resources it's hard to track incremental changes.
One of the features most requested for early versions of Visual Basic was to convert the form layout resources from binary into text and embed them in the form source file for exactly these reasons. And they did this, although you don't see the textual representation of the resources in the editor - they're hidden just as before (unless you explicitly want to see them). Microsoft didn't just do this because they thought it might piss you off, they did it because people asked them to, and it makes sense. Besides, it's not like it's 'gobs' of code, but even if it was, who cares?
C# was developed in house. Some of the concepts behind CLI and CLR were pre-existing but even then only parts. After all, UCSD p-System predates MS-DOS and it wasn't the first.
If the Apache foundation lawyers have a signed paper copy of the aformentioned letter, yes.
g4dget wrote: "The open source community should not touch either of them.".
Opens source development often follows the very successful strategy of finding a standard that works and re-implementing it and building upon it. It is possible to reimplement standards based on proprietary products but due care should still take place
GNU/Linux is a implementation based on Unix and the Posix standards. Unix was proprietary licensed by AT&T, and early open source BSD386 (what became FreeBSD and NetBSD ) development, which replaced the remaining proprietary AT&T code in BSD, was greatly hampered by threats and lawsuits from AT&T. Early Linux development escaped legal entanglement precisely because the developers took steps to insure no such code mixing with AT&T's source took place. However, this took place before software patents were in widespread use, in fact it was not until 1991 that most software companies took any interest in software patents at all.To quote Bill Gates May 16, 1991 email "If people had understood how patents would be granted when most of today's ideas were invented, and had taken out patents, the industry would be at a complete standstill today."
Does this mean that the open source development community should avoid any and all frameworks and patented methords? NO - There is a better way.
The solution is to start a negotiation "dialog" with all the parties involved, getting them to actually support open source implementations and licensing based on their proprietary products. How? It's not easy but it is possible. .NET spec and patent licensing by continualy comparing them to Sun's terms.
1) Win-Win: demonstrate how it is in there best interest to work with the open source community - using open source developed code to ad value to there own products
2) Reward : Any relatively good behavour, incomparison to other players, reward - say thank you and promote them.
3) Converted partners : When you have made a "convert" to open source, such as IBM and SAP, them to badger other partners into also adopting open source friendly licenses.
4) Comparison : play one against the other, Get Microsoft to open it's
5) Badger, Badger, Badger them with the truth : Long conversations and confontations are tiring but it forces the other side to truly consider the issues.
In the long term, does it work? Yes. With the X Window System, in 1998 the Open Group releases X11R6.4 under restrictive licensing, after months of haggling and bitter arguing, The Open Group rescinded the restrictive licensing. On November 14th of this year, again after months of similar haggling and bitter arguing, the Patent Policy Working Group of the W3C announced the Royalty-Free Patent Policy.
It's ironic, but the open source friendly licensing model actualy bring about a solution to the software patient problem proposed by Bill Gates himself in the same email, patent exchanges - "The solution to this is patent exchanges with large companies and patenting as much as we can". Since no company can aparently truly trust the competition in long term relationships, open source friendly licensing provides a methord where competing parties can build upon each others patents.
g4dget wrote: "You think everybody who isn't enamored with Sun must be a Microsoft shill?"
Well, the tactics you employ under the shear weight of contradictory linked evidence is a tactic I find often applied by members of the Microsoft Shill persuasion. No, I don't work for Sun, IBM or any other vendor in the IT industry, but I do admire and promote postive behavour when I see it.
There is one big advantage to Delphi's binary approach. The interpretation of that binary resource is in the actual widget class itself, so if you knew which methods to override, you can customize how that binary resource is written at design time and read back in when the thing runs. Overriding Delphi's GetChildren and GetChildOwner and you can go to town making widgets containing lists of Designer-accessible widgets.
You can do the same thing in C#/.NET to render configurable collection widgets into code, but it you have to create your own collection classes by overriding gobs of methods and it doesn't do quite what you want, and to customize further you have to get into the code-generation API (ew, gross!).
C# is OK but Delphi rules.
I don't like IDE generated code because it means you have to use that IDE to edit it - kind of tool lockin if you like.
This is an excellent step forward for Microsoft on the desktop. As corporations begin to adopt Linux servers, Microsoft software will be able to dominate rather than being left out in the cold.
Congratulations to Microsoft for their success in subverting these open source developments.
Shhh... remember that DotGNU and Mono have never specified meaningful objectives - that would allow their success to be measured, and this would affect the hype factor.
Real objectives would concern real value: the portability and interoperability of products/developments that organizations actually use. Better to stick to announcements about how the C# compiler is now self-hosting, or how someone somewhere is thinking about looking into the feasibility of implementing part of some Dotnet library.
A few months ago ISTR making comments like this to Miguel de Icaza. His response? That people once said the same things about Linux. This appears to be how these guys think - Dotnet is some static, open, well-defined, low-level API and that cloning it is a one-off effort that entails no risk ands cedes no control to MS.
Personally I wouldn't touch this stuff with a bargepole.
You don't say! Moral high ground? I'll certainly raise this at the next XP rollout meeting in my company.
Meanwhile, the rest of us who sup with the devil will be taking long spoons, and praying that Parrot and Kaffe do not fall prey to MS-cloning zombies.
You are expressing exactly the mindset of Adobe, Oracle etc. who will also be developing for this platform.
By clearly stating your requirement for a high-level of compatibility, you are exposing the fundamental weakness of Dotnet cloning efforts:
Unlike, say, Java or Python, the value of Dotnet clones is not directly related to their functionality but to their compatibility. Moreover, this relationship is highly disproportionate - even a few incompatibilities can dramatically diminish their value, since users (other developers) will not make the effort to support the small non-MS market if it compromises their main market developments.
The only viable route for open source is for it to be based on an open platform - a platform unencumbered by compatibility with proprietary technologies. This can certainly make use of Dotnet, but it can do so without ceding control to Microsoft.
I *would* agree, but the problem is that people have frequently taken option A in the past (esp. if a powerhouse like MS is backing it, and MS has made quite a show of backing .NET to the hilt).
ASP. IE/Navigator web extensions. Visual Basic. FrontPage extensions. Javascript that works on only IE. All these were things that (at least at one point) relied on a single company, yet many people chose to go with them.
It's worth considering.
May we never see th
they will have to withdraw from the certification standard
.NET on all their machines. Anyone using extensions is going to have things work just fine on a Windows box. Furthermore, I seem to recall MS going up against Borland, Watcom, and a couple others and squashing them in the past while *using* a language that's quite standardized (C), yet VS code not infrequently uses extensions to C and C++. Matter of fact, the reason the cygwin/mingw/gcc guys don't do MFC is because it utilizes some VS extensions. What makes you think that this would be any different?
.NET always faster than java if implemented properly on intel architecture.
.NET or not.
.NET. That's not really what python is intended to be used for -- general application development. It's nice for rapid development and scripting. Prototyping. Not putting out a finished, runs-on-end-user-systems product like a word processor or a web browser.
Why? As long as they support the language (and presumably a certain set of library code, haven't looked at the exact requirements), they should be gold.
serious disadvantage in the war against java which is what this shit is about
Not really. Has gcc fallen beside the wayside to Sun's or IBM's cc because it supports extensions that go above and beyond ANSI (well, now ISO) C? No. People frequently use gcc or gmake because code uses GNU-only extensions that are useful. I use the --verbose flag of GNU rm in a particular script, for another instance of being willing to require extensions.
alternative implementations
This is completely and utterly not an issue for MS. They ship
Because there is something that makes
True. Java is, and will always be hobbled by performance. I think that sacrificing performance was a fucking stupid idea on the part of Sun, but that doesn't imply anything about whether MS will extend
I hate java so any means of killing it should be cherished and supported.
Ah, well. Someone has to break Goodwin's Law. There were Germans that said the same thing about communists right before Hitler's rise to power...
we will be back to square one where we began.
You mean MS will be in control of the primary popular application development language?
To perl and python as the only "portable" languages.
Um...no. You just quoted performance as being the crucial issue, right? Perl and python are both quite slow languages when compared to real programming languages -- I'm not sure whether perl or python really fall into the "scripting" or the "programming" language set.
Perl is completely and utterly useless for developing a full-scale application. It's a slick language for hacks -- nothing, nothing can compare with the power of ten lines of perl code. But somewhere above a couple hundred lines of perl, I've found that programs generally devolve into unreadability and the lack of types becomes an issue.
I don't know about python -- I don't use it. I suspect that again performance would be enough of an issue to kill it in any fight against
May we never see th
It's possible that the JVM bytecode engine can contain bit-level ops and is big-endian. I really don't know if it is, but it's possible. Other than that, I dunno what he's talking about.
You could always use a compiler that compiles Java to native code instead of a JVM...
May we never see th
Not putting out a finished, runs-on-end-user-systems product like a word processor or a web browser.
:-)
And before someone invokes Sketch, you will notice that the performance-critical portions of the thing had to be written in C. (It also isn't as fast as the excellent sodipodi, though that is neither here nor there. BTW, if you haven't looked at sodipodi recently, it's up to the point where it can be used for (light) production work. I remember when the GIMP got to this point and development exploded. Mmm...Linux has vector graphics now.
May we never see th
If the Apache foundation lawyers have a signed paper copy of the aformentioned letter, yes.
That's a contract between Sun and the Apache foundation, not a contract with anybody else. The license on what Sun ships hasn't changed. Sun's attitude towards "contamination" hasn't changed. Besides, where is the text of that contract? Where are the signed copies?
GNU/Linux is a implementation based on Unix and the Posix standards. Unix was proprietary licensed by AT&T,
But UNIX wasn't patented and AT&T wasn't all that litigious about it (all they wanted was that people honored their copyrights). And POSIX was an open standard, unencumbered by patents. None of that applies to Java (or C#).
Does this mean that the open source development community should avoid any and all frameworks and patented methords?
Indeed, it shouldn't. But it should stay out of the line of fire of two major, greedy, and litigious players.
Well, the tactics you employ under the shear weight of contradictory linked evidence is a tactic I find often applied by members of the Microsoft Shill persuasion. No, I don't work for Sun, IBM or any other vendor in the IT industry, but I do admire and promote postive behavour when I see it.
I do like to promote positive behavior, too. That's why I supported Java and open source strongly during the first few years, when Sun promised to create an open standard, to encourage third party implementations, to improve numerical peformance and type safety, and to open source their implementation. Sun has broken every one of those promises, and the weight of evidence is that Sun is a duplicitous company that is not to be trusted.
Sun, in fact, has a long history of taking open source software and making it proprietary, and that hasn't stopped with Java either. Swing, for example, was also ready to be open sourced (IFC), but Sun took it proprietary. Before that, of course, they built their entire company on BSD UNIX.
Sun is also in trouble as a company, and they have failed to evolve the Java platform technically. This is not a company with which one negotiates or on whose products one builds open source software, in particular since Sun has no technology that is in any way distinguished. In fact, Java has fallen behind technically so badly that it really cannot be recomended anymore.
I don't know whether you are merely clueless or whether you have some stake in Sun, but either way, your arguments don't hold water and the direction you propose for open source is dangerous. We have given Sun more leeway than just about any other company, and they have taken unfair advantage of open source again and again. This should stop now.
Stack-based VMs are much easier to create, but generate a lot more overhead in the JITs. (See Ken Thompson's paper on the DIS VM from the Bell Labs website.) Bickering is bad, but they really want to get it right. You forget, St. Larry has a huge community behind him.
Now,I wish they'd make an ultra-lightweight memory machine VM and implement higher level VM extensions using the VM code itself. All of these higher-level VMs force thier own object models on the code. Perl, Python, etc. get thier object and calling models mangled to be C#-like in order to run on the CIL. Automagic memory management and pointer safety are wonderful things, but stuffing round pegs (Python objects) into square holes (C# objects) doesn't help anyone. I can definately see making seperate sets of registers for pointers and non-pointers (address spaces for mempry machines) and having pointer arithmetic functions cause inlining of helper functions instead of directly manipulating pointers, depending on CPU state. This would allow you per-thread enforcement of arbitrary memory management/object models. If you didn't want pointer safety, etc., it would run blazingly fast. HP had a project called Dynamo where they made a JIT VM that took in PA-RISC object code as its "byte code". On actual PA-RISC hardware, it usually ran very close to native speed, and in some cases exceeded native speed through heavy use of runtime optimization in the critical sections of code.
Anyway, my point is that on architectures with many registers, stack-based VMs are not the way to go for fast JITs. I applaud the Parrot people for taking on such a difficult task. Hopefully we'll see performance payoffs, particularly on non-ia32 machines.
Copyright Violation:"theft, piracy"::Anti-Trust Violation:"thermonuclear price terrorism"<-Overly dramatic language.
fyi: vb7 is very similar syntactically to vb6 and yet it has all of the functionality of c#.
Amazing magic tricks
What, you mean besides two working BASIC interpreters, a Scheme implementation, Befunge-93, Brainfuck, and a partial perl 6 implementation? (Partial because the spec's not done) Nope, nothing at all to show for the work... ;-P