Slashdot Mirror
A Diagnosis of Self-Healing Systems
gManZboy writes "We've been hearing about self-healing systems for a while, but (as is usual), so far it's more hype than reality. Well it looks like Mike Shapiro (from Sun's Solaris Kernel group) has been doing a little actual work in this direction. His prognosis is that there's a long way to go before we get fully self-healing systems. In this article he talks a little bit about what he's done, points out some alternative approaches to his own, as well as what's left to do."
Neither the applications nor the OS should depend on the other providing any failover or self-healing services; they should always be prepared to go it alone if necessary (as it might be the failover system). Services that crash should restart themselves, etc. This part is pretty well done by most enterprise-grade server software. It's the operating systems we're waiting to play catch-up.
And I'm still waiting to see any box that can replace its own power supply after someone flips the 115/230 switch. Once we get that, then we'll have truly self-healing systems. And all you BOFH's out there might be looking for a new career...
How am I supposed to fit a pithy, relevant quote into 120 characters?
So in the future, instead of out-sourcing our tech jobs to India, they'll simply in-source it to the computer it'self..
What'do I care, I'm out a job either way.
Go ahead and call me unreliable; reliable is just a synonym for predictable.
Which turned out not to be faulty... hmmm...
Some IBM mainframes are already at this level of self-diagnosis. Where I work, IBM repairmen show up with spare drives for the RAID array when they fail and the array phones IBM to report the fault. We don't know that a drive failed until the field service tech shows up!
This will never work on Windows. With all the registry crap it has, I don't see anything like this working. The registry is a nightmare to fix if anything goes wrong, it is ALWAYS easier to reinstall. In fact, I'm reinstalling XP tomorrow because of all the crap and bugs it has accumulated. I do this at least twice a year, and its a shame.
I use a little method I like to call the crontab coupled with shell scripts.
It looks like the T1000 won't be appearing any time soon: at least not until Skynet comes online.
"And I'm still waiting to see any box that can replace its own power supply after someone flips the 115/230 switch. Once we get that, then we'll have truly self-healing systems"
You may know of the JTAG boundary scan originally implemented as a form of system test to go beyond the limits of 'nail bed' hardware testing. Developing on this circa 1993 were several ideas that extended the hardware self-test model to include self-heal redundancy such that components that failed the test could switch out and switch in a secondary circuit. What I am reading here is encouraging, instead of having a separate 'test and monitoring' circuit for the 'main' device the device itself (and its software) becomes a coarse grain distributed system in which each node can both opearate as part of the devices global behaviour or monitor (test) and switch other nodes within the system. There is one other device that uses this highly distributed and non-specialised approach to fault tolerance, we call it the brain.
TiVo has had self-healing Linux systems out there for five years now. There are virtually no complaints of TiVo software failure (hard drives certainly go bad from time to time, but very rarely does the OS get itself into a state it can't fix), so the notion that self-healing systems are still years off is silly. They may not be extremely advanced yet, but they're certainly out there.
This seems to be the closest current system design that could possibly allow a self healing system when the hurd is setup as a cluster of servers.
if someone wrote a virus that exploited a vulnerability in KDE, would they call it "the Klap?"
Is a little bit different from self-healing, but they are in the same vein.
I believe Sun are working on systems that will attempt to spot failure trends, so they can proactively identify other customers who may run into similar problems and then either have the system fix itself or send someone out to deal with it.
The other mindset i've seen with RAID disks, is why bother replacing them. Disks are getting to the point that it's probably cheaper just to leave the dead one in there and power up a spare than to dispatch someone to install a new one.
INT 19h
After repeated viewing of those Thinkpad commercials where the techs tell the hysterical PHB to press the blue button on startup and thereby enable IBM to magically resurrect his hard drive, I summoned up the courage to try it. (The curly haired guy in those ads is also in one of my favorite commercials ("Please stay on the line...Playing with the queen of hearts..." so I figured I owed it to him.)
I gingerly pressed the button on my T40 and -- nothing happened. Maybe it's the firewall.
Yikes, now all the people who flipped out last month when I said I prefer my TiBook to the T40 are going to go even more nuts! "You ignorant asshole troll, don't you know the only thing that matters on a laptop is a magic blue button...!"
What I'm listening to now on Pandora...
It's very easy to make a system self-healing when you are running in a completely controlled evironment.
Indeed my TiVo very rarely crashes and always recovers, but the same is also true of every embedded system i've used - be it a cellphone, weather station or alarm system.
Now if i screw around modding my tivo then it's entirely possible to crash it and it doesn't recover very well from that...
if self healing = ms office keeps putting another icon in my start menu whenever I start word, then I don't want self healing.
How many times do I have to move their icons to a submenu before they realise I don't want my root menu cluttered up with crap?
While a self healing system sounds nifty, todays systems aren't even good enough to be healed manually.
Uninstalling applications is often not handled by the OS and has to be done by application itself, resulting in incomplete installations, config files and registiry entries that havn't been properly cleaned up and whatever.
Files arn't versioned, so every change done to a file will simply erase the former content forever, not so good if the former content might have been important.
Undelete? Nope, we don't have that either, we have this hack of a Trashcan, but that won't help you much if some programm deleted the file.
Check of integritiy of an installed piece of software isn't possible either, sure there are third-party solutions, but again that should be something that the OS provides at default
Well, there are millons of more issues why todays system suck and why it is often easier to simply reinstall from scratch then to try to actually fix the mess, and yep, that is true for both Linux, Windows and MacOS, sure for some more then for the others, but thats it.
If they break they can be fixed or replaced. I want selfhealing (prefereably wolverine type) for me.
Do not try to read the dupe, thats impossible. Instead, only try to realize the truth
What truth?
There is no dupe
I don't know why windows doesn't just have a reset button for all the settings to return it to it's original condition. It's a bitch to reinstall it twice a year, you know.
I recently bought a refurbished amd64 HP computer on the cheap.
I was surprised and almost impressed by the "self-healing" nature of the pre-installation.
When booting the computer, you can press F10 to tell the BIOS to get the customized OS files on the hidden partition of the hard drive and overwrite the existing files on C:. This can also be done right from Windows by clicking an icon. Note that it could well be a chemotherapy type of self-healing (with the registry especially)!
I promptly installed Gentoo though, so I wonder if I can make pressing F10 do emerge sync; emerge world automatically!
HP computers are probably a good purchase for regular Windows home users.
Just out of curosity, can anyone define what the precise difference is between "Fault Tolerance" and "Self Healing"?
Explain to me how any of the failure responses I see discussed in the article or in these discussions qualifies as "Healing"? Almost all fault tolerant systems isolate failing components or programs from the rest of the system (killing rouge processes counts as isolation). Quarantine is not an attempt to heal, it is an attempt to tolerate. Are there actually any non-quarantine "self healing" systems out there today?
Well this seems like where computing services are heading as IBM is doing extensive research on Self-Configuring, Self-Healing, Self-Optimizing, and Self-Protecting computing systems called 'Autonomic'
Check out: Autonomic Computing
The most successful example is Tandem. For decades, systems that have to keep running have run on Tandem's operating system. For an overview of how they did it, see the 1985 paper Why Computers Stop and What Can Be Done About It.
The basic concepts are:
Every time you use an ATM or trade a stock, somewhere a Tandem cluster was involved.
Tandem's problem was that they had rather expensive proprietary hardware. You also needed extra hardware to allow for fail-operational systems. But it all really does work. HP still sells Tandem, but since Carly, it's being neglected, like most other high technology at HP.
Click here to ruin the joke.
How am I supposed to fit a pithy, relevant quote into 120 characters?
the health of the rest of the system is monitored, and what are you gonna do if it comes to wrong conclusions?
In Soviet Russia, self-healing systems diagnose themselves.
Self-healing would seem to be a critical step toward a self-aware artificial intelligence. Self-healing requires an ability for introspection that is sufficient to identify and correct corrupted internal states. Code that is able to introspect its own behavior and internal structure could lead it to interesting outcomes if tied to a learning algorithm (even a simple hill-climbing algorithm).
It is then a small step to go from simple feedback self-healing mechanisms to feed-forward control mechanisms. Feed forward system would learn (or be told) how certain precurse states and actions lead to fault or non-faulty operating states. A system that learns that particular states and invocations lead to crashes would "learn" to avoid those invocations or correct those states proactively.
Such a system might even begin to show emotional states in the sense that an emotional state is a summary of the condition of the system that guides future action. "Unhappy" systems would spend extra CPU cycles on introspection to try to understand and correct accumulating faulty conditions. Such systems might even get "angry" at other machines such as machines that send spam or worm packets and refuse to communicate with them.
Two wrongs don't make a right, but three lefts do.
Did anyone else read this as 'A Diagnosis of Self-Heating Systems?'
I think my laptop could cook an egg...
From TFA: One approach is simply to make an individual system the unit of recovery; if anything fails, either restart the whole thing or fail-over to another system providing redundancy. Unfortunately, with the increasing physical resources available to each system, this approach is inherently wasteful: Why restart a whole system if you can disable a particular processor core, restart an individual application, or refrain from using a bit of your spacious memory or a particular I/O path until a repair is truly needed?
Because using stuff like stonith or heartbeat works for many more types of failures. Bad network cable? Yup. Power supply? yup. Server Catch on Fire? Yup.
I'm not saying it wouldn't be nice to have the OS route around bad memory blocks or bad processor cores due to some fancy-pants algorithm (without having to rewrite my app). But you're still going to need a redundant server for when somebody trips over the power cord.
I have it so that if one of our firewalls detects an attempt to access gator.com it enrols the machine into an active directory system group which the SMS server queries to automatically de-spyware it with SpyBot.
I'd call that a self healing system. I'm a network admin though so my perception of these things tends to be on a larger scale.
This is really something that, IMHO, calls for more interaction between the best of the futurists, science-fiction writers, and coders, and other complexity thinkers.
In order for any system to have an understanding of and proper diagnosis of its own operation, it needs to be able to conceptualize its relationship to other systems around it. Am I important? What functions do I provide? What level of error is proper to report to my administrator? Do I have a history of hardware problems? Has chip 2341 on motherboard 12 been acting up intermittently? If so, is it getting worse or better? How have I been doing over the last few days? Is there a new virus going around that is similar to something I've had before?
What good is a self-diagnosing system without a memory of its prior actions?
All of these questions imply some sort of context that will require the system to use symbols to represent "things" in the "world" around it. Clearly, the largest (though perhaps not qualitatively different) symbol will be a "self" symbol.
From there, all you have to do is follow Hofstadter's path and you'll arrive at a system with emergent self-awareness or consciousness.
The end result of this will be something a) very complex and b) designed/grown by itself. You'll have either the computer from the U.S.S. Enterprise or H.A.L.
Side question: What is CYC doing these days?
Hire a Linux system administrator, systems engineer,
For swarmstreaming, we use the Tree Hash EXchange format (THEX) to provide cryptographic integrity verification down to a single 1KB resolution so we can automatically repair the corruption.
How about just systems that fail *verbosely*, so admins can quickly diagnose them? Once the patient can complain properly, we can get to work replacing the admin doctors with "self-healing" metasystems that use those diagnostics. It will be a lot easier just mimicking the best admins' best practices by automating them, than all this screwing around trying to compile marketsprach like "self-healing" without understanding how it even works in nature.
--
make install -not war
Extortion.
Mostly, that's because Windows is a piece of shit.
-- "Makes Little Debbie look like a pile of puke!" - Moe Szyslak
The former could be considered self-repair, but it is limited as you don't have to have much in the way of an error to totally swamp most error-correction codes.
The second form isn't really self-repair as much as it is damage control. This is just as important as self-repair, as you can't do much repair work if your software can't run.
On the whole, "normal" systems don't need any kind of self-repair, beyond the basic error-correction codes. Instead, you are likely better off to have a "hot fail-over" system - two systems running in parallel with the same data, only one of them is kept "silent". Both take input from the same source(s), and so should have identical states at all times, with no synchronization required.
If the "active" one fails, just "unsilence" the other one and restore the first one's state. If the "silent" one fails, all you do is copy the state over.
However, computers are deterministic. Two identical machines, performing identical operations, will always produce identical results. Therefore, in order to have a meaningful hot fail-over of the kind described, the two can't be identical. They have to be different enough to not fail under identical conditions, but be similar enough that you can trivially switch the output from one to the other without anybody noticing.
eg: The use of a Linux box on an AMD running Roxen, and an OpenBSD box on an Intel running Apache, would be pretty much guaranteed not to have common points of failure. If you used a keepalive daemon for each box to monitor the other's health, you could easily ensure that only one box was "talking" at a time, even if both were receiving.
The added complexity is minimal, which is always good for reliability, and the result is as good or better than any existing software self-repair method out there.
Now, you can't always use such solutions. Anything designed to work in space, these days, uses a combination of the above techniques to extend the lifetime of the computer. By dynamically monitoring the health of the components, re-routing data flow as needed, and repairing data/code stored in transistors that have become damaged, you ensure the system will keep functioning.
Transistors get destroyed by radiation quite easily. If you didn't have some kind of self-repair/damage-control, you'd either be using chips with transistors which may or may not work, or you'd have to scrub the entire chip after a single transistor went.
It's a small world and it smells funny; I'd buy another if it wasn't for the money; Take back what I paid (SoM)
I thought I saw an article about that earlier, but on second glance it turned out to about self-heating coffee. Yawn.
Now, as for self-heating systems...
"How to Do Nothing," kids activities, back in print!
Sorry about that, I just said the first thing that came to my mind.
-- "Makes Little Debbie look like a pile of puke!" - Moe Szyslak
First of all, it has the phrase that pays: "graceful degradation "
Next, it talks about verbose and useful errors, so that a techy can make intelligent decisions about terminating a process, restarting it, altering a file, or some other fix. Presumably, once a tech marks a problem "successfully fixed" by a certain set of actions enough times, the system wiull try those series of actions before throwing an error message.
What will be nice is when the system recognizes what it is it's doing, so it'll have a "what" area and a "how" area in its makeup so it knows what's involved to accomplish the task. Then, if the "How" gets damaged, it can refer to the "what" to reconfigure available resources to meet the desired outcome. And, if the "What" gets damaged, it can be rebuilt by analyzing the "What" part. THAT will be realio coolio.
"Wow. Now THAT'S a lot of angry Indians." - Lt. Col. George Armstrong Custer
Files arn't versioned, so every change done to a file will simply erase the former content forever, not so good if the former content might have been important.
VMS had this years ago.
Windows XP also has the 'restore' utility (which I've had to use a couple of times when one of their updates hosed the system). This is one feature though that is both useful and worked when I neeeded it to.
Files arn't versioned
Undelete?
Check of integritiy of an installed piece of software
During the desktop's formative years, the raw drive space needed to actually implement these kinds of things just wasn't available. This is why things like file versioning (popular on large systems like VMS, where the universities/companies running it had the money for the storage requirements) and permanent storage of "unwanted" files just didn't appear.
The third problem is a bit tougher without some extra metadata and hardcore discussions on exactly what should be monitored/done/etc (personally, I don't think this is a kernel-level operation). Something must be stored somewhere so that the system can identify a modified binary. At some time (before change, in which case the operation is stopped? After change? Monthly?) someone (root? file owner? script kiddie currently logged in as root?) has to be notified (syslog? message to terminal? email?) that something (virus? script kiddie? make install? dpkg? rpm?) has altered the (executable? configuration? library? manpage?). As you can see, its one thing to say "oh yeah the OS should do this" and another entirely to define what this is.
The second problem is tough as well, but there are patches to libc's unlink() function (either as a patch or as an LD_PRELOAD library to override libc's function) that move the files to a pre-defined trashcan, and that every dynamically linked application will use.
The first problem is mostly just a lack of demand. Nobody cares, so nobody made a filesystem that can do it. Both ext*fs and reiserfs are extendable (with optional options. Reiserfs moreso than ext), so if you care, do it yourself, but again there's questions you'll have to be prepared to answer (and since you insist on doing this at the kernel level, you have to have THE answer): If a program writes 1MB to a file 1 byte at a time, is that one million revisions? If you're writing a document and you hit save after every paragraph, is that a revision? How are you going to tell this apart at the kernel level?
If I have been able to see further than others, it is because I bought a pair of binoculars.
Only when you limit your OS choices to turds. See below.
Uninstalling applications is often not handled by the OS and has to be done by application itself, resulting in incomplete installations, config files and registiry entries that havn't been properly cleaned up and whatever.
Why in hell does the OS have to be involved in an application install?!?!?!
Oh, right. Because there this single-point-of-failure, dumbest-idea-ever-to-fly-out-of-a-monkey's-butt registry where all applications need to put there configuration data.
Why!?!?!?
What "problem" did this solve?
Files arn't versioned, so every change done to a file will simply erase the former content forever, not so good if the former content might have been important.
VMS. Old news. Also lots of disk space needed
Undelete? Nope, we don't have that either, we have this hack of a Trashcan, but that won't help you much if some programm deleted the file.
And why not a Trashcan inside the trashcan. Even better, a popup that will ask if I'm really sure I want to stop using this wonderful Fisher-Price GUI.
Check of integritiy of an installed piece of software isn't possible either, sure there are third-party solutions, but again that should be something that the OS provides at default
Just how in hell is the OS supposed to determine that a third-party application's file hasn't had it's "integrity" destroyed? How on God's good Earth would the OS even define integrity?
Well, there are millons of more issues why todays system suck and why it is often easier to simply reinstall from scratch then to try to actually fix the mess, and yep, that is true for both Linux, Windows and MacOS, sure for some more then for the others, but thats it.
Yeah, but it's really only Windows that sucks. Real apps on real computers don't need a dumbass "registry" so the "OS" can tell them where to find their files and data (but only on that one computer....), they smart enough to do it themselves (it's actually really easy, because an app always knows where it's located, and can use that information to find other data in a completely relocatable manner that doesn't depend on anything other than itself. Cool idea: limit your app's impact on the box it's installed on.....)
this sounds good un till somebody meake a worn that uses an exploit that (for the sake of argument say there is one) was/(will be might be) found. The worm tricks the server in to thinking it is severly messed up so it orders a boat load of parts or shuts down or both. the tech shows up and its just a worm. now you have these parts and have to pay up. also the server shut down, now its lost time. did i mention its a worm so it spreads. thats just worst case, but i could be great unless you fix broken servers for a living.
That makes it sound like people want computers to be able to mechanically fix themselves when they break.
Wouldn't a "self-healing" system just be good at a) reporting what hardware is actually broken on the machine b) automating well defined responses to well defined programs and c) building parallel, fault tolerant hardware at all levels of the system?
As far as I know, even the best AI research hasn't come up with software that can diagnose and fix unknown, first time, bizarre problems. Ultimately, it all seems to be about providing better error reporting and automation of traditional technology, not some magical PC that can fix itself and reprogram itself with no human intervention. Which is great, don't get me wrong, but why the term "self-healing?" Does someone know the rational for that?
"I object to doing things that computers can do." -- Olin Shivers, lispers.org
Solaris was mentioned!! Solaris was mentioned!!
Time to get all slashdotty and proclaim the
end of the company. Ooooh Solaris was mentioned!
The space shuttle, as old as it is, has an absolutely incredible computer system that is self healing.
The Shuttle has many thousands of sensors and backup sensors. Each sensor feeds into one of many computer systems. These computer systems talk to each other as more of a committee rather than just passing data amongst themselves. If a computer discovers a fault, another computer will see that fault as well, it will combine data gathered from other computer systems throughout the suttle and each computer system will literally cast a vote on what the best solution should be for the particular fault discovered.
If one computer system suffers a partial or complete failure, the remaining systems will work around the failed system.
This computer system has managed to keep our astronauts alive for every mission, except those two that suffered from a catastrophic mechanical failure. The second of which (Columbia) the computers kept the craft flying until it broke apart completely.
I say not bad for a system designed over 20 years ago!
Good security is based upon reality and common sense. Common sense is a function of having common knowledge.
### Something must be stored somewhere so that the system can identify a modified binary.
Well, the system ultimativly knows when something changes, since it is the one who changes it. You are right that one needs some metadata, those however in most cases already comes with the packages (deb/rpm) one installs, there just isn't a standard way to automatically check these changes. However this problem can be solved completly in userspace with a cronjob, would just be nice to have a standard way to do it.
### During the desktop's formative years, the raw drive space needed to actually implement these kinds of things just wasn't available.
While that might be true, that was at least 10 years ago. Since we count in GigaByte we have more space then needed and in most cases more then we ever can legally fill. And even if the harddisk runs full from time to time it isn't much of a problem, a versioning filesystem should simply scale back and automatically discard older versions, but as long as there is still free space on the harddisk I see little reason to not use it for something usefull.
### The second problem is tough as well, but there are patches to libc's unlink() function
The throuble with that patch is the same as with the trashcans, they only get what you actually delete, not what you overwrite, fill with 0 bytes or destroy by other operations. I don't have any hard numbers, but in my experience the deleted files don't happen that often compared to the overwritten ones.
### If a program writes 1MB to a file 1 byte at a time, is that one million revisions?
If it does 'fopen(.., "a"); write() close();' then yep, one million revisions. A new version should be created once the filehandled is opened for writing, something that is hard to catch from userspace. Storing of the new version could then happen in some Copy-on-write style manner, thats why the kernel need to play at least some role.
### How are you going to tell this apart at the kernel level?
Since you only need to listen to open() and close(), how many bytes are written inbetween that is not much of an issue. And about the "nobody cares" part, well, the programmer might not, the users who yet again have lost data however might a lot, but as with all things that are only usefull if things go wrong it of course isn't much good for marketing.
"and another entirely to define what this is."
;)
That would be "Survive, damn you! Survive!"
There is this internal conflict we must have, where on the one hand we want our technology to have a survival instinct; so that it is motivated to look after itself while we are not.
A bit like a human baby figuring out that sometimes mummy is not looking this way and it has to get out of the way of the reversing SUV by its self.
On the other hand, the prospect of computers that have a survival instinct is (or bloody should be) a bit scary.
The real problem we have is very much like facing the emancipation of slaves; on the one hand you'd rather not have the expense of maintaining slaves and couldn't they just take care of themselves. On the other hand you *know* how you treated them and worry that they will extract revenge.
Or read Stanislaw Lem 'Non Serviam'. A true classic of AI literature.
Then theres the low level side where a filesystem is filling up and what do you start deleting first? If the *computer* could choose, for its own health and wellbeing, where would *it* start?
Ooops there goes the pr0n...
In the free world the media isn't government run; the government is media run.
Well, I've seen some nice systems. When I see some nice fully systems and some quality fully self- systems, I'll be ready for the advent of fully self-healing systems. I expect we will get there one step at a time.
But I read in 1958 that we would have self healing systems "within a decade" - surely we must have had them for over 30 years!
Sent from my ASR33 using ASCII
Having thought this thing through, I guess it's all about different levels of (inter-)dependability. One program relying on the other, etc..
I guess if you work this out upto a low enough level, this includes the hardware, you can actually make the system heal itself.
You could probably start at the root of the whole system: power, and build your way up from there in a sort of tree-version. However, other environmental issues for you system could exist that make a power failure seem like christmas.
It could be fire, it could be the airconditioning that stands next to (one of your) machines which leaks water. In short, self-healing systems are great - but total self-healing will not be achieved unless you can, somehow, get all environment concerns charted and handled. Even then you probably have to be honest and admit that the system can and will fail in certain (very) far-out conditions. In that case, the system will closely approach a truly intelligent system. As this does not yet exist, why should total self-healing systems ?
Slashdot: stuff for news, nerds that matter, matter for news, stuff that nerd
The currentzSeries machines come with 16 cpus and L2 & L1 packaged together on a board.
But only 12 cpus are used.
Each "cpu" is actually two cpus and a comparitor. When the cpus come up with a different answer the cpu is shutdown and procesing is taken over by one of the four free cpus on the board.
You will never know it happened until you run one of the mainrneance utilities.
In the way of IBM this technoligy will probaly appear on top end pSeries (AIX/Linux) and iSeries boxes in a couple of years.
Old COBOL programmers never die. They just code in C.
To understand the problem with systems that fail verbosely, investigate the 3-Mile Island disaster. When the alarm board lights up like a christmas tree, it's hard to figure out what the root cause is amidst the chaos.
BTW, the whole TMI nuke plant had exactly 2 phone lines to the outside world. Between the governor calling to find out what happened, the media clammoring for answers, and other miscellaneous activity, the guy who designed the plant couldn't get through to tell them how to keep it from blowing up! Would you want to be on the wrong side of a Treo 600 while on vacation after the server coughs up a 20MB log file?
aQazaQa
I don't know if we can predict the socio-economic forces that will (or will not) obsolete repairmen. I recently discovered that, much to my surprise, automobile mechanics in Thailand (a developing country by all accounts) often resort to whole engine replacement rather than any of the component-level repairs or rebuilds we are familiar with in the US. On top of that, maintenance in general is poorly done. My expectation was that much more effort would be made to keep machines going and repair them to avoid replacement, as is done in the poorer urban and rural areas of the US.
Hm, I guess that explains why my porn directory suddenly got a new hot_computer_on_computer_action/ subdirectory.
This'll probably get moded flaimbait but it is true. If your telling me you unix guys have to start services with a number of scripts, that these services have no dependencies, that you cannot restart them automatically (or run a resume script, or whatever) ...
Then I am glad my data center spends its $$$ on Microsoft Windows. We've been doing this since NT!
Comment removed based on user account deletion
Uninstalling applications is often not handled by the OS and has to be done by application itself, resulting in incomplete installations, config files and registiry entries that havn't been properly cleaned up and whatever. ...
gentoo has this
Files arn't versioned, so every change done to a file will simply erase the former content forever, not so good if the former content might have been important.
this too
Check of integritiy of an installed piece of software isn't possible either, sure there are third-party solutions, but again that should be something that the OS provides at default
Do you mean the md5sum of an installation package/archive before you install it? Or you somehow want to test the program after install?
IBM are basing their future application self-healing abilities on what they call a whole branch of research they have been investing in for years called Autonomic Computing
It's not all pie in the sky either - they've already released preliminary Autonomic Computing Toolkits as part of their Emerging Technologies Toolkit. Start by looking at the Logging and Trace components, and then maybe look at the Solution Install pieces - they underpin the whole framework.
It will take a generation, or two (10-15 years) before complete IBM systems (hardware, OS, middleware, databases, applications etc) are close to autonomic - every aspect have to buy in and adapt the Autonomic Compouting framework. Given their extensive software catalog, IBM themselves will probably take 10-15 years to complete that task but they face a significantly larger hurdle convincing major 3rd party vendors (e.g. Oracle, SAP etc) to wire their products into the new autonimic services.
My guess is, in a mixed vendor (hardware/OS/application) environment, you won't see this for many, many years to come. Pure IBM shops may be able to rely on Autonomic systems within 5-10 years if they are using the latest of everything.
### Do you mean the md5sum of an installation package/archive before you install it? Or you somehow want to test the program after install?
Basically both, if one wants a self healing system, the system needs first a way to find out that something is wrong in the first place. If there isn't a way to detected that some files got broken, then a self-healing system can do nothing. Beside from that it might of course also help to detect some cracker attacks or corrupt harddisks easier.
### if one wants a self healing system, the system needs first a way to find out that something is wrong in the first place. If there isn't a way to detected that some files got broken, then a self-healing system can do nothing. Beside from that it might of course also help to detect some cracker attacks or corrupt harddisks easier.
... and we are *cough* months away from that :)
The OS can't possibly know an application is healty or not (There are other applications that can check this: rootkit hunter is one of them). The reason being you can't define a healthy application: is allowing myhost.example.com to connect from the internet on port 22 using tcp a sign of "disease" or that the system is healthy since it allows only one host to connect? What if the host is a malicious user who denied every other user the right to access the system? What you want is more in the field of AI