Slashdot Log In
Let's Make UNIX Not Suck
Posted by
Hemos
on Wed Aug 09, 2000 10:45 AM
from the stop-the-sucking! dept.
from the stop-the-sucking! dept.
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.
This discussion has been archived.
No new comments can be posted.
Let's Make Unix Not Suck
|
Log In/Create an Account
| Top
| 355 comments
(Spill at 50!) | Index Only
| Search Discussion
The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
Re:What's this got to do with UNIX? (Score:3)
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?
---
Re:Proposal: Linux Unified Model (Score:4)
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.
TM'd title (Score:3)
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. [beebware.com]
--
Re:UNIX's "problems" are really flexibility (Score:3)
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
UNIX trademark (Score:3)
Re:TM'd title (Score:4)
No, people keep forgetting that everyone is a beginner at some point.
Making a system good for beginners does not mean crippling it for advanced users. I think we should be past the point where complexity for complexity's sake should be attractive...
I'm an investigator. I followed a trail there.
Q.Tell me what the trail was.
Re:Great Article... (Score:4)
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.
Middleware (Score:4)
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 [amazon.com], 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.
library dependencies (Score:3)
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.
Re:First make GNOME not suck (Score:5)
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.
What's this got to do with UNIX? (Score:3)
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.
Re:Miguel is sadly mistaken (Score:3)
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
Re:Complexity isn't the only problem here (Score:3)
No one is forcing you to use GNOME or KDE or XFce, and some people genuinely like them.
Re:UNIX's "problems" are really flexibility (Score:3)
If you only write stuff for hackers how do you think Linux is going to succeed in the desktop market ? You can't just ignore your user's needs.
There has to be a standard way of doing things.
Re:TM'd title (Score:3)
I'm an investigator. I followed a trail there.
Q.Tell me what the trail was.
Re:Component systems and versioning (Score:3)
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...
UNIX was one of the first component-based systems (Score:3)
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.
Re:TM'd title (Score:3)
Basic typeing and arrow keys work as expected.
Then I use search a lot: C-s.
undo is shift-underscore.
replace is (OBVIOUSLY...) M-%
cut can be achieved by C-space at one and and C-w (wipe) at the other. Copy is the same but M-w. Paste (yank) is C-y. Any M-y's after C-y's paste things that used to be cut/copied, very neat as you never lose any text. C-k cuts the rest of the line.
And of course quit is C-x C-c
then there are some long commands I use a lot
M-x enters minibuffer fo command typing
line-number-mode shows line numbers
sgml-mode, cc-mode, c-mode, html-mode etc go into those appropriate modes so you can use:
font-lock-mode for syntax highlighting.
Obviously there's much more, but that's 99.9% of what I use. Can be learned in 15 mins, really. stick it to the side of your screen.
Also useful is the tutorial C-h t
First make GNOME not suck (Score:3)
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.
--
Posix (Score:3)
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.
Component systems and versioning (Score:4)
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
Policy and lack thereof (Score:3)
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!
CORBA isn't the answer (Score:3)
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 [kaffe.org]) and Java desktop apps (e.g., JFA [javalobby.org]), we'd soon have a good environment that would be much easier to extend with new components than a big C/CORBA system.
Components at install level (Score:3)
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
Speaking of things that suck... (Score:4)
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.
um, one foot before the other, you know? (Score:5)
You need something like DCOM implemented first before you can even think of implementing something like
Re:Component systems and versioning (Score:3)
Re:Great Article... (Score:4)
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
Scary! A Linux nerd bashing Unix! (Score:4)
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.
Great Article... (Score:5)
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 [xml.com] 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 [desaware.com] 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 [omg.org] but there hasn't been that much a big push towards components. Frankly I am eagerly awaiting MSFT's
FOOD FOR THOUGHT
Wanted: Killer Apps for World Domination (Score:3)
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.
Missing the point... (Score:3)
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.
Re:Component systems and versioning (Score:4)
For instance, the published interfaces in Microsoft Windows have not changed since they were published in the first version of OLE 2.0.
When Microsoft has expanded the funcionality they have created new interfaces or new methods, and they have retained the behaviour and previous interfaces.
The DLL problems in Microsoft applications are of a different nature, and can not be attributed to faults in their component system. It is a separate problem, still a problem for end users, but a separate one.
Miguel.
Meanwhile, the "beast" lumbers on (Score:5)
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: