Slashdot Mirror
Mono Project Releases Beta 1
AArnott writes "Ximian has just released beta 1 of its open-source implementation of Microsoft .NET platform. Mono allows .NET applications to run on Linux, Mac OS X, Unix, Windows. Mono 1.0 is slated for release on June 30, 2004."
sjanes71 adds "The first 'beta' always gets heaps of attention, and this is the first of three planned for the Mono project. Some of the new features touted for this release that updates Mono v0.31 include a faster interpreter, a global assembly cache, support for the StrongARM and HPPA platforms, generics support in the VM and C# compiler and an early alpha of System.Windows.Forms. C# and .NET is Microsoft's answer to Sun Microsystem's Java platform and Project Mono aims to create the Open Source, cross-platform version of Microsoft's new development environment."
http://www.go-mono.com/archive/beta1/beta1.html
/. I doubt it is the latter.
The generics compiler is called `gmcs' as opposed to the standard 1.0 compiler `gmcs'.
I assume this is a typo.. or I am working too hard.
As I am reading
You might also want to check out MonoDevelop v0.3 which was released to take advantage of new features in Mono Beta1. .NET development in Linux and rival VS.NET in Windows.
While it's not quite up to the task of stable work yet, it will become a great IDE for
I heard in some news that Microsoft is applying something like 10 patents a day. You could say that all that effort in acquiring patents is just for psychological effect, but should they change their mind...
For this it states:
Get off my lawn.
Beta 1.0 is currently only available as packages for RedHat 9, Fedora Core 1, SuSE, SLES and as an installer for Windows - there currently isn't an OS X installer or .pkg as the story seems to imply. Infact, there doesn't ever seem to have been a packaged release of Mono for OS X.
The Mono status on the front page says that there is a JIT but no Interpreter currently for OS X. It seems that OS X users should compile from source if they want to use Mono...
Microsoft open? Hah! .NET for mac or linux? (I mean the ms created version and not mono)
Where is
Their XML is a joke, swaths of proprietry code and an arsenal of patents to defend it.
Microsoft pays lipservice to "open standards" to keep the DOJ at bay, but after that it's business as usual.
Great work on Mono guys, we can only hope that microsoft won't dare use their patents against the project.
It's also slightly encouraging to see Microsoft adopting the use of technology like XML and moving a bit closer to standards with their software... their new vector language is very similar to SVG
But it isn't SVG. OTOH I don't think it'll be too long before some cunning hacker writes some XSLT which will convert XAML into SVG + XUL. If its integrated into 'zilla users would be none the wiser.
Rich
The write up says "Mono allows .NET applications to run on Linux, Mac OS X, Unix, Windows."
The FAQ page says:
"Question 52: What operating systems does Mono run on?
Mono is known to run on Linux, Unix and Windows systems. "
Then later they admit to running on FreeBSD:
"Question 54: What architectures does Mono support?
Mono today ships with a Just-in-Time compiler for x86, PowerPC and SPARC-based systems. It is tested regularly on Linux, FreeBSD and Windows (with the XP/NT core)."
If it's just the IDE you're missing (and I wasn't aware that the Mono people were writing one), then you might want to take a look at icsharpcode.net. One of the projects (#Develop) is a free-as-in-both IDE for .NET.
In addition to that, Borland have a personal edition of C# Builder available, which is free as in beer, but not licensed for commercial use.
It's official. Most of you are morons.
Someones doing a VB Compiler in Mono
that would be an interesting thing should it ever produce binary compatibles.
There are places where the networks are not touching,and there are places where they are-Boeing's Lori Gunter
There's a chance you'll see .NET for Mac if MS releases a version of Office based on .NET. Not very likely, but possible.
.NET for OS X. That doesn't mean that the platform is useless.
.NET and Java are not the answer. A Java or .NET app is still not going to feel 100% like a native app on every platform, even if you throw some pretty skins on it - there are too many differences. For example, for the longest time the Mac OS had no standard equivalent to Windows' ComboBox, so developers rolled their own. I'm not even sure if OS X has an equivalent. Mac UIs have always been designed somewhat differently than their Windows counterparts, based on that reason and other reasons.
Though, really, why does it matter? Apple doesn't release a version of Mac OS X for x86, so you can't run OS X software on x86, just like Microsoft isn't releasing a version of
If you really want an application that fits into your workflow nicely and cooperates with all the other software on your PC, at least for now, platform-independent solutions like
using namespace slashdot;
troll::post();
Mono was around long before Novell purchased Ximian. Mono will remain around long after Novell, if Novell does go somewhere, simply because the .NET platform is popular and there are quite a few talented programmers who'd like to work with it.
Combined with Sun's perceived reluctance to open Java (perceived because IBM has their VM; GNU has theirs; they don't have the popular press that a project like Mono does) and Mono has a *lot* of support behind it.
My reality check bounced.
What are DLLs if they aren't shared libraries?
I haven't enabled all experimental features but winelib support is there. I'd like to hear some feedback for it.
Historically, Microsoft has had two different teams to produce the same 'title' software: Internet Explorer and Microsoft Office both had teams strictly separate from their Windows counterparts. The Mac teams use Carbon and Cocoa simply because they are writing specifically for Macs.
I'm assuming it's cheaper for Microsoft to hire a new team than to port over their framework (in strictly this context, without worrying about the Evil Empire ideology ascribed to them). This has been good: Mac versions of Microsoft software (with the notable exception of Media Player) are usually better in terms of usuability, bugs, and features.
You probably read it here.
It gets interesting now, though. This guy at eWeek has a theory that MS is putting all it has onto Longhorn to steamroll Linux.
If that's the case, then projects like Mono (or anything that consolidates and professionalises Linux) takes a larger sense of importance and urgency (well, kind of: MS won't release Longhorn for another decade or so...)
MonoDevelop is a GTK port of #Develop.
It's my understanding that #Develop is trying to create a cross platform compilable version of their IDE as well.
My reality check bounced.
These are my 0.02 US$...
...and that's about all they're worth.
.NET compatibility. Microsoft have always gone out of their way to make sure their new versions of Windows run software written for previous versions: do you know why? Because big business won't let them break things. Why should that be any different today than it has been for the last fifteen years?
According to your predictions for Mono, Microsoft should have litigated Samba into the ground years ago. Remind me, how many lawsuits has MS filed against Samba? Oh, that's right, ZERO . Not a single fucking case. Man, that bodes ill for Mono, doesn't it!
Of course the Samba team didn't get any support from Microsoft. But Samba still exists, and it still works.
Likewise, Microsoft can't break
And even in the case that MS do break compatibility... why should we care? Will that mean that Gnome apps using Mono and GTK# will suddenly stop running on Linux? Of course not. We'll still have something cool of our own.
Haha, far from it.
.NET developers interested in how the technology works.
.NET is something more than a new API for windows...
Choice quotes from the MS website:
It will be of interest to academics and researchers wishing to teach and explore modern programming language concepts, and to
Notice that nowhere in the list of intended uses is "Development", that's because it lacks all the libraries needed to make it useful.
This software was last updated 18 months ago - it's not undergoing development.
Simply another ploy to gull people into thinking
That's actually a good thing, inheriting from classes you don't maintain is a risky business.
If you subclass and add methods in your class there is nothing to stop the original class adding new identically named methods in a subsequent release.
It is generally much better to favour composition over inheritance unless a class specifically documents that it is intended to be subclassed - eg/ abstract classes.
+++++
The harder you look the less you see. That's what we're up against.
can you spell delphi.net?
it is MUCH better than visual studio (which is neither innovative nor brilliant)
Conservatism: The fear that somewhere, somehow, someone you think is your inferior is being treated as your equal.
'm sorry, but WHAT THE HELL ARE YOU TALKING ABOUT? If you do .Net development in Windows, you use VS. You have no alternative. It's not "not a lot of fun", it's impossible.
.NET Framework Software Development Kit (SDK) version 1.1 includes everything developers need to write, build, test, and deploy .NET Framework applications--documentation, samples, and command-line tools and compilers.
Wrong:
The Microsoft®
Open source .NET IDE:
The sub-classing of standard classes has been managed successfully in Java for many years. I've never had the problem where a new version of a class has produced a method with a name the same as one I might have written in a sub-class. Anyway, even if it did happen, the likelihood of it causing a problem is very remote. Java very easily distinguishes between (For example) Method(String string) and Method(boolean flag).
.NET libraries is that they aren't very extensive (Well, at least not when compared to the Java standard libraries). Of course to work around the limitations of the standard libraries we look for 3rd party libraries. In the case of Java, 3rd party libraries are mostly GPLed and free, where 3rd party .NET libraries are almost always commercial products with fees attached to their licensing.
Another thing I've found extremely prohibitive with the standard
Free Firefox news reader.
Well, you are partly right. Windows.form is not part of Mono's "core" library, and so won't work with 1.0. So for now, cross-platform applications are a big no-go.
.net framework and propriatory extensions like windows.forms (even if that particular extension is quite important).
.net library, windows.form is not a standard...it's something MS can change any time they want. There's also the problems of the legality of reproducing the entire API. The rest of the mono project is probably legal because it's an implementation of a standard...
They are working on a couple of solutions though. First, is GTK#, that (along with bindings to all others Gnome Libs) will allow you to quickly develop a linux application using an API just like windows.form but with GTK widgets. Don't confuse c#, the
Even without ever seeing Windows.forms, GTK# and all the associated library can be quite nice for linux. It's easy to develop for, it's quite fast and it means new Linux developers can create application more easily and perhaps port windows applications more easily.
The problem with Windows.form as far as I understand it is that unlike C# and the
I guess we'll have to see. I'm quite excited about Mono anyway even though I'm a big linux user and don't usually care about MS technologies. I have to admit that I highly prefer C# to Java (for several reasons) and I wouldn't mind seing more c# actions on linux even if the language itself was copied^h^h^h^hcreated by microsoft.
IP Therefore I am.
Chill. If Mono only implemented the CLI and a C# compiler, it WOULD be "just an open source implementation of the CLR/C#". But Mono implements nearly all of the MS.NET base class libraries as well. Those libraries are not part of the CLI. Therefore, the only accurate way to describe Mono is to say it implements .NET in Linux.
Shut up.
I'm guessing that DOS Plus imported a bunch of features from the Atari ST version of CP/M 68, which also looked just like MSDOS to end users (and was renamed TOS and had GEM as the UI.)
QDOS was a semi-clone of CP/M, built to deal with the fact that DR took their time to port CP/M to the 808[68] architecture. The original author denies it was a straight clone pointing out it had some nice features and architectural differences that weren't present in DR's OS, but there's no denying the API was intended to make porting CP/M programs easier.
CP/M itself dates back to the mid-seventies, with Dr Gary Kildall writing a crude filesystem and CLI for early Intel 8008 evaluation systems. CP/M 1.3 was practically unusable. CP/M 2.x became an industry standard, but was very tied to the architecture of those original Intel evaluation systems (CP/M required OEMs develop a BIOS that was practically identical to the firmware in those systems.)
So what you essentially have is:
(Mid seventies) CP/M for the 8080
1980/81: QDOS developed independently by Seattle Computer Associates, with many ideas taken from CP/M and with compatability in mind.
1981: Microsoft buys QDOS, releases it as MSDOS 1.0. IBM bundles it with PCs.
1981: DR releases CP/M 86 as a seperate product, this is essentially CP/M ported warts and all to the 8086. Nobody buys it.
1982: Microsoft makes dramatic updates to QDOS, releasing MSDOS 2, which has a proper file system, I/O redirection, all the things, essentially, we consider part of DOS today
1984: DR releases CP/M 68 for Atari. This includes an MSDOS compatable file system and many MSDOS APIs
1984: DR releases CP/M 3 (CP/M Plus) for 8080 based machines. Amstrad in the UK is only major buyer. This is still straightforward CP/M, antiquated file system and all, but with support for paged memory and with a lot more userland tools.
1985: DR releases DOS Plus. Amstrad, in the UK, is virtually the only major buyer. DOS Plus is mostly, but not entirely, compatable with MSDOS. Most people avoid it because of this.
1986 (I think): DR releases DRDOS. DRDOS is now almost completely compatable with MSDOS and begins to take off.
You are not alone. This is not normal. None of this is normal.
They are shipping both CLS and Microsoft compatible implementations. The basic idea is that new applications for Linux can use CLS plus the Mono stack (i.e., UNIX/Linux intended assemblies, like gtk-sharp, various DB libraries, POSIX wrappers, etc) and legacy or cross-platform apps can use the Microsoft stack (Windows.*, ASP.NET, ADO.NET, etc).
;-)
For example, a GNOME app written in C# for Mono would not use the Microsoft stack at all. So even if Microsoft broke/changed/patented the Microsoft (non-ECMA) stack, that would have zero effect on the tons of Open Source/Free Software apps developed using the ECMA and Mono assemblies. Thus, Mono provides both a great set of languages (C# and anything else that can run on the CLR), a good solid runtime (Mono+CLR stacks), an efficient and cross platform interpreter and JIT/AOT compilers, and so on.
The only thing Microsoft can kill is Microsoft compatibility. Which really isn't all that interesting to most FOSS developers.
> What I have been wondering, however, is why .NET generated so much interest in the Open Source community? Java has been around forever, and hyped beyond belief, yet for all the talk about needing an open-source java vm and class libraries, it looks like open-source .NET is further along than open-source Java in much less time!
.Net framework, C#) fills a slightly different niche, with its strong emphasis on multi-language support. This is attractive for developers who already have a lot of code written in other languages.
.Net, and the discussion over strategy for preventing a Microsoft Internet monopoly, and you get a lot of buzz factor.
I can understand why you might have that impression, but I don't think it's true.
I think both Java and Mono have a place on Linux.
Java provides an excellent cross platform language and runtime environment. In terms of number of job listings, it is currently the most popular languge used in business, having surpassed C/C++. And Java is well supported on Linux -- there are Open Source JVMs, the GCC supports Java bytecodes, and the Sun Java Desktop Linux distribution is finding a lot of support.
Mono (i.e. the
Of course, other languages can also be compiled to Java butecodes, but that aspect of Java has never been emphasized much, so it didn't really mature.
Java is good for downloadable Internet applets, though Microsoft has used their control of the PC desktop to stunt Java's growth in that area, by sabotaging the compatibility of the Java clients (i.e. "polluting" Java with J++, then removing Java support altogether).
C# can also be used for Internet applets, and Microsoft will try to use their desktop control to ensure C#'s success in that area. Microsoft intended to have a monopoly in that area, but that may not happen now with Linux and Mono as an alternative.
So I think both Java and Mono/C# have roles to play, and I think they will both succeed.
As to your suggestion that Mono/C# may be gaining greater interest on Linux than Java, I think that is a false perception.
Instead, I think it is simply that Mono/C# currently has more buzz factor...
I think that Java is simply accepted, and growing quietly. As I said, the popularity and support are both there.
Mono/C#, on the other hand, is very controversial, being a Microsoft-originated technology. Thus, it makes the headlines. Add to that the Microsoft propaganda, the Microsoft-forced "success" for
Overall, I would say not to worry. In its usual open, free-market style, Linux is trying all possible avenues to success. And it will succeed, even if we can't predict the exact mix of technologies for the future.
First, is GTK#, that (along with bindings to all others Gnome Libs) will allow you to quickly develop a linux application using an API just like windows.form but with GTK widgets.
GTK# is nothing like Windows.Forms. It's like C GTK+. The idea of GTK# isn't to allow porting Windows apps easily to GTK#, the idea is to allow writing new applications with a good, solid, intelligently designed toolkit.
GTK# also is not just a Linux solution. GTK+ runs on Windows, X11, and many other graphics architectures, and GTK# works with any of those. You can develop an app in GTK# intended only for Windows, if you feel the API for GTK# is friendlier and more usable than Windows.Forms. (Which wouldn't surprise me. ~,^ )
That is the way things ought to be.
However, I'm betting you've never seen programmers try to use inheritance to express relationships of a "has a" (or "other") nature, because they haven't thought it through clearly (the "if all you have is a hammer..." syndrome).
So, it's helpful to train programmers to think about the "is a"/"has a"/etc relationship up front, rather than just kind of fuzzily using inheritance because they know the classes are related (and then maybe deciding that there is an "is a" relationship ex post facto).
DNA just wants to be free...
Please note that SWT is available for MONO/.NET, too! It is part of #Develop. In fact the IDE uses SWT too be platform independent.
Please also note that the parent is wrong in comparint SWT with Emacs. SWT is only a toolkit. The Eclipse IDE, which is indeed light years ahead of everything else available today, also runs on top of MONO/.NET.
However, the parent is right that Eclipse does not yet support a good C# mode which supports standard techniques such as delta-compilation, live compilation during debugging, refactoring etc. This is currently only possible in the java mode. But this isn't a problem because MONO/.Net is language agnostic, you can write java code and execute the code within MONO, there is no need to write in C#.
Wake up: the ECMA standard covers c# only.
Funny you should suggets the parent to your comment was a troll. There is an ECMA standard for the CLI (i.e.
This signature intentionally left blank
Aside from the other poster's comment, you only have a separate copy of the DLL in the gac for each version. You don't have a copy for each application. You can also remove an old version and/or point an application to the version you want it to use via an app config file.
MS has released the source for its .net system
It's not the whole system; it doesn't include any libraries. It's basically worthless for development.
Just as opensource, just as free..
Wha..? You didn't read the license, did you?
who would have thought that would happen?
People who are misguided and don't have all the facts?
Yes you are.
.NET lets Microsoft ensure they can easily move software around in the future.
Windows currently runs on x86, x86-64 and ia-64. Soon it will run on the G5 (Xbox2) and eventually it might run on other platforms as well. Developing something like
> 1) Students can learn most of J2EE in half a .Net guest taught
.NET programming in half a semester of a 3h course, so the fact that your colleague is incompetent is irrelevant to this discussion.
.Net was easier for the students to create .Net
.Net is only easier if you use the non-MVC
.Net occassionally, so I would be .Net.
x
> semester of a 3h course (up to Message Driven
> Beans) with difficulty. The
> only dynamic website creation driven from a DB.
You're comparing two lecturers, not two programming platforms. I can teach your students most of
> 2)
> simple dynamic web sites, but they didn't have
> the restriction of asynchronous processing of
> requests. In the real world, the
> applications they wrote would have required
> more than twice the horsepower.
That's utter rubbish of course. Making silly claims like 'it requires more than twice the horsepower' without backing it up is not something I would expect from a lecturer (with professional experience, I assume).
> 3)
> graphical development tools. Think front-page
> style generated html that hardly works in most
> browsers, and definately doesn't pass any kind
> of standards.
There's nothing in the runtime that's keeping you from using the MVC pattern in your (web-)applications. In fact, searching in Google for '"Model View Controller" C#' returns thousands of helpful hits.
You mention struts, but struts isn't exactly part of J2EE, or is it? Fact is that most companies wouldn't touch struts with a ten-foot pole because of the same reason most companies prefer WebLogic over JBoss.
> I have to use
> very much interested in some book
> reccomendations and some pointers to making a
> real database driven application, web or
> otherwise, in
It's not a book of course, but take a look at Microsoft's pet shop: http://www.gotdotnet.com/team/compare/petshop.asp