Slashdot Mirror

> PS: you got skills and want to help OSS, join the GNU's Classpath project http://www.classpath.org

Actually, I'd say go work on dotGNU. They're implementing straight from the ECMA specs.

The Crypto api is implemented in C (for obvious reasons) and plugged into the engine. It should only have a slight degradation in performance due to the dynamic lookup of these methods. MD5's just about the same speed as one written in C (ok, maybe 97% is not 100 ... but it's damn near enough for me).

For the non believers have a look at MD5 Code Or Ripemd160 Or Sha512

Looking over the DeDRM code , there doesn't seem to be any places where a performance hit due to array bounds checks are there . (that's coz he's using BlockCopy).

I'd have run this on DotGNU by now (ie it builds and runs, and no todo's around the things it uses) , but I don't have something to deDRM :)

Don't forget these people. The difference between these people and the mono people is the level of zealotry. :-)

The dot-gnu people object to the fact that the mono compiler was written in C# and bootstrapped with with MS C# compiler. So, the dot-gnu people wrote their own compiler in C, not C#, and haven't found a reason to write the compiler in C#.

Yes, definately.

That said, in the middle of FUD that post has some interesting claims, like impractible goals of DotGNU

I'm not sure what you mean with "impractible goals of DotGNU". Fundamentally I'd say that there are two types of goals: "essential goals" and "dreams". With an "essentail goal" I mean a goal which is essential for making the project a success; if we don't reach that goal, the project hasn't been fully successful. For DotGNU, "making it easy to port apps that were written for .NET so that they become truly portable with DotGNU Portable.NET" is an "essential goal" in this sense. With "dreams" on the other hand I mean the type of goal that would be great to achieve, but where it's not really essential to achieve it. I have lots of DotGNU-related dreams, probably most of them will never get realised, but some will, and I think there's nothing wrong with that.

Maybe you mean Miguel's statement "the DotGNU team wanted to invent a new virtual machine that supported Java and .NET at the same time"? That dream is not as impractible as it might appear at first. Read this. We do have a working runtime for IL which has been designed in such a way that there no serious obstacles (besides lack of volunteers) against adding support for JVM bytecode into this same runtime engine. Miguel criticises the JVM bytecode support as "slow, untested, and very broken"; I'm not interested in debating these claims. This JVM bytecode support is not something that we publicise as a feature; rather it's a proof of concept showing that with pnet's design it is possible to implement this, and an invitation to anyone who is interested in JVM-IL interop to come on board and work out the details.

reading Rotor code

Miguel's statement "Pnet follows a different approach: read Rotor, and do a new implementation of it" is mostly FUD. The truth of the matter is that Rhys has asked Eben Moglen, who is the General Counsel of the Free Software Foundation (and also the author of the GNU GPL and LGPL) for legal advice concering the question of whether looking at Rotor code is ok, and received the following response (posted with a bit more context in the pnet FAQ):

My advice is to tell people to code where possible from the ECMA standard. Where (which is likely to be everywhere), ECMA is insufficiently descriptive to create interoperable code, it is acceptable to read the source of the Rotor implementation. Notes taken in the course of reading that source should be made in pseudocode, so that programmers do not copy snippets of the Rotor source as aides to their memory. We want every line of code in our projects to have come out of the original invention of one of our coders, having been expressed in his or her own way. Ideas abstracted from the Rotor implementation should always have been put in our programmer's own "words," because copyright protects expressions, not ideas.

This isn't true. The implementation of DotGNU Portable.NET proves that it can be implemented directly on top of X, without any need for Wine or winelib.

No there aren't. DotGNU Portable.NET has a Java compiler front-end to the cscc compiler which you normally use to compile C# to IL. This Java compiler isn't currently useful (you'll need to port at least the basic class library before you can really use it) and not going forward (because the programmer who worked on it while still a student now has a job that keeps him pretty busy) but it's certainly a good starting point for anyone who wants to work on this.

Also there are no insurmountable technical barriers against the following, more tricky objectives:

• Compiling both Java and C# to JVM bytecode, or to Parrot bytecode.
• Executing both IL and JVM bytecode in the same VM.

I find all this talk about GNOME possibly becoming based on Mono extremely unsettling. GNOME is part of the GNU project. The Mono project is not only not part of GNU, they're even openly hostile to the GNU efforts that they're competing with.

Sure, but this helps only if you can assume that those compiled C and C++ binaries are already installed on the user's computer. The main point of "compile once, run anywhere" is to be able to distribute a compiled program that will run anywhere. Of course in DotGNU, we don't define "anywhere" as narrowly as the Microsoft monopolists do:

Unlike Microsoft's C compiler, whose output will only run on i386-based Microsoft Windows systems, our compiler turns portable ANSI C code into a truly portable executable that will run any platform that has a CLR ("Common Language Runtime"), regardless whether the system is 32-bit or 64-bit, little-endian or big.

Or is it because of some form of hatred towards C#

No. It's because there's a lot of C code out there that people might want to use from C# and other modern languages. Throwing that C code away and re-implementing in another language would be a waste of time.

Read the mailing list archives ... there seems to be enough reason to kick this guy...

( I remember Miguel Kicking a guy out of the Mono lists just because he was working with the Portable.net team... IIRC, one the Qt# guys)

It is almost ironic, that while both Mono and DotGNU aim to support .NET on Linux and various platforms, Miguel claims that "C is dead" while the folks over at DotGNU have been working on the C compiler portion of pnet. In my opinion, it's much more advantageous to support multiple languages and platforms, as to bring in developer support and a wide userbase, than to narrow yourself to a few platforms (I read about Mono just getting ported to Sparc64, while DotGNU's pnet has ran on it for some time, among many many other platforms. Ranging from the Playstation 2, to the iPaq.) and trying to depreciate (In verbal statements or otherwise) other languages. Sone of the major points of the IL platform in general, are it's ability to run the same binary on multiple platforms and operating environments, and also the ability to compile multiple, and completely different languages to it. It seems like Mono is sort of missing the boat on both of these to a certian extent. Regards, Chris Gilbert (Neovanglist)

Maybe C is not just dead yet ... or Miguel will not be hawking Gtk#,Gnome#... all wrappers of stuff over good old C code ... he'll be rewriting Windows.Forms in C# ... like some other fools are doing

Wake up ! ... he's just trying to sell the Mono idea to the Gnome community

I work on the Portable.net project
http://www.dotgnu.org/.

Ive written a large chunk of the System.Drawing and System.Windows.Forms namespace. We currently have two "toolkits" that means our SWF copy will work on Windows and X Windows (using Xlib directly). Mac OS is thus supported.

C++ improved on straight C, Java improved on C++, C# improved on Java. C# is becoming an important standard.

We want to reuse software. We want to take existing software that is built to only run on Windows and run it on Linux or other platforms.

We have much of the framework built to write gui applications using System.Windows.Forms. Despite peoples initial suspicions, what we have done works. We already have most controls completed, including textboxes, treeviews, comboboxes, tabcontrols etc.
See http://pnet.homelinux.org for some screenshots

You can now take a .net gui exe compiled in Windows, copy it to a Linux machine and run it and it works!
The technology is excellent and open source. We need people to help us finish it off.

Hahahaa... DotGNU Tron on XBox ...
It's still an x86 box :)

For Microsoft's own products, I think that this is very unlikely. MS has quite a few aces up their sleeve that they can use to use to make it very hard to use MS apps on non-MS operating systems. Games are likely to be problematic also until the marketshare of GNU/Linux on home user desktops is big enough to make games vendors care about portable programming.

However, productivity apps will be easy to write in a portable manner, as soon as a good, portable System.Windows.Forms implementation is available, and that's why DotGNU has strong empasis in this area.

As soon as all the apps that businesses want are available on GNU/Linux (whether via DotGNU, via Mono, or as stand-alone apps doesn't matter), we'll see lots of businesses switching away from MS Windows. People will generally want to have the same OS and productivity apps at home that they use at work if they can afford it, and since everyone can afford GNU/Linux, this will lead to the migration of many home users. I predict that this will eventually lead to the slow, painful death of the MS Windows platform.

It should be noted however that obsolete OS platforms die slowly. Don't hold your breath.

Also, I'm sure that MS can survive this. They're diversified enough, e.g. in the entertainment area, and I don't see how the Free Software movement could possibly kill that profit center.

The DotGNU project is 100% committed to making Windows.Forms mature. We're even offering significant cash prizes as an additional incentive to help move this forward as fast as possible.

Mono makes it easy to give access to all kinds of .net libraries from inside Parrot (the new high power VM for Perl and probably Python and Ruby.) And it makes it easy for Parrot to add the ability to turn perl code into .net code (I think. does anyone know how much mono code is being used in parrot?).

oh man, here you go again...

Linux is not a viable alternative on the desktop simply because it is not public. The users cannot just get an fast'n'dirty education in OSS the same way as Windows.

If X11 is so bad, why haven't every geek moved to the alternatives and started to support those projects instead.

I agree that Win32 will be a relic of the past, but I hope that .GNU will succeed over .NET, and thereby Microsoft will be a relic of the past.

The typical Linux user has not got much inability to accept change, he or she typically browse through their options (e.g. KDE, GNOME, *box when talking about GUI) and use what they like for some time (maybe forever) ... while a typical windows-user would install office, winamp (some have switched to media player) and divx for basic use. Linux users may have difficulties to start using it, but they learn a whole bunch more, when they do (not many people are quitters).

Bait and switch? I see an opportunity to switch, but no forced switch. I clicked through your dotgnu link and ended up at a wiki page giving the status of System.Windows.Forms support in DotGNU.

Ah, the "switch". The "bait" was of course the promise of ".NET Functionality and More", with "Compatibility with .NET" shamelessly highlighted for those visitors to your site of a particularly gullible nature.

I'm afraid that Gtk# does nothing to rescue DotGNU from the charge of functional bankruptcy. If I am investing specifically in Dotnet, I will use the native Windows UI and am unlikely ever to be able to justify migrating or forking my app to use Gtk#. Conversely, if I know up front that I want a genuinely cross-platform application I'm likely to follow the much better supported path of writing it in Java.

Standards from Microsoft are dangerous, even when royalty-free licensing is offered so that they can be implemented in Free Software.

Consider for example the ECMA standards 334 and 335 for the core parts of .NET - while Microsoft has promised royalty-free licensing for any and all patents that may be neccessary for implementing that standard, they are at the same time embracing and extending their own standard, and they have filed at least one patent application that seems to be designed to give them a monopoly on their extensions to the standard.

In some situations it may work to simply refuse to go along with the standards attempts from MS. Unfortunately, MS has so much leverage that this won't always work. For example, with .NET just ignoring it IMO won't work, that's why we're working on creating a competing "standard set of libraries" for the stuff which goes beyond the stuff that is safe from patent-based attacks (the safe parts are what is specified in the ECMA specs, for which MS has promised royalty-free licensing, plus everything which is thin wrappers around stuff that is simply too old to be affected by .NET patents, such as for example System.Windows.Forms). The strategy of the DotGNU project is to re-use a good number of existing Free Software libs (written in C) and compile them for .NET - again since those libs are old, they're safe from being affected by any .NET patents.

Greetings,
Norbert.

I'm expecting this. One of the things I do daily before switching on my monitor is to make sure that I have my asbestos underwear properly in place. :-)

Of course MS will put up a fight as soon as what we're doing becomes a real threat to them. Sometimes my knees get wobbly when I think about this, but then we knew since the beginnings of DotGNU that it's going to take some guts to not only challenge MS but to actually fight it out.

If I fight and I get burned, at least I got burned while fighting for what I believe in.

If I don't fight and MS manages to catch the whole IT world in their .NET, building another effective monopoly (one which is much harder to dislodge than a desktop monopoly can possibly be), I'll always have to have a bad conscience if I haven't fought.

I've made my choice.

What is yours?

Greetings,
Norbert

In DotGNU, we have been thinking a lot about this kind of questions since the beginning. Catch me on irc, channel #dotgnu on irc.freenode.net ... my nick is: nb.

Greetings, Norbert.

For anything related to DotGNU or .NET or webservices in general or bytecode systems in general, I invite you to use the DotGNU "visionaries" mailing list for creating a public record that can if neccessary be used later as "prior art" for invalidating patents on essentially the same ideas.

Greetings, Norbert.

We have the beginnings of a VB.NET compiler (derived from the C# compiler) in DotGNU, waiting for someone interested in this kind of thing to come on board and champion that subproject. Right now it does "VB.NET syntax with C# semantics", the hard parts of building a compiler are taken care of, finishing it is a matter of plain old programming (lots of it).

Any takers?

Greetings,
Norbert

Right now, in 2003, Linux has no equivalent to Dotnet or WinFS nor any plan for such features . Such VMs and DBs that do exist are completely unexploited (and often impossible to exploit) from the kernel, the core tools and the popular desktops and office applications.

I'm assuming that your referring to a Linux system as a whole and not explicitly the kernel. The reason why these shouldn't be part of the kernel are pretty straightforward, .NET is a development framework and WinFS is a database driven file system. That said, the equivalents for .NET would be Mono / dotGNU and for WinFS you could use Oracle's IFS , not free but then neither is Windows.

Am I obligated to give away my webservice source code?

You are not automatically obligated to distribute your source code, and you are certainly not obligated to just give it away. However, if you sell webservice services, then your customers will expect that you make them the "owner of the data" which the webservice uses, and depending on the exact circumstances that may indirectly give these customers a right to get the source code upon request. Here are the details:

If you provide a webservice using a GPL'd webservice program (which you may have modified), then the "owner of the data" will be able to obtain the webservices programs under the terms of the GNU GPL, and this implies in particular that they will have a right to get the source code of the exact version of the program which you're using. The terms of the GNU GPL also require you to make a written promise to this "owner of the data" that you will be willing to provide the source code upon request. This ensures that the "owner of the data" will know about this right to the source code.

The "owner of the data" is typically a paying customer, and the fact that the customer has a right to get the source code increases the value of the service you provide. Therefore you will be able to charge a higher price and/or close more sales.

You can use the DotGNU development tools to program your own webservices (instead of just modifying the webservice programs which are distributed with DotGNU, or which others have made available under the GNU GPL) and then your are not required to make source code for these webservices available to the customer who is the "owner of the data". However, even in these situations where you are not required to make the source code available to your customers, we strongly encourage you to provide the source code to your customers under the terms of the GNU GPL anyway. We believe that this is ethically the right thing to do, and that it will be good for your business.

Now I thought the GPL would not prevent this sort of thing? Now I'm really confused.

I'm sure glad that GNU thinks they know what would be good for my employer's business and that my employer should charege more for their program (which is for schools).

I thought I had a good solid understanding of the GPL . I've taken the GPL quiz , read the GPL Faq before.

I thought the GPL only applied to copying and distribution of a program or derrived work. Not to running it privately on my own web site.

If I distribute my proprietary program, along side a DotGNU program / platform that executes it, I would not think that my program comes under the scope of the GPL.

If I do NOT distribute my proprietary program, but merely run it at my site, and merely sell it as a service, then I was definitely under the impression that the GPL did not apply since no distribution takes place.

Still, back to the case where I distribute my program, and a seperate DotGNU program to run it, then I would not think that my program comes under the scope of the GPL.

Maybe I had better just stay completely away from DotGNU. Stick with Apache and various Java tools instead.

Just a side note about the customer having their data he

dotGNU
More interesting than Mono, IMHO. But as I'm about to give it a whirl (I find C# more appealing than Java, yet I don't do - or want to do - Windows-only programming), I wonder -- what organization would use a free / open source .Net-lookalike? Seems that if someone is sold on the .Net path, they'll buy the "real thing", that is, Microsoft. Comments?

much).. It's good to see Sun evolve Java into a new language , but couldn't they have done it before MS pushes something similar down our throats. You might like Mono . But how about this this ?

While I can certainly understand the patent concerns, it is important to note that discussions have taken place between the DotGNU Portable.NET project and the people working on the next generation perl runtime. This provides a very good way out in case Microsoft goes after Mono and Portable.NET with patent claims.

Mono and Portable.NET really shine in allowing former Windows developers to get involved with Linux and still have a comfortable and semi-familiar place to start.

I don't see Mono or Portable.NET as cross-platform technologies (unless you mean cross-platform across Unices) because Mono and Portable.NET grew up on Unix and will be used here the most. Besides, Microsoft has simply created too many API's and hence the barrier to a *quality* cross-platform development environment is too great.

Rather, Mono and Portable.NET will be good for rapid prototyping and as a conversion tool for Windows Application developers. Is also important for providing an alternative when the great migration begins of Smart Clients begin from Windows to Linux.

As for the rest of the article: Yah, I'm sure the Microsoft developers who created .NET are enthusiastic about Mono, but the higher-ups (see: PHB's) have no love for Mono or Linux.

DotGNU Portable.NET can compile C# code to Java. The libraries are lacking, but more support is in the works.

Ever heard about DotGNU ?

Really folks, patents are a problem to Free Software in every project. No Free Software project is immune to these kind of concerns as well as other complicated interactions with corporations. Look at Samba which is every bit as susceptible to MS patents as Mono. Or how about OpenGL which has problems with corporate concerns. Sun has patents on Java. At least Microsoft is bound to the ECMA patent policy which is basically RAND with required disclosure.

Another important thing to understand is Mono isn't the only Free Software project out there that is implementing the ECMA standards. DotGNU/Portable.NET has a large par t of the ECMA specs implemented and the design goal of PNet is ECMA not the rest of MS's .NET infrastructure ie, System.Windows.Forms, ASP.NET, ADO.NET. The wine project is another area with every bit the risk that Mono faces.

So the conclusion to draw from this is: Patents are a danger to Free Software in every direction! Not just this one particular project...

I could be free from Microsoft.
You could be free from MSFT and use .NET at the same time ... try DotGNU Portable.Net , a fully GPL'd implementation of .NET sponsored by DotGNU ... and I think I saw a fink package somewhere...

Finally we get to do what we want ... roll out a Passport clone. And one which you can use for Free as well :-)...

DotGNU is planning a nice replacement for Passport and has been working for the past one year on something "real people call secure" ...

DOTGNU

Its a good thing the DotGNU project is around. The project's goal is to totally replace .NET and its whole platform, including passport, with a decentralized, open system. Not to mention, you can run .NET apps on any platform.
If the project continues at a good pace, we will not have to rely on Microsoft for anything at all when it comes to Webservices.

IIRC, I read that DotGNU will enable you to run your C# programs on the free GNU/Linux operating system using exclusively free software. With DotGNU, you will be able to use C# if you wish, without surrendering your freedom to study, share, change, and generally control all the software that you use.

This is, of course a boon, however it is worthless without some soft of workaround for Microsoft's Palladium scheme:

Microsoft's "Palladium certification scheme will rip the guts out of the GPL. That is, the minute I begin tinkering with my software, my ability to interface with the Great PKI in the Sky will be broken. I'll have a Linux box with a GPL, all right; but if I exercise the license in any meaningful way I'll render my system 'unauthorized for Palladium' and lose business. So instead, I imagine I'll be turning to my vendor for support, updates, modifications and patches. And I'll be dependent on them for support services at whatever price they can wheedle out of me because I dare not lose my Palladium authorization. I wonder if the cost of ownership of an open-source system will actually be lower than the cost of a proprietary system under such circumstances."

IIRC, I read that DotGNU will enable you to run your C# programs on the free GNU/Linux operating system using exclusively free software. With DotGNU, you will be able to use C# if you wish, without surrendering your freedom to study, share, change, and generally control all the software that you use.

This is, of course a boon, however it is worthless without some soft of workaround for Microsoft's Palladium scheme:

Microsoft's "Palladium certification scheme will rip the guts out of the GPL. That is, the minute I begin tinkering with my software, my ability to interface with the Great PKI in the Sky will be broken. I'll have a Linux box with a GPL, all right; but if I exercise the license in any meaningful way I'll render my system 'unauthorized for Palladium' and lose business. So instead, I imagine I'll be turning to my vendor for support, updates, modifications and patches. And I'll be dependent on them for support services at whatever price they can wheedle out of me because I dare not lose my Palladium authorization. I wonder if the cost of ownership of an open-source system will actually be lower than the cost of a proprietary system under such circumstances."

As you work on Windows systems, you might look at #develop which is a very flexible open source IDE for .NET. I presume you are running .NET anyway by now, as that is where VS is at now. It has among other nifty features a completely plugin-based architecture (see the SODA document for details) and user-definable backends, i.e. you can switch the compiler (and language of course) to whatever you like. Currently the MS.NET compilers and the SUN Java engine are implemented as backends, but if you want to use MONO for Windows, GCC or whatever, you can do it. And as you might guess from the last bit, porting to Linux is planned as soon as dotGNU and/or MONO are up and running :-)

McAfee patented Webservices as a whole !.

And now look at the second line of the article you're linking to:

We hope to dispell the myth that this covers all application service providers.

And now say the same thing again...

A lot of patents are in the hand of the Big Five of the American Corporate Jungle. Thank goodness I live in a country without software patents

I know this might come out as a saleproposal but it's really not. Turnpike is a CMS written completely in C# for you who do use the MS plattform (or thinking of using .NET for either FreeBSD or DOTgnu). It's made by a team of Swedes.

Well, you can read the docs (somewhere on MS's site; I'm not going to search for it), or you can go check out the mono project, or you can go check out dotGNU, which is somewhat larger in scope than mono but also implementing a .NET runtime, or you can go read O'Reilly's books on the subject, some of which are already in their second editions.

(Mono+.Net > Mono). A more disturbing thought, discussed on DotGNU list, about Mono bringing out a proprietary version (anybody remember "Exchange Connector ")

DotGNU mailing List Archive -- the stupid lameness filter is not allowing me to post the actual mail. Search for Ximian there and read Martin Coxall's comments on our reaction

I've been following Microsoft's .NET strategy for quite some time and have been quite interested in the Passport vs Liberty Alliance scenario.

Firstly, what exactly is happening with Liberty Alliance at the moment? I got the impression that the iniative was started as a marketing oppositing against Passport as there doesn't appear to be any visibility of the implementation on the web site.

Secondly, there is also an open source source initially from .GNU for this central authentication service. Essentially both Liberty Alliance and .GNU are trying to provide an opposition framework to Passport - and yet the nature of the concept and the existance of the two projects seem to be self depricating. If everyone and their dog develop a centralised authentication service that spans services across networks - people would probably use Passport purely because of its market share.

Would it not be a good idea to somehow merge the work done to offer a unified opposition to Passport?

The DotGNU project was originally started in reaction to Microsoft's .NET strategy, for which it will be a complete replacement (and not just a Free Software implementation). The part of .NET strategy about which we are most concerned is Hailstorm (recently renamed ".NET My Services"), which is in fact Microsoft's attempt to gain control of the internet and its users. In contrast, the goal of DotGNU is to give computer users full freedom to use the internet as they want. For example, the DotGNU approach to "web services" will make it possible for end users to run webservice software on their own PC, so that the users are not forced to migrate their data to the webservice servers.

BTW, there are pre-release, untested, packages of pnet & treecc at http://dotgnu.org/debs/.
Sorry, it's not yet apt-gettable.

There seems to be a lot of confusion about the term "Web Services" also. Most people, including the .GNU folks, focus in on the My Services model of Application Service Providers as the sole meaning of Web Services. In fact, a .Net Web Service is a remote component that is accessed through SOAP or HTTP.

There's a world of difference between a blatant attempt to corner another market (.Net My Services), and a platform interoperability mechanism (Web Services/SOAP).

damn...hear is the link