Slashdot Mirror
Leo Laporte On UNIX As the Future
TractorJector writes "In a well-written interview with Mad Penguin, techmeister Leo Laporte (formerly of G4/TechTV fame) discusses his vision of the future of proprietary and open platforms: 'I think there's a lot of hope for Linux, although I don't think that Linux is the answer. I think that UNIX is the answer, in some form or fashion. It might be BSD, it might be Linux, it might be some third thing. But UNIX is such a well understood and smart to handle the issues that an operating system has to handle that it ultimately will prevail.'"
Unix is very flexible, and it certainly outlive Windows. However, its development will only take it through the near future. In the long term, the very idea of unmanaged code will disappear. As will the traditional concept of the Desktop.
:-)
My predictions are:
1. Desktops will be replaced with Browser simulations of a Desktop that can work anytime, anywhere.
2. The traditional PC will then be replaced by a home server through which all activity will happen.
3. Components for Music, Television, Desktop, and Video Game consoles will (in many cases wirelessly) interact with this server.
4. The server itself will run an OS based on a managed code environment, making remote attacks difficult if not impossible. (Many Unix concepts would probably be reused in this system, but it won't *be* Unix.)
That's my thoughts anyway. Sometime in the near future, I'll get them blogged down in detail.
Javascript + Nintendo DSi = DSiCade
MacOS X and operating systems that can marry the power of a good command line with the ease of an excellent GUI shall inherit the earth. I'm interested in how the new windows command line stacks up.
PC as a thin client browser?
I don't know about you, but that doesn't satisfy me and I think there will always be room for people who want a traditional desktop.
As a gamer and just fan of controlling the computer in front of me completely without all this abstractness, I don't think that everyone is going to bite on this kind of stuff.
I'm sure it has its place, but for everyone?
Unix is fine. It works.
But....it's 40 years old! Wouldn't we all like to see a completely MODERN operating system? I know I would. Keep all the good stuff from Unix, update it, and throw out the bad stuff.
Of course, in the end, we'll still be stuck with Windows and MacOS and Linux because they're the only 3 that have developer support.
This is a distinction I do NOT understand.
The underlying code open or not is just the implmentation.
And some implentatoins have different switches on the commands.
Like BSD,Irix,SYS V5, didn't
Sticking to a design (what UNIX standard, POSIX?) is the bigger issue in my opinion.
But the end result is the same.
"Everything is a file" ( read,write,block or char)
Or is there really a major difference ?
This is my opinion based on what little I know and understand of the rumors and lies Thanks, Randal
This just proves that time IS, in fact, cyclical! Consider trends with fashion? The 70s came back, the 80s came back, the 90s are coming back... Remakes of movies and music, too... The same is true with computers! Remember how we used to have these big centralized machines that occupied cabinets or frames in rooms? And people used these things called 'Terminals' to interact with the 'MainFrame'... Now we call it a Server, and the Terminals "Thin Clients", but its the same thing! If this was such a good idea AND the future, why did we abandon it when the PC came out?
Laporte says:
"It's funny, because in the early days of UNIX, the philosophy of a program was, "do one thing well, and then pass the result along and interface with others." We've gotten to the complete opposite, which is do everything kind of okay, and interface with nobody. That was clearly a wrong turn. It's a response to market forces, not computer science forces."
In the case where there is just the CLI and a list of programs spawned from a single input line, having a whole collection of tools that work well together is a must. But when you move to a graphical interface, so huge is the change in interface mechanics that the idea of the end-user setting up a chain of programs to run from one mouse click should be alien.
The UNIX mentality of small, modular programs doing one thing well can still be maintained while a graphical environment is running, but his criticism that "do everything kind of okay, interface with nobody" can't be taken as criticism: it's just the way that GUI stuff appears to the user*. The computer system may be organised so that the GUI program you're using shares a lot of libraries and calls a lot of helper programs to do its work, but the user should only see the graphical interface, making his point moot.
*: Maybe he means something else: that an environment where one program does only one thing, from ground to GUI, does not help people to tinker, develop and hack new features into the software.
Unix in the backend, handling all computery stuff(services, servers, etc).
A nice, pretty GUI up front(Macintosh, Windows, whatever you like), that grandma can use.
IIRC OSX does this to an extent already.
Thus, the reverse mullet approach. Party in the front, business in the back.
More clueless crap, for Unix to really be the future, it needs to get rid of its legacy bagage and truely become "well understood". Frankly a lot of people think they understand unix because they are stuck in a single process/text based enviroment mindset. In reality the "extensions" made to unix to support current programming models are full of holes.
When RAS, threads, async io, multiple processors, and may other things that really are the "future" (or rather the current state of the art) are well understood by the unix community they will understand what needs to be changed in the model from the 1970's the people claim is Unix. When that happens unix will be the future, but it won't be "Unix" as you know it.
Now for some more concrete examples. Lets start with a simple one. What does the system call "close()" do? Thats right, did you know it can fail? Whats the solution? Try again. Now think about what happens in a multithreaded enviroment with open() happening in other threads. I can't find a link to Linus's comments on this but they are ammusing. The bottom line is that in a threaded POSIX enviroment you have to write code that looks like (in psudo code to remove the specifics):
app_open(filename,...)
{
lockmutex(globalopenlock)
rc=open(filename,...)
unlockmutex(globalopenlock)
return rc
}
app_close(filehandle)
{
lockmutex(globalopenlock)
while (close(filehandle)!=EBADF);
unlockmutex(globalopenlock)
}
If such a simple unix concept as open/close is screwed up by threads, just imagine what happens when you write code to trap percise floating point exceptions, deal with async filesystem IO over an unreliable network, the list goes on. Basically unix is good for certain kinds of applications and absolutly blows chunks for other kinds. Everyone doing a lot of these things has tied themselves to a particular Unix implementation and uses system specific knowledge to solve the problem.