Slashdot Mirror
Let's Make UNIX Not Suck
The above is a title of the talk that Miguel de Icaza of Gnome and now Helix Code fame gave at OLS concerning the look and feel of the UNIXs. From what I've heard from attendants the talk was great - and now you too, in the privacy of your own home/cube/lean-to/car can read it.
But Unix doesn't use those things enough! The philosophy hasn't carried over to the graphical applications, so we have a schitzophrenic Unix where the little text tools try to do one thing well, and the GUI applications are monolithic and try to do everything.
If you like the idea of building a specialized text-processing app by combining some generic tools (e.g. grep, awk, sed, etc), then wouldn't you like to be able to build a specialized GUI app the same way (e.g. HTML renderer, image editor, calendar, etc)? Don't you see a difference between the beauty of grep and the disgusting bloat of Netscape Communicator?
---
As copyright owner of this comment, I authorize everyone to defeat any technological measure which limits access to it.
Insufficient Coffee in Operator - System halted.
Sorry, got the band name wrong. That should read "Great Big Sea" (I always get it wrong), and the song is on their album "Up".
"The first time I got drunk, I got married. The second time I bought a chimpanzee, after that I stayed sober" Arian Seid
You are missing the point. CORBA does not implement policy, only a mechanism. This is policy on top of any object model you choose. That is why it is powerful.
The point is that there needs to be some sort of policy that is loose enough so that anyone can use and understand it, but rigid enough to enforce a metaphore that works and in understandable by non-computer-cluefull people.
Reading some of the comments here, seems like people haven't really read what the article or don't really understand what Bonono is.
:
Check out the full description at
http://www.helixcode.com/tech/bonobo.php3
Just to quote from that page if you can't be bothered :
Bonobo is a set of CORBA interfaces that define the interactions required for writing components and compound documents. These CORBA interfaces are not bound to GNOME, the X11 windowing system, or the UNIX system.
The Bonobo distribution as shipped by the GNOME project includes the Bonobo CORBA interfaces, and a GNOME/Gtk+-based implementation of these interfaces.
What about Slackware?
Sticking feathers up your butt does not make you a chicken - Tyler Durden
Isn't UNIX still (tm) AT&T? I thought the generic term was Posix...
Posix system's aren't really aimed at beginners - that's what people keep forgeting. It was designed for use by people who know what they are doing and how _they_ want to do it - not the way a Redmond base drone wants them to...
Richy C.
--
Bollocks, pure and simple. The first Real-World deployment of Unix (i.e. outside ken's lab) was to the secretaries in the patent department of AT & T to enable them to write up patent applications, hence the emphasis on text-management and typesetting software in the early releases of the Unix system.
As for Unix being intended as a server OS - quick reality check required. Unix dates from the late 60s/early 70s. The client-server separation was fifteen years in the future - back then there were no clients. Unix was designed to support multiple terminals (tty0 - n) hanging off a central computer (originally a PDP8 IIRC) which displayed plain text in black and white: termcap files, full-screen editors and the like didn't arrive on the scene until the mid-70s and prior to that people edited with ed.
Get yourself a copy of the Unix Programming Environment and read it, then come back and post an informed comment.
--
Cheers
Cheers
Jon
There are all sorts of things that you can expect to be able to do on any Unix-like OS. You expect X-Windows, NFS, vi, etc. Yet at one time or another most of the Unix "standards" had some sort of competition.
Miguel is proposing to standardize Linux (and Unix as well) simply by creating Free software that is so cool that it becomes ubiquitous. Instead of writing their own HTML widget, XML parser, Address book, text editor widget, etc. programmers will simply borrow the GNOME widgets. Programmers will do this because GNOME is free, comes with source code, and because GNOME can be installed anywhere.
GNOME will simply become one more layer in the existing framework that is UNIX. Some people won't use it in much the same way that some Linuxers don't use X-Windows. But most of the new software will happily use these shared components in much the same way that they happily use the existing shared Unix libraries.
Actually, I believe AT&T sold UNIX (including the trademark) to Novell, who later sold it to SCO. As far as I know, SCO still holds the trademark. (It was SCO that gave permission for the Lions book to be published with V6 UNIX source code in it...)
Deven
"Simple things should be simple, and complex things should be possible." - Alan Kay
Saying that CORBA's interface versioning solves this problem is like saying that a hammer solves the problem of nails. It's a tool, valuable to the extent that people know how to use it properly by making sure that the interface definition accurately and completely describes the behavior of a component and that the "actual interface" doesn't change without corresponding change to the "official interface" - something that doesn't just happen on its own. Arguably, what you really need to solve this problem (and, even more arguably, what some languages or programming models give you) is a way to ensure that all behavioral dependencies are captured in the interface definition and that nobody can even begin to depend on something that could change.
Slashdot - News for Herds. Stuff that Splatters.
Here is my point. It isn't just CORBA. Corba is a neat way to force applications to talk in a non-pointer determinate fashion. It's about the policy (that is what bonobo partially delevers).
There has to be a way that a system can serialize data, provide access control to serialized objects, and store thoose objects. This is what Linux is missing in a big way.
Componets are cool, but if we are going to add componets, lets add a constant model or policy, and flexability in. Let's also make it so that there is a common configuration interface, a block or object interface, and some heirchal or non-heirchal way of looking at it.
So what's the problem? What DOES suck is the attempt to make Unix into a friendly operating system. Great.....IF you know what you're doing.
The Microsoft Windows 95 interface is successful because they had Human/Computer interaction experts working to design the interface. (Don't start with the 'Microsoft copied Apple copied Xerox' crap. Each interface is different enough that SOME design went into it.) The problem here, is that we have the Gnome people, and the KDE people, etc., trying to make a Graphical Interface - and they're trying to be too much like the other interfaces out there, and the rest of the design is just being assumed.
UNIX doesn't suck. It was designed to be a powerful network operating system - and that's exactly what it is. Sure, 10 years down the road it's going to be different. However, the basic functionality will be the same.
To say an Operating System sucks because of bad design of an additional interface is ignorant.
-- Give him Head? Be a Beacon?
-- Give him Head? Be a Beacon? :P)
(If you can't figure out how to E-Mail me, Don't.
``Miguel also should have picked a better title. "Unix sucks" is *not* going to get the mainstream to read the article, they're too used to one-line sound bytes''
``Unix Sucks'' was not the title! The title was ``Let's make UNIX Not Suck''. I don't think there really could have been a better title.
--
Ski-U-Mah!
Code Reuse was the mantra in the eighties, not the Next Big Thing for the year 2000. There are obviously some cases where it makes sense, but its not a cure-all for derailed software projects. Code reuse is well suited to projects with a short development cycle, a short life cycle, and a small user base. Most internal IT applications fall in this category. But it doesn't make much sense for projects with ongoing, constant development, long life cycles, and millions of users. This is where fine-tuning "custom" code makes sense, despite the current aversion to hand-written code by people who consider themselves to be knowledgeable about such things. Every re-write is an opportunity to improve the code. Software reuse effectively eliminates this opportunity, and in time leads to an obsolete and brittle code base. Code reuse is a part of effective software development, but it shouldn't be the central tenant around which it revolves. That distinction belongs to good design and well-written code.
The 'no policy' policy of X is a Good Thing, in my opinion. There are some advantages to having a consistent UI, but they are outweighed by the disadvantages. A certain amount of chaos always accompanies innovation, but chaos is better than being subjugated to an inflexible policy. There are always going to be people who want to force their ways of doing things upon others, and UI policies are a great way for them to accomplish this. The best policies are the ones that are voluntarily adopted by large numbers of users over time. If it works for that many people, then there's probably something good about it. But if there isn't consensus in a particular area, trying to enforce policy is not going to meet with much success. MSFT gets away with this because they have a more or less captive user base.
Miguel has a few good points here, but overall this article could be more appropriately titled "Let's make UNIX suck like Windows".
Used to be, anyway. But there's no way I'm installed eighty-eleven libraries the hard way. I'm gonna find RPMs. And RPM -U removes the old lib. Whoops.
That is a misfeature of RPM then (and other packaging systems which have the same problem). Dependencies should not be an either/or thing -- different versions of libraries can and do coexist just fine. I agree that -U should not nuke old libraries by default, but an alternative would be --install --force, whereby both library packages are in place. Of course, one must use this with caution, as many packages include other files (headers, config files, etc.) with libraries, whcih IMHO is also a mistake. Libraries are LIBRARIES, header files and config files are something else. The -devel scheme tries to address this and (mostly) succeeds, but a more explicit approach might be better:
package-0.0-1.bin.rpm
package-0.0-1.conf.rpm
package-0.0-1.lib.rpm
package-0.0-1.devel.rpm
Whatever scheme is used, I agree it is a mistake (and disengenuous to some degree) for popular packaging systems to actually undue one of *nixes tremendous strengths: library versioning and peaceful coexistence.
The Future of Human Evolution: Autonomy
My guess would be that much of this has to do with code reuse in graphical applications. Netscape takes up a lot of space, but not one byte can be used by other applications. In contrast, MS apps can make use of the code in IE (even the web browser part of Winamp).
The same could be said for StarOffice, which is a big bloated mess, but can't share its code.
The real future of Linux is looking towards things like Mozilla and galeon, where galeon can reuse the code from Mozilla to create a small browser.
-- Ever notice that fast-burning fuse looks exactly the same as slow-burning fuse? I didn't... (Edgar Montrose)
The primary difference, in my eyes, is that with open source, there's a chance of breaking this cycle. If people can be persuaded to support a larger project, or combine efforts when their applications are similar in purpose, then they can learn from each other's mistakes, and come up with a much better product. And, the little projects that fork off from the "core" codebase sometimes evolve into something that's better suited to a particular niche.
Would a tool like thttpd still exist if it had been written exculsively for Windows, and the source had been closed? Sure, Microsoft might have simply bought the rights to it, if users wanted that functionality, and rolled it into the IIS codebase. But then it would just be another checkbox on the same monolithic monster, instead of a tiny, hella-fast "ace in the hole" for certain applications.
I would hardly say that Windows programmers don't "recycle shit that's already written," since they largely put together their projects out of Microsoft-supplied code. The Windows platform basically forces you to use the "blessed" libraries. That may help to limit duplication of effort, but it also limits your choices.
Your examples of software projects that fail to have code reuse are mostly (or all, I'm not sure) propriatary non-free projects?!?
I've seen studies on the amount of code reuse among free software projects, and it's quite surprising how much is reused. For libraries you don't mention like readline and regex to small bits and pieces here and there.
"The only common denominator on those applications is libc and Xlib."
Perhaps you aren't aware of a little program called `ldd`. Try this:
ldd /usr/bin/* 2>/dev/null |grep "=>"|sort |tee /tmp/ldd.1 |cut -f 1 -d " "| uniq > /tmp/ldd.2; for i in `cat /tmp/ldd.2` ; do echo -n "$i : "; grep -c "$i" /tmp/ldd.1 ; done
That's what my "computing experience" is about, and it's not something I would ever want to try with a drag and drop interface.
The article is really good, but I think that he falls into the same trap as everyone else. What do I mean by that? He is creating another system to do componet level reuse when they should instead be focusing on a unifying policy. There are no less then four different object models at this point (Mozilla's XPCOM, Gnome's Bonobo, KDE's whatever their new name of the day is, and gnustep's ib).
/proc filesystem called /options. If you want to change something, cat a new value into it. If you want to find out what something is set to, read the file. Include interpreters to map sendmail options into the tree (something like /options/senmail/rulesets/6) and someway to store that either by a translator or in XML.
/World/Home. Options could be mapped into /World/Preferences/User or /World/Preferences/System). Persistantly write objects into somekind of back store by their Corba id or XPCOM id in /World/Objects/serialize/global or /World/Objects/serialize/local.
/usr/local/perl5
n t");
Instead they should be looking at a unified policy. The reason that Linux will never rule the desktop the way things are is because Microsoft is simple. You want to change a setting for the system? Goto the control panels. Change a setting for a application goto options->preferences.
I am not saying that these are the options to use, but instead imagine the following. Envision something like the
Better yet, do it in RDF and let any arbitrary program write to the RDF tree like a filesystem. For example, a translator could map the filesystem into something like
Use translators to set options for apache etc. Use mozilla or IExploder to set your configuration. You can probibly serialize objects into the RDF tree and bingo, you have poor-man's DCOM and object sharing. Wouldn't it be cool if you could write something like this in perl
#!
use UnifiedModel::RDF
my $print = new RDFNode("/world/www.ahost.com/objects/default_pri
$print->isA("Printer") || die 'Could not Open\n';
$print->print($text);
Why should we do this? By having a loose policy implemented via RDF or something, we have a single simple policy for storing information and a powerfull way to share componets.
I am seriously considering coding something like this. Anyone else interested?
>3. Mail Client.
>Sorry, but you've got no defense here. Balsa, Mutt, even emacs will read mail. Gnome folks are even building an Outlook clone.
>4. Editor. Uhh, I use vi and emacs when there is absolutely, positively, nothing else available. Don't get me wrong, I first learned emacs over 8 years ago. But there are some basic functions which I rely upon that don't exist in emacs. Give me something like HomeSite on a linux box and you've got a convert.
Try Screem.
That's whatI liked about the redhat distro. It came with Pico and pine. 2 great tastes that taste great together. If Corel Linux was made for the native win95 users for its fancy interface, why was pico and pine left out? Those to me are the easiest to use console mail/editor apps that I have used since 1993.
Just my 2 cents.
No, learning to code is not copying people's work. If you want to learn to code, then use parts. peices. Toy with it. But dont make an entire copy of some fucking way overdone app and post it on freshmeat and consider yourself a baddass open source hacker.
What he's really pointing out is UNIX doesn't have a modern middleware layer.
The history of modern middleware begins with Visual Basic "buttons", which were invented by Alan Cooper. (Microsoft bought this technology; it wasn't developed there.) Visual Basic made it possible to write medium-sized business applications with graphical user interfaces without much pain. Code reuse worked well in that environment, and it was easy to access a database. You could have the good programmers write a "button" and let the lesser programmers drag and drop the button into their app. This was a major driver in moving corporate America off the green-screen IBM mainframe terminals and onto Windows.
Programmers were pushing the "button" idea way beyond its intended uses. So Microsoft expanded it into COM, DCOM, and Active-X. It turned into a huge proprietary do-anything object system. But a lot of work gets done with that toolset, even though it's become ugly.
de Icaza has correctly identified the lack of a comparable middleware system as a serious problem in the UNIX world. Whether he can fix it remains to be seen. It's very hard to get this right. The past is littered with failed middleware environments: OpenDoc and NextStep come to mind.
A big problem is that if you let the object fanatics design the thing, it ends up too abstract and complex. If you let the UI designers design the thing, it ends up not powerful enough. CORBA and Prograph are at opposite ends of the spectrum here. (If you let the hackers design the thing, it ends up like Perl. Perl, remember, started as a tool for reading text logs. It's a special-purpose language pushed way beyond its design basis.) This requires really good engineering judgement.
For some insight on how to make design decisions here, read Weaving the Web, by Tim Berners-Lee (you know, the guy who invented HTML and the Web), page 182, where he discusses why HTML isn't a programming language like TeX. He says it better than I can, and I'm not going to repeat him here.
I hope de Icaza can pull it off. From reading his article, he has the basic good sense needed to get it right. Best of luck to that project.
This is exactly one of the reasons UNIX is in so much trouble -- even something simple like the concept of shared libraries (at least in practice) is a relatively new thing in much of the UNIX world. It's not very well understood, let alone welcomed.
People bitch and moan about having to deal with getting a whole bunch of libraries because of runtime dependencies. Deal. It's the cost of componentizing software, and it's not like there aren't tools that can manage the complexity for you (e.g. apt-get).
And, for those of you who don't think you need shared libraries, try replacing all the binaries on your system with statically linked versions and see how much disk space you have left...
There is also a good deal of management flexibility and efficiency that you gain through using higher-level component systems, as well. I know the Unix pipeline has been offered as a viable model, but it's not really complete enough.
Unless you extend the role of the filesystem abstraction as in Plan 9, the UNIX file/pipeline metaphor is simply not a viable component model in and of itself -- if it were, every application could be written as a shell script (which you can mostly do in Plan 9, btw, even if it would be a bit slow).
There's a point where you just have to stop managing all of the complexity yourself, and delgate some of it to software. The untyped data streams of the Unix pipeline (without the additional policy/flexibility imposed by Plan 9) don't sufficiently allow that.
Failing a Plan 9-esque level of abstraction, you're going to have to settle for a higher-level layer like Bonobo to really function in a modern environment.
DNA just wants to be free...
Well, the "integration" of Linux Mandrake of Helix GNOME is really sad. There is no single day that passes without Jacob receiving mail for the broken way Mandrake distributed Helix GNOME.
Miguel
The ability to evolve and survive is indeed one of the strongest features of and *NIX system, but there comes a time where rigid standards and enfored policies in the forground are necessary.
For instance OpenGroup has required CDE as part of a distribution in order for it to be called UNIX. Although I personally do not like CDE, the use of a standardized window manager that allows for multiple flavors of UNIX to look and feel similar is a necessity for its survival. It allows for application developers to hit a target that is not moving, they may have to deal with some library issues but they don't have to deal with customizing the UI to several different standards too.
At the same time we do need to keep the flexability that *NIX enjoys. That is one of the reasons why I switched to Linux. But I have quite a few friends who want to switch to Linux and just want a standard GUI. They don't want to deal with which window manager, which application manager, etc... They have enough problems deciding what distro to pick. They don't want to take sides in the geek religious wars that are being waged, they just want it to work and consistantly.
Linux needs more standards, especially in the GUI arena. I say keep the religious wars in the background, but allow them to be accessable to those who want to participate. Decide on standards and then send them to the forefront. This will make companies trying to support Linux happier, it will allow for easier customer support, and will draw in a larger group of users.
Disclamer - Opinion of Person
The biggest source of flexibility in UNIX is that everything can be manipulated with linguistic tools. If Microsoft ever ships a truly easy to use from-the-command-line scripting system that can easily interact with and manipulate COM objects, they'll have achieved much of the flexibility of UNIX. If they ship Perl/Python, then they'll have a language rich enough to generate its own hashtables and lists of data that can then be analyzed/treated as if it were a text file, and regexp's and the like will be available to work with their full COM suite.
I've spent almost five years now developing a GUI, object-based sysadmin project for UNIX, and it has taken almost that much time to convince some die-hard UNIX traditionalists here that the very poweful consistency safeguards, error checking, privilege delegation and support for n-user simultaneous editing that it provides was worth giving up the ability to do grep on the passwd file.
I'm with Miguel all the way on this.. something like COM can mean *more* flexibility, as long as we have good scripting tools that make working at the higher level easy, and as long as the COM-style interfaces are designed with a *lot* of thought towards flexibility and security.
If we get COM-style interfaces that prevent us from doing things that the designer thinks we shouldn't do (such as setting a pre-hashed password for a user account, which NT doesn't provide an API for), then a COM would become a barrier. If the interfaces are designed to be as open as possible while still hiding implementation -specific details and providing safety and error checking, then a COM becomes a tremedous strength.
I sure wish Miguel would have talked some about security, though.
- jon
Ganymede, a GPL'ed metadirectory for UNIX
Back when I was a total computer newbie, I was using a DOS computer. I knew nothing about DOS, but I had a program that would dial up to BBSes for me. My roommate set that program up, and I used it. After a few months, I got a shell account on an ISP. I knew nothing about the 'net or UNIX. This ISP had a great menu system, though. It would give me options for commonly used programs and system functions, and while it was doing that, it would print out the exact command that it did. After a while, I started using those commands directly at the system prompt, to save time.
Soon I was looking up man pages on various commands like vi, as I tired of the limits of pico. I was looking up various things on how to customize my shell and use it better. A little while after that I was installing Linux on my home system (this was a few months before kernel 1.0), and a couple months after I managed to get that working with X and PPP, I wiped out my DOS partition. I've been learning much more since.
I don't think I would have started out liking UNIX at all, if I didn't have some sort of guide like that character based menu, that told me exactly what was happening behind the scenes in the shell.
Something of this concept, perhaps in a GUI even, would be very good for beginners, and would do nothing to cripple things for advanced users.
It has often been argued that competition is good, and therefore we need both KDE and Gnome. But after reading Miguels very nice article it seems to me that this is not the case. The thing we really need is common standarts. If KDE and Gnome are not willing to make a common standart then it might be time for one of them to die.
I'm all for making things easy to learn. I am NOT in favor of making them just like Microsoft.
I totally agree that GNOME, KDE, Linux, and Posix based systems should try to avoid being like Microsoft (with the execption of COM / CORBA type stuff). Actually, I would say that user interface developers should say "Microsoft did it this way, that means it must be bad, unless there is real academic research backing this idea up." (real academic research means research not being preformed by the Microsoft did it all right morons who sometimes get tenure in CS departments.
Unfortunatly, I do not see how the complexity you describe relates to that (execpt the associate files of this type complaint). I do not think I'm the only one since all your other replies go to answering the library question without answering the associate file question or the larger question of copying Microsoft. This means you really need to express yurself more clearly.
Anyway, I agree with you, that there are many stupid things which GNOME (and KDE) get from Microsoft. They shuld really try to emulate a good user interface like Plan9.
The Christian religion has been and still is the principal enemy of moral progress in the world. -- Bertrand Russell
or those running slackware? same story
finkployd
Some very good points here. When I get moderation I'll remember to come back here and bring this up.
However, I'm not convinced that XML should be used. I would insist that the configuration file abstraction be one layer up, meaning any configuration format is allowed as long as the common parser can parse it into whatever the tree might look like in memory. Then your at the same point you would be if the file where xml. IOW the memory model is the same but persistent storage is cofigurable.
I have looked at XML quite a bit. I haven't written code for it, but think about what a typical config would look like in XML. Try something as trivial as syslog and you'll see how ugly it can get. Not all configs look like they map into XML as well as apache.conf or smb.conf.
KidSock
See my response to miguel
You are one confused person.
:-)
It is based on COM or whatever name they give to COM these days (COM+
miguel.
The GNOME project was started because of the licensing problems in KDE and Qt: the result was not a free system
Miguel
We have reduced all the complexity that you have described above now. To install, setup and configure your whole system:
lynx -source go-gnome.com | sh
We take care of the library issues for you, and you can focus on compiling Galeon (which we plan on including on Helix GNOME as well in the near future).
Miguel.
That said, Miguel has a point about code reuse, and my guess is that many people reinvent the wheel because they enjoy the challenge of coding. We certainly are on the way to reuse with things like Bonobo, and I think we'll see more reuse in major projects than we have in the past because it makes architectural sense.
Miguel also should have picked a better title. "Unix sucks" is *not* going to get the mainstream to read the article, they're too used to one-line sound bytes.
Q:Doctor, how many autopsies have you performed on dead people?
A:All my autopsies have been performed on dead peop
Or maybe I just don't try to use UNIX as a component-based system, and as such don't see it suck. Maybe I'm not fitting a square peg in a round hole (or vice versa). When I want object-ness, I do use BeOS. UNIX!=User-friendly object-mish-mash-component-SOAP-XML-Hype. UNIX is a way of thinking that's different than other paradigms, and because of this UNIX sucks? I hardly don't think so.
Free BeOS, runs from a Linux partition
Normal people (ie, non-zealots) call it X-Windows. It's a conciet from the popularity of Windows, but it's true.
The same reason people rarely say "GNU/Linux" - it's not that we don't love the GNU tools, but give me a break, it's Linux.
Coca-Cola would have an easier time trying to convince people to stop calling it "Coke". We like shorter, easier way to say things...
I'm an investigator. I followed a trail there.
Q.Tell me what the trail was.
Recursive: Adj. See Recursive.
I agree 100% with what you wrote. This is something that concerns me a great deal in general. If Microsoft has their way with .NET there will be no room for Linux. So what are the biggest elements with .NET?
t s/default_printer");
The ability to mix and match objects.
Fairly transparent object invocatation, and the ability to access your information anywhere.
What if we had some kind of system that stored everything in a browsable tree. Ie, any object could serialize itself to the tree, and anyone (provided they had access permisions) could access, store, read and run parts of the tree. Even more so, what if everyone could access their tree locally.
For example, In c++
umGeneric = new obj_from_tree("oft://objects.blah.com/World/objec
assert(obj_from_tree->isA("printer"));
printer->print(string);
Parts of the tree could be simple dictonaries (in java, or hash's in perl) that have configuration files etc.
Sorry, but wouldn't this be cool?
Anyone interested?
Part of the problem is that there is no "Unix", in a concrete sense. Unix is more of a Platonic ideal than a specific system. Solaris is a kind of Unix, HP-UX is a kind of Unix, Irix is a kind of Unix, Linux is a kind of Unix (OK, maybe not legally, but philosophically), but none of them is Unix. To say "Unix does foo" is misleading; Unix doesn't do anything - specific implementations do things.
Miguel uses examples like ssh, Samba, and Apache. Are those "Unix"? To my way of thinking, no; they're applications written for implementations of Unix. Bad applications do not make a bad OS - you can write a Windows application that doesn't use any reusable code and breaks every standard, but that doesn't change the strengths or weaknesses of Windows. Now, Miguel is right when he says (or implies, at least) that certain systems make it easy to write component-izable stuff, and Unix isn't one of them. But I think he's wrong in implying that a monolithic component architecture is the answer.
Unix applications don't use reusable code or talk to each other? Sure they do - and I'm not talking about pipes, either. Does your web browser care what network card you have? No, because it only talks to the layer of the stack directly below it, and each layer of the stack is a black box only providing a fixed set of services.
Part of the problem with Unix GUIs, I think, is that they've broken with the stack-oriented model to some degree. The application is responsible for too much, which is part of why X apps tend to look very different. Sure, you can link to Motif without worrying about Motif's internals, but that only exemplifies the problem - imagine if your web browser was "linked" to a specific network protocol!
I guess I'm partly agreeing with Miguel here, in that you should be able to code without worrying about how services are provided. The difference is that Miguel seems to think that centralization is the way to go, whereas I think that decentralization with proper understanding of responsibilities is the way to go. It looks to me like in Miguel's world, you'd be stuck with one model for everything, whereas in a protocol-layer world, you can change any layer without affecting others.
Hey, I am not a coder, just an end user and learned the hard way to just hate windows machines from experience and Linux is a godsent to me. I don't think I'll like a more "user friendly" machine if that implies dumbing down Linux! He writes: "Unix is a complex system internally despite its simplicity in its design, but it is not a system ready for end users. And this is what the GNOME project is building on top of the existing Unix foundation." Well, I for one am an end user, and like it the way it it, thank you very much! Let's hope this does not degenerate into another dumb box type operating system. Just my rant.
~~~Please pass the salt, I hate unsalted MD5s
True. It sno big harm. They just annoy me.
And my patience is thin. I need to get laid.
Except that GNOME is going about this entirely the wrong way. They're writing a lot of useful stuff (the canvas, html components, etc.) except they can't figure out why somebody would want to use this stuff outside of GNOME. GTK+ could benefit from the standard inclusion of some of these things and it's likie fighting for a firstborn to move them out of GNOME into GTK+.
Is it so strange that the GNOME team primarily write GNOME components? GTK+ is a small and fast widget set and I think huge complex components like the GNOME canvas is the last thing it needs.
Example: In the previous article about Miguel speaking (sorry, no reference), one poster mentioned how he had gotten flamed for taking the GNOME html component and removing the GNOME dependencies. Clearly, an html component that everybody can use is a good thing. Requiring GNOME to use this html component is not a good thing.
AFAIK the only "GNOME html component" around is the GtkHTML component (used for example in the Helix Code Installer, Updater and some wizards). I'm pretty sure it works in GTK+ only apps too.
What you describe is similar to what the OODS team is trying to put together. Their idea is to have a single API for interacting with any kind of data held in a directory-style structure, with the OODS software providing client access, permissions controls, and back-end data store drivers.
They are just at the point of planning and discussing everything.. it's not clear that any signficant amount of code will be written in the foreseeable future, but if you want to join a discussion with people who are working on this sort of thing, check it out.
- jon
Ganymede, a GPL'ed metadirectory for UNIX
* My Background
I was asked once at Usenix, once at OLS "How long have you been using Unix?". At OLS someone just assumed I was a newcomer that had used a Mac all its life, that I had no idea of what I was talking about, and that I would be better of clicking icons on my Mac.
I have been using Unix since the early 90s. My first contributions to free software was in 1992.
I was the main author of the GNU Midnight Commander, a file manager that was a clone of the DOS file manager called the Norton Commander.
Later, I started working with David Miller on the SPARC port of Linux: I worked on the kernel and on a bunch of device drivers that made the system usable. I also ported three libcs and did significant work on the various dynamic linkers used on the port (the libc4, the libc5 and worked partially on the GNU libc port).
Afterwards, I worked with Ingo and Gadi on the Linux software RAID-1/4/5 implementation. Ingo later perfected it to the beautiful levels you see now.
Later I joined the Linux/Indy team in which I worked on various tasks to bring up a complete system to Linux on the Indy. I abandoned the work when I began working on GNOME, three years ago.
Miguel
What is your point ? If you want a web browser, download one. Mozilla doesn't depend on GNOME or KDE, neither does good old netscape. If you want to use a GNOME app you need GNOME. Kinda like how if you want to run a Win32 app, you need the Win32 library. If you want to run a Mac app ... yup, you need whatever libraries MacOS provides. Lets even jump back a step. Why do I have to install pthreads if I want to run mySQL ? Some programs have requirements, and some people decided that they are going to write a GNOME app. So, you can either download the libraries (I prefer them to come in several small libraries then in on 100+MB library) or you go off and write your own.
No one is forcing you to use GNOME or KDE or XFce, and some people genuinely like them.
I don't think Unix was ever built to have a pretty interface. After the iMac, it seems everyone wants to abandon functionality for style. Not that Unix is losing functionality by this, it's just taking away time that might have been well spent developing other features.
Some OS's weren't make to be pretty, and I think unix is one of them. I much rather have it's power then any other other operating system's GUI any day...
Help me through college please!
Miguel
ESR says:
These are opposing viewpoints?! It looks to me like Miguel and ESR are on the same page.
---
As copyright owner of this comment, I authorize everyone to defeat any technological measure which limits access to it.
Look at Mozilla XPCOM for this. They are not that far away. Replace the usual RPC mechanism with SOAP, and you have something a bit bloated (not nearly as bad as CORBA tho) but completly open, and understandable.
I would love to do something like this.
There are things to complain about in Emacs, but lack of features? You must not be looking hard enough. There are always at least 2 or 3 different implementations of any conceivable feature...
"I believe that the cult of the particular brings only death - for it bases order on likeness." St.-Exupery
I was agreeing with Miguel up until the point where he said that the interface of MS windows 95 was better than we had in X at the time. I disagreed strongly with that, for one major reason: We had the window manager. That means when a program dies, it doesn't freeze to your screen and eat up real-estate. You can still minimize it or move it out of the way. Windows *STILL* doesn't have this feature today. I get sick and tired of the way in windows a slow app that starts up "hourglasses" the cursor, eats up all the screen real-estate, and can't be dismissed until it wakes up enough to pay attention to my mouseclicks. Plus, the annoying focus policy of "focused windows must be on top" is really annoying to anyone who's experienced the luxury of typing into a shell window that's only partly exposed, while looking at the window on top of it (perhaps as a reference to what you are typing). The MS GUI has some big problems, and it scares me a bit that the maker of GNOME is someone who praises it and (apparently) wants to emulate it. Yes, the UNIX interface is old and crusty. But imitating Windows is not the way to fix it.
Don't label something "offtopic" unless you know the topic well enough to tell what's on topic.
He's trying to turn our wonderful Unix-like systems into Windows.
I, for one, love the way applications are written now. He mentions how things like inetd and ssh have no code reuse. That's because they don't really do anything similar! libc does most of their work: socket(), connect(), select(), etc. There's no reason for these applications to share--and hence depend on--components.
Stay the fuck away from our Unix.
I'm far from a Microsoft programming expert, but I think I'm correct in stating that although these interfaces have indeed remained static up to now, this is more due to a design flaw than by design.
;-)
One of the real weaknesses of the MS way is that (as it has been explained to me), there is no way to extend a COM interface - any new functionality requires creating a completely new interface that exists alongside and is (usually) a superset of the old one. Of course, you must still support the old interface for backward compatibility, but this isn't always done. (This really makes some sense, since the alternative is code bloat, but it breaks things, especially if app vendors "update" a MS-supplied DLL.)
The DLL hell problem is quite serious, and has some significant and largely unknown side effects - here is one big reason why even W2K isn't up to enterprise duty: The DLL problem prevents running test and production versions of the same application simultaneously. Of course, this is something the Unix folks have handled forever simply by starting in another directory and/or tweaking the search path variables for executables and libraries. (For those of you MS folks that think it can be done, I have it on good authority (Microsoft's) that it cannnot be. It is possible to tie a particular DLL version to a particular app, but there is no way of ensuring that you will get the right DLL if another version of the same DLL has already been loaded into memory by another application (or another version of the same application.))
This sort of behaviour *MUST* be avoided at all costs!
As an aside, although I'm starting to be quite impressed with GNOME and it's rate of improvement (although it's an inexcusable resource pig), I still wonder how much farther we might be if this had all been done in Java, leveraging all those other components that are already built? (And yes I realize the freedom issues of a year or two ago. I also think they're almost totally fixed and/or irrelevant today - there are a lot of alternative implementations out there.)
It just pains me to see so much effort thrown at reinventing the wheel yet again, but without the benefit of portable binaries and the attendant abilty to automatically and dynamically define the client/server(s) split point(s). This ability will eventually make Java or something like it the winner, since you can only pull that trick off with binary code that runs wherever you decide to send it...
Miguel, if you read this, I'd be interested in your take on this latter point in particular. And keep up the good work, you may convert me yet...
"The future's good and the present is nothing to sneeze at." - Roblimo's last
One question, though... Are there many *n?x people out there who feel this is something we really need? Or is it just an accute case of code envy on the part of Miguel?
Information wants to be anthropomorphized.
UNIX is BUILT on highly modular components with a high level interface to glue them together. It's just that the components are command-line programs, and the glue is lines of text (records) through pipes.
Just because something's based on a command line with independent processes running in separate address spaces, and isn't object oriented, doesn't mean that it's not a modular, component-based architecture.
First, the dark green of links is hard to distinguish from the black in some conditions. Then there's the black for the "clicked link", so after I popped it up earlier then closed it before reading it, the link effectively disappeared. Then there's the philosophy of putting the link to the talk/paper/article *anywhere* but the first time it appears as a noun. In this case, I had to scrub the text with my mouse until the end where the cursor finally changed over "read"
I swear, reading slashdot is like playing myst some days.
I've finally had it: until slashdot gets article moderation, I am not coming back.
Hah, just the sort of West Undershirtian reply I'd expect. You are people too? Not from what I can tell. You sub-human visigoths are what give America a bad name abroad.
Go back to your single-wide, artificial stucco, outhouse-using life. You pig.
<SARCASM type=":)">
Potato chips are a by-yourself food.
How do you pronounce Miguel's last name?
I've finally had it: until slashdot gets article moderation, I am not coming back.
They're reinventing the wheel. The standard UNIX desktop environment, CDE, already has all this. ToolTalk provides a much more lightweight and nonintrusive distributed heterogeneous systems component architecture. ToolTalk is part of CDE. CDE is an excellent architecture for a complete desktop, and is already the standard. If you look into the technology, you'll see this. So basically, either these guys are completely ignorant of CDE's significance and capabilities, or they know about it and they just want their name on something (NIH).
This is not a troll, this is an illustration of an opposing viewpoint.
If I want to use some little GNOME program (say, Galeon), what do I need to do?
Download the program.
Figure out which libraries are needed for the GNOME stuff.
Figure out which libraries are needed BY the GNOME stuff.
Locate and download all those libraries.
Find a place to put all those libraries.
Debug all my existing applications because I just upgraded all my libraries (can you say "DLL hell"?)
Occasionally: Answer "NO" to a program that wants to "associate files of type ABC with this program"
I'm all for making things easy to learn. I am NOT in favor of making them just like Microsoft.
--
Linux MAPI Server!
http://www.openone.com/software/MailOne/
(Exchange Migration HOWTO coming soon)
I heard little about Miguel prior to 3 years ago which leads me to believe that he has never really worked with too many UNIX systems.
/usr/src/linux
:)
Do me a favor. Go to a shell and try this:
$ cd
$ find . -name '*.[ch]' | xargs grep Miguel
Take a long hard look at what you see. Then think about your statement.
Perhaps you should let Miguel know about some of your concerns. You can easily reach him at miguel@kernel.org. Or miguel@gnu.org.
--
Ian Peters
Posix was a term generated by the government in order to get around some restrictions. Basically, when the government is trying to set standards for what they will purchase and not purchase they cannot use trademarked names, ie they cannot say "We want a system that is UNIX complient." because UNIX is trademarked. What they can say is "We want a system that follows certain guidelines descriped in the Posix standard." and then make the Posix standard restrictive enough to limit the scope of what they buy to UNIX.
Posix is not the generic term for UNIX because even NT is Posix complient (barely, but it is) and we all know that NT is not UNIX.
As someone already mentioned in this thread, the UNIX trademark was sold by AT&T after the anti-trust ruling, AT&T had some major restrictions on anything not related to long distance communications. AT&T sold it to Novell, who sold it to SCO. From what I have been told SCO gave that trademark to some non-profit standards orginization, or something along those lines.
UNIX is not just a trademark but a standardization. In order for a product to legitamitly called UNIX it must follow certain conventions.
A more generic term is *nix, which refers to UNIX like. It covers UNIX, Linux, Minix, and several others.
Disclamer - Opinion of Person
Er... no.
You've tried to find a gui for unix equivalent to Windows, which last time I checked doesn't exist, and when you failed you started ranting. If you want to keep using the Windows gui, stick to Windows. Really lots of people use it for businss and leisure, it certainly isn't that bad.
But let's look closer at your beef with unix, and why in my opinion it is totally irrelevant. Has it ever occured to you that the majority of people actually using unix on the desktop are happy with it, or they wouldn't be using it, and they'd probably hate being forced to use Windows, or anything else for that matter, because it would be totally unfamiliar to them just like unix was to you?
Has it ever occured to you that these users couldn't care less if there's a gui & set of apps functionaly & visually equivalent to Windows, since they don't *need/want* that functionality?
And before you step in and say that if more people are to start using unix on the desktop, such a gui must be created, has it ever occured to you that such people minght not give a damn if more people start using it or not?
Why should they care what other people use on their home box. I'm using someting that I know, like and am familiar with. If you don't like it, I honestly couldn't care less. I don't care what my users are using on our network either. They should be and are free to shoot their feet any way they please.
Lately I've been using windowmaker + wterms + gtk (gtkstep rocks!) w/ some gtk apps (gimp, gtksee, xchat...) and netscape etc. During the last year or so I seem to have stabilized on a consistent setup on my laptop, workstation at home & work etc., before that I would experiment often, try new things etc. Thing is, it's been almost a year since i last did a dramatic change on the setup appart from the odd upgrade here and there, the occasional tweak here and the odd background image change =P
I can say that I finally found the ideal gui for myself - i'm very productive, everything is in the right place, it's readable (contrary to 99% of the themes on theme.org). Granted this path to nirvana wasn't painless, but hey, there's no way an out of the box gui can please all people. Accepting anything prepackaged is bound to be a compromise, including windows.
Chances are, you're probably not gonna like my setup. My point is though, that I'm not gonna like your windows setup either. You miss some windows apps on unix, I'd miss some unix apps on windows.
Oh, and for the curious, here are some shots of my gui nirvana:
shot 1
shot 2
Is the interface definition used to determine "compatability" of an object for a particular purpose? Can interfaces evolve? Can an object add functionality, but still be used by other, older objects for the older purposes? Must an evolving object conform to several interfaces (adding bloat), or can there be v2.0 of an interface, after the designer realizes there's a Better Way to do it?
These are hard problems, and ones I was not able to answer to my satisfaction. Evidinced by their software, it seems that M$ has not either. Do you really want to embed an editable spreadsheet in a document, and deal with the bloat and crashes that will occur? Or is there a Better Way?
Of course, I could probably answer all these questions by digging into the Bonobo and CORBA documentation, but stimulating discussion is good too.
--Bob
1^2=1; (-1)^2=1; 1^2=(-1)^2; 1=-1; 1=0.
The core of Miguel's argument is that the Unix world is in chaos because the designers of Unix have failed to form and enforce policy down the years. A good point.
But let's look at the history of Unix here:
Now, Miguel, could you please tell me precisely how is one going to enforce policy on such a disparate user base, most of whom are going to react with instinctive loathing towards anybody attempting to throw their weight around, to say my thing is The Right Thing damnit, for whatever reason?
Unix has survived precisely because there is no hallowed policy handed down from above. It evolves. It changes to meet new needs. Those components of Unix that are shared, like glibc, have developed through consensus and bitter experience. If you want to develop in an enforced-policy environment, well, there's Windows NT or VMS or OS/390.
The Cluetrain has already left the station, Miguel. You on it or under it?
--
Cat Mara
Love me, I'm a liberal!
>Sorry, but you've got no defense here. Balsa, Mutt, even emacs will read mail.
And none of them handle multiple POP accounts. Mutt certainly isn't going to display that scan of the new baby in the message, or show a company logo at the top. I guess no one ever included pictures in snail mail either or ever wrote on letterhead either. But YOU have no use for these features, so they're useless, right?
I've finally had it: until slashdot gets article moderation, I am not coming back.
As for Java, remember that the GNOME guys are all rabid free software zealots and wouldn't dream of depending on a proprietary language like that :). Nor do they have the marketing
team to force people to switch to another superior language (see
what happened to ObjC, Eiffel etc). So C compatibility
is really the only way to go.
A Dick and a Bush .. You know somebody's gonna get screwed.
War is necrophilia.
First, is anyone from GNOME talking to anyone from GNUstep? While approve of the Bonobo architecture ideas, it looks to me like the two are doing very similar things. (And WindowMaker rocks my world.) Second -- does anyone else think that an object-based OS doesn't really sound like UNIX? -_Quinn
Reality Maintenance Group, Silver City Construction Co., Ltd.
Bloat!=Flexibility. You wouldn't believe how overbloated GNOME and KDE are. From my experiance, BeOS has a fairly complete application framework, with a lot of consitancy. It is also the lightest major OS available on x86 (with the exception of QNX Neutrino). (Out of *BSD, *NIX, Windows, etc) The major problem is that GNOME and KDE suffer from huge feature bloat. GNOME implements a file system, uses CORBA (trying to kill a fly with a Buick there) for objects, and in general puts in a lot of stuff 99% of people don't need. Consistancy does not have to be accompanied by huge overbloat. I just has to be designed with some sense of what would be better if left out.
A deep unwavering belief is a sure sign you're missing something...
The main thing is that in UNIX, too much policy is bad. Overall the lack of policy is done to overkill propertions in UNIX, but it is still a good idea. Also, performance comes first. Do you realize how god-aweful slow a CORBA based filesystem would be? The thing is the more you abstract, the more performance you lose. Up to a certain point it's a good idea, but beyond that it's not such a good idea. The component interface you mention is already implemented to some degree on OLE. As the designers put it, "OLE is 2/3rds of an operating system." However, using to it's full potential is a very performance robbing proposition.
A deep unwavering belief is a sure sign you're missing something...
Is it so strange that the GNOME team primarily write GNOME components? GTK+ is a small and fast widget set and I think huge complex components like the GNOME canvas is the last thing it needs.
I have nothing against the GNOME team writing GNOME components. I do have a problem with them writing incredibly useful components that could be used at a lower level than GNOME. Now, it's hard to decide exactly what should get backported from GNOME to GTK+, but if nothing else, things could get separated out to only depend on GTK+. Then GNOME could use those -- much better code reuse. That keeps GTK+ a "small and fast" widget set and benefits those programmers who don't care for GNOME but would like some GNOME-type functionality in their app.
AFAIK the only "GNOME html component" around is the GtkHTML component (used for example in the Helix Code Installer, Updater and some wizards). I'm pretty sure it works in GTK+ only apps too.
Well gosh, why don't you check out the Debian package page for GtkHTML and explain to me how it only depends on GTK+. And no, I'm not concerned about the image libraries; those are pretty standard and easily compilable.
-Nathan
Hypercard was an interesting system, weighted down by a terrible scripting language. Hypertalk was painfully similar to COBOL-60, ("add 1 to a") and had terrible data access ("field 3 of item 4 of card 9341"). Hypercard also turned out to be a ripoff of Zoomracks for the Atari, so Apple had some problems there.
Hypercard's "component model" was weak; you couldn't write components in Hypercard. It was more like a plug-in system, and in fact most Hypercard plug-ins were to provide access to something Hypercard didn't support, like networking.
Hypercard didn't really lead anywhere. Still, Cyan's Manhole and Cosmic Ozmo, the 2D black and white predecessors to Myst, were written in Hypercard, an impressive achievement.
Now, I hate Windows as much as any loyal /.'er, but Microsoft has made a concerted effort to make object-oriented programming easy on their systems. It may run like crap and be painful to anyone who knows better, but Visual Basic does make OO a breeze to understand and work with, and COM is so tightly integrated into Windows these days that you can't sneeze without hitting it.
So, where does that leave us, the Linux/BSD/(insert-your-*NIX-flavor-here) faithful? Well, we have a few options. We could continue to try to pile layer after layer of abstraction on top of the core system, ending up with something that's highly understandable at the top levels, but an ugly mess of spaghetti code in the middle. Personally, I suspect that much of the bloat and instability of Windows comes from just this kind of sandbagging. Alternately, we could leave all that new-fangled OO stuff to the boys in Redmond, and continue happily spending our days piping text from place to place.
Personally, neither of these sounds all that great to me. I think we need to step back a bit, and start working OO services in at the operating system level. C++, Java, and the rest of the object-oriented languages are here to stay, and they deserve to made the be equals of C, Perl, and assembler in the UNIX programming model. Right now, what we have are wrappers for a bunch of C libraries -- a layer of interference that shouldn't be necessary. From a developer's standpoint, it's much easier to feed flat data to an object than it is to feed an object to something that's expecting text; doesn't it make sense to put the power at the low levels of the system, then, and simplify as we move up?
Your whole point is based on the freedom of the developer. That is not the best way to do anything of software. There should be a single, flexible, powerful model, and all developers should be required to program to it. I really don't give a rat's ass if that means I have to program for a certain toolkit (from a developer's point of view) if it means that all applications use the full power of the system toolkit and interact well together (User's POV). Compared to Microsoft components on Linux is still a pipe-dream. Where on windows most modern apps use OLE and COM and take advantage of the features they provide (not only objects, but scripting, and network transparency) and applications extensivly use the component technologies, you've got the current GNOME/KDE situation where there are different object models, no-one uses them to their full potential, and all the really important apps don't work well together. I want to be able to take a spread sheet from StarOffice and embed it into a GIMP picture which is embedded into a StarOffice document. Since neither app really takes advantage of the component model I can't do that. Also, implementing objects in high level languages would be insane. MS doesn't use Visual Basic for most components, the easiest language to use COM from is C++. Python would be terrible slow. Components should be lean, mean, fast, network transparent objects from which to build applications. Only if they meet these criteria (lean, fast and pervasive) will they succeed.
A deep unwavering belief is a sure sign you're missing something...
As a realitive Newbie to Linux/UNIX myself, I find the whole system clunky and dificult to configure. I do have high hopes and am glad to see another OS finaly worth the trouble, but it's a pain in the ass. I'm making my way through it, but it's not something I would put in front of my parents/friends and tell them to use yet. I'ts too easy to sit on a high horse and tell people it's not that hard, Windows and Mac users have been bitching at each other for years about this, and the short point of it all is: you know what you know and are scared of anything else. Most people are just not "tinkerers". they want something that works out of the box. I can't see UNIX ever getting that easy to use, but I think Linux is almost there.
Dirty Pirate Hooker
This Post Is Way Off-Topic :)
Having Cherokee Indian blood in me, I don't see it as racism, for a couple of reasons:
One, there's nothing wrong with Indian. In fact, most Indians prefer Indian to "Native American". They were called Indians not because Columbus thought he reached India, but from his log, which he described the natives he found as being "in dios" (with God). (Columbus's spanish wasn't terribly good) I think that's a lot better than naming them after an Italian cartographer.
Two, the colloquialism "off the reservation" is an old one. I have no idea about it's origin. I use it because it best describes what happened -- Miguel, a true hacker, has wandered off the sacred tribal grounds and is basically throwing stones at Unix.
I wasn't trying to be offensive, just, as you say, "colorful".
As a side note, the Indians have more grounds than anybody in this country to bitch and moan about how they were treated. This is why I like Tribal casinos -- I like the idea of the Indians losing their land, but getting money for it from fat-assed yahoos from West Undershirt, Ohio.
Potato chips are a by-yourself food.
But I think neither COM nor CORBA are the answer. COM and CORBA are both rather complex systems because they are trying to patch up deficiencies in the underlying languages, C and C++. In an environment that encourages reuse, you should be able to just serialize and send objects to other components without lots of error-prone declarations. Such systems exist, and have existed for decades. But you simply can't build them reliably on top of C/C++.
Ten years ago, Objective-C was a pragmatic and efficient answer to that problem. Objective-C is simpler than IDL and gives programmers more power. Today, the obvious answer would seem to be Java, although even it is still more complex than it probably ought to be.
While I appreciate the short term utility of Gnome, I think in the long term, the effect of the Gnome project (and KDE, for that matter) is going to be harmful. It continues to encourage people to develop in and for an environment that is fundamentally not well suited to building software components and getting a lot of code reuse.
If people want to do something relevant for end users in an industry-standard environment, I think they should contribute to Java-based desktop application efforts. The Gnome programmers are smart and capable: if even a fraction of the Gnome effort went into open source Java implementation (e.g., kaffe) and Java desktop apps (e.g., JFA), we'd soon have a good environment that would be much easier to extend with new components than a big C/CORBA system.
Let's forget the fact that Miguel did use the word "suck".
OK, now, the rest of this document highlight some features that Miguel'd like to see in Unix.
IMHO, some of these features could be worth coding. And accepting that we don't have them unlike others is fair.
If we want to prove him that Unix doesn't suck, well, just prove him that Unix is open enough to easily embed the features he asks.
These are reasonable features that would certainly benefit Unix, and Gnome in peculiar (by "benefit", I mean bring their users to new levels of computing ease).
I personaly enjoy it and understand Miguel's message as a challenge.
--
Trolling using another account since 2005.
I'll probably get downgraded to flamebait, but...
... it almost seems to me that article was more about how wonderful Gnome is than how to improve Unix. In my experience, Gnome creates at least one new problem for every one that it solves. It is bloated beyond belief. My new computer is a 2x600Mhz that runs X at the exact same slow speed as my old 1x300Mhz thanks to the fact that it came pre-installed with Gnome.
Additionally, all of these wonderful libraries create dependency problems that make it virtually impossible to upgrade your system or install any new apps. Every time I've tried to sample a new or upgraded Gnome app, it tells me I've got to download a new library. But since all the libraries depend on each other you end up having to download at least half a dozen huge files. It is ridiculous that even the simplest of apps depends on so much megabloat code.
And the only way any of this stuff will define "policy" or encourage reuse is if Gnome is the 100% development standard, something I think is unrealistic.
I just wanted to weigh in with the fact that I got interested in UNIX in general and Linux in particular *because* of the command line and the generally wack interface, not in spite of it. It's true that when I'm in Linux, I'm nearly always in X, but I do all my file management etc. in an rxvt, not an Explorer-type file manager.
I must say that I do lament the lack of a standard application framework that would give some consistency to most programs: same hotkeys, same type of menu bars, etc. But, if to get that I have to put up with all the extra crap that comes with GNOME or KDE, plus having to continually update such a huge and rapidly changing chunk of software, I'd rather just tolerate rampant inconsistency.
MoNsTeR
Quick sidenote: I will admit to a wording snafu (fu*kup) this message was not meant to flame your credentials
PX: I heard little about Miguel prior to 3 years ago which leads me to believe that he has never really worked with too many UNIX systems.
I should practice what I preach by "thinking before I type".
As other people have pointed out, reference counting is the way COM manages these things--- and it almost, sorta, kinda works for a little while in the demo and on the LAN. Perhaps the gnome guys just want to be bug for bug compatible.
Reference counting is a bad idea whose time has passed. When faced with the inevitable programming and network errors reference counting leaks. In some circumstances these leaks are just little bits of memory and don't really matter (if you don't mind poor performance and restarting every now and then). But sometimes the leaks are locks and expensive things. Leaking these can easily lead to deadlock. Deadlock is as hard problem as distributed garbage collection. Don't go that way. Don't allow leaks.
Corba objects can typically timeout and save themselves to disk and be transparently reinstanciated when needed. Thats good enough for some objects; if you don't mind leaking disk space.
A leasing model works well. The client wants a foo for 500s. Great. Maybe it wants to renew. Also great. And if the client disapears without a trace (somebody hung up the modem or tripped on a cable or went out to lunch or whatever...) the server is free to clean up that foo. If it needs to, the client maybe forced to get another foo. Thats ok.
Most programs in most languages leak their own memory. Why would you trust those same client programs to meticulously solve your distributed garbage collection problem? If you are a defensive programmer, you don't. Even if you did, you wouldn't trust the internet to have 100% uptime; it doesn't. Instead you use leasing and/or timeouts.
Cheers, Henry
/etc must die.
/etc and /usr and /lib structure was spawned from the mind of a C programmer in which global data is deemed an acceptable solution. /etc is a form of global data, which is fragile and inherently carries minimal context. It's fragile in that there's no standard interface to retrieve config properties - so that any program other than the parent of the config file cannot reliably expect to parse it. And, without context, it's unclear which programs depend on a particular config file.
/etc!
Miguel touches on the mess of configuring services. He proposes a solution for working with existing configuration files using a perl backend and GUI frontend. This is an admirable short term solution for a larger, significant problem.
The inherent problem is that standard unix
In the spirit of the changes proposed by Miguel, I propose that applications and otherwise all packages be components even in the way they live in the system. Let every package have an arbirary, unique directory, and let everything owned by a package live only in that directory. Let there be a common system component that exposes packages and their configuration on request. Let all packages find and expose other packages only through this component. Let the system package component internally record at most where to find other packages. Further configuration is stored in the package's own directory.
There are a number of advantages to this model:
1. First order installation becomes trivial. Just dump everything into a directory. The system package component will automatically find it.
2. Complete uninstall becomes trivial. Just blow away the package's directory.
3. Exposing a package's configuration is standardized, stable, and protected through the system package component.
4. "Custom" packages and their configuration is trivially persistent across reinstalling the operating system.
This is a problem that has been clumsily attacked by both RPM's and the MS Window's reigstry. Both tried to solve the problem by making prodigious use of massive amounts of internal data - data that is subject to unneccesary and unwanted management and corruption. With the proposed system package component, the small amount of internal data is easily reconstructed by scanning the file system. If you assert that packages access even their own configuration data through the system package component (much like the interface to a registry), then each package's configuration data can be stored in something standard and sane, like config.xml.
I code. If you want help, I'll give it.
Down with global data! Down with
- Cory
Wow.. And I thought the /. bias wasn't that bad.. We're about 40 comments into this story already and every one that has been moderated up is people saying "Hey, come on, Unix doesn't suck, Windows does" and they go on to compare the Strengths of Unix vs the Weaknesses of Windows. Just like Miguel was talking about in the story (which I'm sure about 5 of the people posting comments has read)
Now, why don't we all go back and read the article? Miguel is very very right. He's been saying some of the things that Unix zealots have been covering their ears over for ages now. Component architectures are vital to a good GUI, code reuse is key. One of the things that people insist on doing in Unix is reinventing the wheel every time they need something done.
I'm glad someone who can't be ignored by the community is finally saying all this. Maybe someone will listen for once.
Think about this: you're working on "rebuilding that damn kernel" instead of doing something useful with that OS that doesn't suck. There are two things you can do with a computer: use it to get something done, or tinker with it for fun. Nothing wrong with the latter, but remember that most people are interested only in the former.
--
$x='S24;r)>63/* h@<5+oZ)32"5cz';$me='phroggy'x$];
$x=~y+ -xz+\0-Tx+;print$_^chop$me for split'',$x;
Miguel de Icaza seems like an otherwise intelligent guy, so I have to assume that CORBA is forcing the use of reference counting here. If that's so, then CORBA sucks even worse than I thought.
To a Lisp hacker, XML is S-expressions in drag.
Under the "Unix Problem" Miguel tries his best in a few paragraphs to expose the history, and weaknesses of UNIX. I find this quick leadin not only completely flawed but mostly wrong.
He says that three years ago
"No innovation was happening". Which is odd because I remember running BSD and Linux in the early 90's - even before then my SGI hardware was bad ass and could whomp on whatever Macintosh, Amiga, or Atari ST could produce.
"No code reuse was happening". This is not only untrue, but downright weird to even think about. He states later that the systems developed (interfaces, abstraction, etc.) were flawed - even if they did reuse code - why would you want to? Code reuse is up to the program managers and programmers in a business model or the leaders of the project in the open source model. I do not see his point.
"There was a lack of basic facilities on the desktop". Well duh, you can't just say "here's a new OS - everyone support it". Linux has become popular and people run it, that's why there is support for it. Which leads into his next statement "The little innovation that was happening was proprietary.". If something is going to exist in a business model it must have support - this is why it was proprietary. More and more companies are being able to innovate in UNIXland because support is so wide - largely due to the open source model.
Later he complains about "Unix Components" - where they don't share "any code except for libc". This can be argued both ways. These sort of programs are as basic as format, fdisk, and tree. These are not designed to share code, they are designed to be small and singular. He makes the jump of ftpd to ghostview to Internet Explorer. This is not only unfair, but flawed logic. One is a service, which does not need a gui - one is a very old application (much like notepad in windows) and the other is an application that has taken a long time to kludge together.
My problem with this paper is that he just does not get it. He understands a *lot* about how to build GUI's and how to frame together a Rapid Application model. In this sense he is genius, yet in another he just doesn't seem to understand WHAT it is that he is building on top of. He complains about xlib, libc, services, and all the like. He doesn't look at the standards that were developed way back - such as POSIX and WHY they were developed, and *how* we got to where we are. He simply asserts that 3 years ago was "dark ages" and that today there is hope. I heard little about Miguel prior to 3 years ago which leads me to believe that he has never really worked with too many UNIX systems. If he wants to make a GUI, or even a GUI framework like X then great - more power to him! But I wish that Miguel would think more before he talks on subjects such as these because most people will simply flame him.
Please Miguel, think before you type.
If you spend much time looking at .NET, you'd realize that it's essentially built on top of COM itself.
.NET, let alone transcending it.
You need something like DCOM implemented first before you can even think of implementing something like
DNA just wants to be free...
Miguel's article is spot on. I love everything about Unix except the fact that Component Based programming is so underused. If there is only one thing Microsoft has done right, it is the way they have developed and pushed COM. With COM, I can write a piece of software that performs a task (be it a Widget or piece of middleware) and COMify it.
Except that GNOME is going about this entirely the wrong way. They're writing a lot of useful stuff (the canvas, html components, etc.) except they can't figure out why somebody would want to use this stuff outside of GNOME. GTK+ could benefit from the standard inclusion of some of these things and it's likie fighting for a firstborn to move them out of GNOME into GTK+.
Example: In the previous article about Miguel speaking (sorry, no reference), one poster mentioned how he had gotten flamed for taking the GNOME html component and removing the GNOME dependencies. Clearly, an html component that everybody can use is a good thing. Requiring GNOME to use this html component is not a good thing.
Write the reusable software at the right level; don't GNOMEify everything in the name of "software reuse".
-Nathan
Wow, it's always tough when a true Indian wanders off the reservation!
Well, he has a point. Unix should be the first OS to use modularized components with rampant code-reuse, not one of the last. Remember part of the Hacker Ethic: do not re-invent the wheel.
Imagine! Maybe Microsoft does do some things very well! (I know IE has much better support of CSS than Netscape does -- not to beat a dead horse, but Mozilla isn't looking all that great either on several fronts). Could it be that this modularity (even done as slipshod as it is on Microsoft OSes) is part of what encourages people to write software for Microsoft? Ease of development? (I'm not a True Programmer, so <TAKE type="salt" size="grain">
I wish the best for Helixcode -- just before you get carried away with making it "easy to use", try to get some UI experts in there to help design things. Just because it has a button doesn't mean it's easy to use. Where the button is placed is just as important as having the button.
Potato chips are a by-yourself food.
That was a very, very good article by Miguel. Unfortunately the first few posts I have read are from posters who obviously didn't read it and instead are making personal attacks at Miguel.
.NET for one reason only...cross language inheritance. The thought that my C++ components can be inherited by my Perl, Java or Javascript objects makes me extremely *CENSORED*.
Miguel's article is spot on. I love everything about Unix except the fact that Component Based programming is so underused. If there is only one thing Microsoft has done right, it is the way they have developed and pushed COM. With COM, I can write a piece of software that performs a task (be it a Widget or piece of middleware) and COMify it.
Once this is done, anyone can use it regardless of what language it was written in, fast XML parsers can be written in C++ and used in from Javascript or VB. This way developers of business apps do not have to make the choice between a.) putting up with a slow app or b.) writing one themselves with all the attendant bugs therein especially if they have little C++/C skills, also they can go on towards actually creating their application instead of worrying about if they malloced() enough space for their char*'s.
Lots of *nix people believe this implies laziness but fail to realize that reinventing the wheel dozens of times over is folly.
Example I:
I am currently designing and implementing a project management system on Windows(TM) for a small business with a few of my friends. two of them are *nix hackers and they balked at using an XML based protocol to transfer data between the client and server. Now instead of simply designing our protocol then using one of the dozens of available parsers to do this, they decided that we should invent our own binary protocol and write our own parser to parse it.
Our project involves code written in both C++ and Javascript/ASP. We could have used a single COM based parser to consistly interact with the data both from the C++ and the Javascript code but instead its been 2 weeks and counting and our homegrown parser is still being written, tested and debugged. In my opinion this is nothing but a waste of time. When I ask them why not just use XML and an already existing parser their replies boil down to "It just feels wrong.". The chances that a bug or two will slip through in testing or that there is a buffer overflow in our parser is not unlikely considering that most early versions of parsers written in C++ have a few bugs like this hidden somewhere. in this situation component based programming would have allowed us to focus on building and designing our actual application instead of focusing time and energy on a tangential application.
Example II:
At work a MBA intern asked me if it was possible to create an application that housed a search engine that searched a database of MBA students based on criteria like concentration, work experience, graduation date, etc. and then displayed results with links to their resumes in MSFT Word(TM) or HTML format which could be stored on a CD to give recruiters at career fairs. Their first attempt had been to use VB and Access which turned out to be a disaster because of DLL Hell based issues. My simple solution was for them to store all the students in an XML file and to write a Javascript page that used the COM based XML parser (written in C++) to perform the search. Writing this page took less than 2 hours.
Now they have this search functionality they can press on a CD and give out at career fairs which any recruiter can view without needing more than MSIE 4.0 or greater.
Without Component based programming their request would have been impossible to fill in their time frame and would have also required that the recruiters machines would need to fulfill a stricter set of requirements (like a Webserver being installed or they'd have to install an app).
In conclusion my question is "Why has it taken so long for a major *nix push towards component based technology?". After all we've had CORBA for almost a decade but there hasn't been that much a big push towards components. Frankly I am eagerly awaiting MSFT's
FOOD FOR THOUGHT
I think that we'll find out that the MS VM is going to force languages to make severe sacrifices to be compatible with each other. Look at the eiffel implementation (called eiffel# of course). It gives up multiple inheritance amongst other things so that it can live in the VM.
A Dick and a Bush .. You know somebody's gonna get screwed.
War is necrophilia.
Of course, Miguel's original claim to fame comes from the sterling work he did on the Sparc Linux port many years ago. Due to his recent work with Gnome, few people realise how talented a kernel programmer he is...
"The invisible and the non-existent look very much alike." -- Delos B. McKown
Linux on the server: happy happy. Wouldn't choose otherwise.
Linux on the desktop: does indeed SUCK.
I've been using Unix in a server environment since 1992. Never had any major problems. On the desktop, I started with Mac, fiddled with NeXT, tried Sun and DEC workstations, and eventual moved to M$ Windows (for gaming, nothing else compares).
All of those OS's have their strengths and weaknesses. And, in hope af creating a better world, last week I bought an extra hard drive and installed Linux (RedHat 6.2, am told Debian is better but no CD available) on it to play around.
In general, a less than fulfilling experience. Here are my observations:
1. I have to choose a desktop environemnt? GNOME or KDE? I'm supposed to know which has better Apps? Great idea - split a limited developers pool among two environments - so instead of getting one set of applications that work well, we get two sets of applications that are in perpetual beta.
2. Web Browser. At no time while using a PC do I have less than 4 or 5 browser windows open. Trying to work without a functional browser is difficult, if not impossible. I just don't enjoy opening NN and seeing my available memory disappear. (Last week, Mozilla was declared dead - how could this happen when it hasn't even been born yet?)
3. Mail Client. I spent days looking for a mail client for GNOME which supported multiple POP mailboxes. I found a few, but they ended up in wild-goose chases for libraries to replace those which where outdated, too new, etc. Never actually got anything to compile. Heard there's a good mail client for KDE, which means I made the wrong choice back at #1.
4. Editor. Uhh, I use vi and emacs when there is absolutely, positively, nothing else available. Don't get me wrong, I first learned emacs over 8 years ago. But there are some basic functions which I rely upon that don't exist in emacs. Give me something like HomeSite on a linux box and you've got a convert.
5. Word and Excel. Regardless of how much other Microsoft software sucks, these two products are hard to beat. Also, they are practically industry standards. If you work in any office environment, you'll be sure to get these sent to you all the time. Of course, you can read them from your linux box - but if you want to edit them, it's lilo:dos yet again.
I use my computer to work. It is a tool which I need to function efficiently. I played with my new Linux Desktop for a few days, then when I had real work to do, I rebooted back to DOS. A real disappointment.
I know, it's open source, help and code it instead of complaining. I do code open source software, but for web applications. I don't code for the desktop. To grow, linux needs the desktop. To win on the desktop, Linux needs the killer apps - at least a browser, a good mail client, and an editor.
To get there, I'll argue that Linux needs less developers rather than more. I'm tired of seeing 2000 new apps which are v.0.0.0.1beta0.0.5-unstable. The paradigm of "release early and often" needs to be rethought. Release when you have a functioning application. If you have an idea for a new app, look around to see if anything else is out there first. If someone is already working on the same application, join them rather than creating a new tarball which will never get out of beta.
Open Source can and will take over. But it won't do so without the Desktop. And the desktop is all about applications.
It seems like a lot of people are missing Miguel's point. He is not saying that you *must* do it this way, he is just saying that this is just one way of doing it, a way that he feels is better.
What I see as one of the points here is that a lot of people are wasting a lot of time by writing a bunch of support code for their application because they are not reusing code. How this hurts us is the fact that this time could be used more effectively on working on the logic of the application, rather than rewriting yet another html parser or whatever.
I know on a few pieces of software I have written I ended up using glib, because there are just so many nifty functions that programmers are constantly rewriting. And I can see his point after using what is still a fairly lowlevel interface.
Also, as far as a lot of people saying, well we have pipes and that's all we'll ever need is just silly. I mean yes, pipes are neat, but god damn, how do you really expect to write anything complex and have it be relatively fast when your swishing data via pipes and firing off a bunch of new processes via fork().
Modularity is really the key to have a extensible OS. Linux to some extent is modular, but not really. Take a look at the HURD for example, from the design viewpoint, its a beautiful kernel. Sure microkernels are a bit slower than a monolithic kernel at this point, but what difference does say a 3% performance hit matter.
Code sharing and reuse is really what open source programs should be about. There should be common APIs and interfaces. Lets let go of some of the baggage that has accumlated with us over the years and stop trying to be a UNIX workalike and do something innovative. Linux and GNU are really the standards that the rest of the Unix community are trying to live up to now, we should show a bit of leadership here.
The hardware will make up for the speed loss. It certainly can't make up for the time I spend rewriting the same components other folks have done before because they aren't available in my language, or writing library bindings to python and perl and whichever other lib happens to be in vogue...
GNOME may not be a perfect answer right now, but that doesn't make it not a Good Thing in the long run.
Upgrade removes old versions. Install keeps them.
It's hard to see how so many people are getting this mixed up.
Only if you are obtuse is it difficult to see how people would mix this up.
Many libraries packages, when one attempts to "install" them, report that they conflict with some older version of the same library. The natural thing for a user is to think "of course, I need to upgrade" and do so, promptly removing the older, conflicting package.
It is in no way intuitive to use "--install --force", particularly when "--force" is documented as being dangerous to use.
The default behavior of "--upgrade" should be to not remove the older libraries, but install the newer libraries such that they coexist, without offensive messages warning of conflicts and dire consiquences. If someone wants to remove the older version of the library a modified "--upgrade" switch should be used, perhaps "--upgrade-remove-old" or something equally intuitive.
I've been using Linux since the 0.49 days, and UNIX even longer than that, but one of the real problems the *nix community really has is an almost religious unwillingness to accept criticism. This is counter productive and doesn't help any of us (except maybe Redmond).
RPM upgrades as they are currently implimented behave in some non-intuitive and confusing ways. Is it really so difficult to accept a little criticism and improve the semantics, such that even the newer, less experienced users have an easier time coming to grips with it?
The Future of Human Evolution: Autonomy
It's thoroughly off topic, but this occured to me last night and I thought I would post it (now that I have found the key to the Bomb-shelter)
WE'LL RANT AND WE'LL ROAR:
(To the tune of "Spanish Ladies" (many versions) or "Rant And Roar" (Great Blue Sea for example))
By Phrogman (http://www.omphalos.net)
My nickname is "Troll-bait" or "Anonymous Coward",
My comments are leading so you'll have a go,
If you like Linux, I'll be MS-man,
You'll look hard to find me, cause my Karma's so low...
Chorus:
We'll rant and we'll roar like true Slashdot addicts,
We'll foam as we read with our threshold set low,
If its about Linux, we treat it like gospel,
'Cause if Slashdot will post it, we know that its so.
I like to pour hot grits down the front of my blue-jeans,
I'd love to see Natalie frozen like stone,
I don't have the brains to come up with a comment,
I would rather waste bandwidth like a meaningless drone.
(Chorus)
I am a true Slashgeek, my system runs linux,
My software is all GNU, and well-used,
My dreams are in hexcode, C, or assembler,
And I cannot sit still and see Penguin's abused.
(Chorus)
My claim is "First Poster", I don't have a purpose,
Never mind that there's three of us all in a row,
I refresh my browser every 2 seconds,
Just so I get the chance to let you all know.
(Chorus)
Redhat's not Linux, its only a distro,
We'll scream it out loud, till we're blue in the face,
There's Debian, Mandrake, Slackware and Suse,
And many a new one to take their place...
(Chorus)
I am a 5krip7 k1dd14, I am real 1337 now,
I can't do too much hacking 'cause my system is slow
But don't you upset me, or I'll have to show you,
That I can read Bugtraq and then have a go.
(Chorus)
I hate RIAA, I love to use Napster,
It still is the best source for Metallica's songs,
I'd love to buy CDs but I'm a poor student,
So if you ask me, song trading's not wrong.
(Chorus)
Silicon's divine, Transmeta's my Mecca,
Can't wait for my startup to go IPO,
I'm counting the days until we go public,
Now, if we had a product 'twould be an easier go.
(Chorus)
"Meta-moderating" is just fine by me now,
I love to downgrade the things I oppose,
If I think your comments are stupid, say goodbye to your Karma,
I just hope that my actions are never exposed.
(Chorus)
I am an MS-man, my software's not open,
But that doesn't mean my mind's totally closed,
Even though I must reboot every few hours,
I still have the right to think Linux is hosed.
(Chorus)
If an item is high-tech, bizarre or expensive,
I'll let you know that I think in this case,
A Beowulf cluster is surely in order,
Never mind that the cost'd be in outer space.
(Chorus)
My name is Jon Katz, you all love to hate me,
My stories all take a similar line,
I hated my teenage years, so now I'll explain 'em
Cause to me the whole world is post-Columbine.
(Chorus)
My name is Rob Malda, my shorts are asbestos,
My Geek-hobby website has certainly grown,
We got bought by Andover, and now we're employees,
Our impartial viewpoint is probably blown...
(Chorus)
My name is Slashdot, comprising 5 servers,
My Alteon load-balancer's not just for show,
If we post a link to your website, beware now,
When the Slashordes all visit - down it will go.
(Chorus)
"The first time I got drunk, I got married. The second time I bought a chimpanzee, after that I stayed sober" Arian Seid
He has fallen for the biggest myth of today's software industry - the myth that the OS and the user-interface are two sides of the same coin.
They are not and they don't have to be. One size does not fit all. Most users do not want to administer their own systems, they just want the computer to work when they switch it on. Soccer-moms and business executives should not have to understand client-server architecture in order to use their PCs.
When he says "When you develop applications, keep the end user in mind." he is assuming that application development and user interface are so completely and utterly entertwined that the user interface must necessarily mirror the application development paradigm - and so he argues that changing the application development paradigm will simplify things for users. This is utter twaddle.
He then uses this argument for justification of his claim that a 'better way' to write Unix applications would be to use a component architecture built on top of CORBA.
I'm much more inclined to agree with esr, who says
First, get a user-interface design specialist, and a bunch of users, and figure out how they would like to use your application. Then do your coding in whatever suits you/your environment/the application best. Your users will thank you, and your code will be better written.
ai731
--
"I use the words you taught me. If they don't mean anything any more, teach me others. Or let me be silent"
UNIX means several different things. Traditionally, it's an OS kernel with a suite of common utilities. Very handy for some things, like software development and other processes where you can leverage lots of existing tools rather than having to put custom features into every program. It works well, for a certain type of usage.
These days, UNIX--well, Linux--is being viewed an alternative to offerings from Microsoft. To do that properly, what's needed is something else. It's more like Apple's approach to OS/X, in that you start with a kernel for basic services, then you pile a fixed layer of higher-level services on top of that. The whole package, kernel plus libraries plus GUI, is in effect it's own OS. Yes, "OS" isn't the correct term here, but you have to view the result as something that's different from what is normally called a Linux distribution. It's no longer a "choose your own WM, choose your own GUI" set of bricks , but something that has fused into a coherent, independent entity. It's not Linux; it's a system that happens to use the Linux kernel.
Gnome needs this kind of split. If Miguel or RedHat or whoever want to put together a system where everything is fixed and easy to use, then that's the way to go. Trying to spin all of UNIX and Linux in this direction is the wrong way to go. Many people, even myself, might prefer a Gnome-based system, but let's not make the mistake of trying to turn core UNIX into something it was never intended to be.
You know - I had a lot of problem with the point people mentioned: that you needed to have so many libraries loaded just to run a simple program such as gtop, for example; I agree with this. But now I see that is a completely different paradigm than what Miguel sees. That doesn't worry him because he wants those libraries on every distribution. He, probably like the KDE people, assumes that those will be standard on every linux setup. I'm not too sure how I feel about that though.
What do numerical codes have to do with this? (And what is a numerical code?) I don't see how you can argue that abstraction is good for performance. For example, if you based a file system on CORBA, it would always be slower than the same FS based direct system calls. Less abstraction usually leads to more performance. Not only are there fewer layers that software has to deal with, but making the interface close to the way hardware works leads to designs that take better advantage of hardware. A great example of this is OpenGL. In OpenGL, state changes are very clearly seperated from other commands. Because state changes are expensive for hardware to do, it is important that the API's reflect this. Another good example is DirectSound. By keeping you aware of exactly how the sounds are being played (streaming or in-buffer) and whether the hardware or software is doing the mixing, it forces designers to create programs that reflect the limitations of the hardware. You can't argue that fact that DirectX is faster than the normal Windows APIs simply because it is much less abstract from how the hardware works.
Second, you argue that abstraction faccilitates good design. That is entirely untrue. Good design is whatever runs fastest on a given piece of hardware. By abstracting too much, you lose the "feel" of the hardware. A car analogy is good here. Performance drivers hate cars that "abstract" away the feel of the road, because such cars simply cannot be driven at full potential.
Third, you say that the idea of "brute force, low level code" is dying. I would like to pick apart that concept. Less abstraction doesn't lead to brute-force code, and low level code is not necessarily (in fact it is rarely) brute-force. People who code at the lowest levels tend to realize that good design is the biggest part of performance, and design appropriatly. Good design is good design regardless of how much abstraction there is. Less abstraction simply makes a given design faster, and allows more innovation in the design used.
By your arguement, one could say that retained mode's in 3D (which are highly abstracted) would be faster than immediate modes. This is simply untrue. You try doing Quake in retained mode. It will never happen. Also, high abstraction usually leads to a lot of design decisions being made by the creator of the API. Another BAD idea. The people writing the code will 99% of the time have much better design ideas than the people writing the API. The best thing to do is make the APIs as low level as possible, so people can implement good designs. These designs will almost always be faster than the abstracted ones, and the lack of layers between the application and the hardware will just increase the performance of a good design.
You take abstraction from a UNIX point of view. Not the best people to consult when performance is concerned. The best people to consult are game developers. Games are probably the most highly tuned pieces of software running on PCs, because they have to do so much on so limited resources. Game programers almost always prefer less abstraction. When Windows came out (with more abstractions) they continued programming for DOS. They didn't actually get on Windows until DirectX came out, which allowed them close access to hardware. On Sega's Dreamcast, most developers ditched Windows CE (which wasn't slow, it used DirectX) in favor of the "to the metal" Sega OS. On PSX, game developers trick the hardware to do things it wasn't designed to do. The result are programs that really take 100% advantage of hardware, and by far outstrip what application designers can do. The evangalist behind DirectX said, "It is incredible that Internet Explorer can visibly refresh just drawing a page with a few pictures on it, when the guys at id are spraying whole worlds with tons of AI-driven monsters on the screen at 30fps." (Paraphrased, don't have the actual article in front of me.)
A deep unwavering belief is a sure sign you're missing something...
I prefaced my comments with the disclaimer that I am not an expert on the Microsoft programming world - in fact I appear to know just enought to get me into trouble on occasion.
On the interfaces issue, it appears I was simply misinformed.
As for the DLL issue, you are right that this *can* be worked around, but must be done at compile/link time and this is not normally done. If you're dealing with a vendor app and the vendor didn't take the care to ensure conflicts were avoided, you're out of luck. As for who at Microsoft said this, it was several top Microsoft SEs working to evaluate the feasibility of switching a *very* large company's Unix shop over to NT (I was a consultant on this evaluation.) All of the MS experts agreed that this was *not* possible, and was one of the principal reasons they didn't manage to squash Unix in that company then and there. Believe me, they wanted to say they could do it, but they couldn't - they all said it was possible in theory, but completely impractical and that they could not guarantee that the OS would "do the right thing" when running two different versions of the same app. I don't pretend to fully understand (or even care about) this issue, but I do report the facts as I observed them.
As for why you'd need to run two versions simultaneously - it's an absolute requirement in the real world where you want to validate the new code (especially for designing life-critical systems) alongside the proven code for a while to make sure the answers match. If you can't support both a test and production version, it's very hard to do that. (Also, it's common in complex engineering projects for this process to take months, so one group may cut over to a new version much earlier than another group working on something different, which may require more extensive testing.) This is very much a real world requirement.
Finally, the overhead of the JVM is a red herring: it wastes no more than the bloat of all the GNOME services that duplicate its functionality. And there is still a real benefit to being able to dynamically determine where code will run based on the capabilities of the client/end node device. Only Java or some other platform independent binary distribution method can really support this . I stil would like to know if Miguel thinks that's important - it's pretty clear that Microsoft does, given the capabilities of their new setup. You really have only two choices here: interpreted code, or p-code/bytecode. Until the software industry is completely dead, that means only the latter is a real option, due to IP concerns.
Oh, as a final aside, ad hominem attacks aren't called for, especially when someone goes out of their way to state that thier comment is not based on extensive or first-hand knowledge. Thanks for your response.
"The future's good and the present is nothing to sneeze at." - Roblimo's last
Huh? I didn't even USE the word BeOS in my post! BeOS is entirely irrelevant here. Not to mention the fact that it doesn't even HAVE an object model (yet)
Freedom for developers != Freedom for users to chose. Freedom for users requires that the developers adopt strong standards. All the most user friendly OSs have had strong central policies. By using these strong central policies, apps can interact with each other much better, and "cool" features are opened up. For example, by forcing all developers to use the native toolkit for GUI apps, all BeOS apps are automatically scriptible. By having a standard method for translating foreign file formats, all BeOS applications benifet when new translators are added. Central features are critical and rarely hinder to developer as long as they are well designed. Take Windows. There are 3 different toolkits, native Win32, MFC, and OWL. All use the same backend services, but are simply different programming models. They allow the developer to chose which model they like, yet still allow integratin of apps using the different models. MFC apps are just as integrated into the system as Win32 and OWL apps.
In fact, less developer freedom (to a point) == MORE user freedom. For example, I hate GNOME. It's not religious or anything, it just rubs me the wrong way. However, I'm forced to use it (for some of its apps) or else use KDE and live with two libraries loaded. I could use the KDE versions, but why? If the two used the same backend, I'd have the freedom to choose which desktop environment I wanted without being a slave to the developer who chose to use GTK instead of Qt! Why can't my GNOME and KDE apps communicate well? The best IDE on Linux is KDevelop, and the best graphics software is GIMP. However, they are two different models, so they don't cooperate with each other. Say I like Gnumeric better than KSpread. However, I prefer KWord to AbiWord. Will the two interoperate? No.
UNIX actually had the right idea origninally, but the DEs ruined it. When all apps used the native X protocols, then you could just switch widget sets, and apps would get updated. You could switch window managers, and all apps would still work with each other. What was required simply an extension to the native X protocols. Living with one system object model is surely a good trade for allow the user more flexibility. However, the DE guys thought they were OS designers, and now we have two OSs (incompatible ones) running on top of Linux.
You said MS implements most components in VB. They don't. You said that high level languages like Python should be the basis for a UNIX object model. It shouldn't. And yes, Python is slow. Take a look at some of the Phython based web-browsers.
The 90/10 rule coming from a UNIX guy? The same people who decided it would be a good idea to use a very feature rich, powerful, bloated, network transparent model like CORBA in a desktop object model? I mean you're using some seriously heavy duty stuff just to embed an HTML renderer into your filemanger!
A deep unwavering belief is a sure sign you're missing something...
Some claim that this it's a waste of time - now that is a borg mentality if I ever heard one. There is never any reason for a developer to ceace development on a project they like. If anything is a waste of time for *nix, it's whining about GNOME on Slashdot.
Because *nix is the ultimate learning system, there will always be people re-inventing the wheel to see how it works. Because *nix is free it will always be here because it can't be killed by commercial failure. However neither of these are reasons to not see further innovation.
After I've learned command line C programming, I don't want to have to switch to MS to learn component programming. Good luck Miguel, I hope to help the cause some day :)
First of all, to those of you who are criticizing Miguel by saying "Miguel is wrong because being Object Oriented isn't necessary", or "Miguel is wrong because XML isn't necessary", I hope you're keeping this in mind: Miguel's comments can be broken down into two parts("You know, there are two kinds of people in the world..."
1)We should be thinking about ways in which the UNIX philosophy is deficient, rather than continually reassuring ourselves that it's all okay. Look at it pragmatically: Who's got the biggest market penetration? Who's system is easier to learn to program in for the beginner, ignoring cost?
Okay, these are total flamebait questions, so please, please don't respond to these in particular. Use your imagination, and think of some ways in which Windows is better than UNIX, rather than touting all the advantages of your pet operating system. Otherwise, you're just brainwashing yourselves with your own marketing.
The question here isn't which way we should take things, it's how we should think about them. If you want to respond to this half of the question, address what the community should expect of UNIX, not how it should be done.
2)UNIX needs standards, reusability, etc. This is a set of recommendations to the community about where things should go specifically. If you agree to Miguel's motivations in the first part, then read on. His argument is based on looking at "the competition", and I can give you a concrete example.
He mentions IE, and how it's actually made up of a large collection of components rather than being a monolithic application. True. If I want IE's rendering capabilities in my application and I'm using something like Delphi(example because I actually had to do this once), Hell, I'll just draw myself a window and drop the browser component into it. You can argue about whether it's bloated code or not, but the end result is that I didn't have to reinvent the wheel to get something pretty momentous done. Further, I can now focus on doing something with this browser component that hasn't been done before.
For those of you who aren't interested in looking into it, Microsoft is working on something called dotNet. There's a lot of argument about what it all is, and whether it's useful, a product of the devil, etc. The thing that excited me about it is that components from one language can be used in another. And here's where I must admit that I didn't read the details about Bonobo. But my point is that Microsoft is going to have a fully operational Death Star of interoperability between languages pretty danged soon. Miguel rattles off a list of languages:
And this is exactly what isn't going to be the case with dotNet.
I know most of you have lost interest by now, and are happily moderating me down, flaming me, etc., but I have an appeal to those serious programmers and geeks amongst you who bore with me this far. It doesn't matter who came up with it, but isn't that just a bitchin' cool idea???
As you know, everyone who writes about their new features admits that you can already do the same thing in plain old C, but you also know how the rest of it goes.
By now, I've totally lost track of any other points I was going to make, if any. Please fill in the blanks with anything relavent you see:
This is a manual virus. Copy it to your sig and help me spread!