Back in a good old MoonEdit days, when everything was brighter and simpler (I call it double sarcasm, those days are not over yet!), together with my friends I started a MoonEdit debate "Immortal software - a software that our grand-grand children will be able to not only run but to take advantage of its functionality". VM-based languages (Java, C#) and WORA (write-once run-anywhere) seem to be good enough for that purpose, but is it ?
I'm not going to talk about good old DOS days, DOS4GW, hardware registers and other weird things that was an obvious trap (but how many of your really thought of it when devoloping this way?). Maybe just one more sentence: all my old DOS software is practically dead. It's not that you cannot execute it at all (i.e. there is DosBox, although my software has still some minor issues in it), it's also the fact that the software is completely out of date. First of all it is not well integrated with a system, i.e. artificial memory limits (16bit addressing or just stupid constants in a code), no support for long file names or even no shared clipboard. Imagine using text editor for your daily notes that is still very good piece of software, but only runs in a DosBox. It would be utterly annoying. It's dead, end of story, with a little exception of games. Only a little, since user demands on realistic graphics grows almost exponentially here.
Now think about all this software made entirely for Windows 3.1, Windows 95 and even XP. It's already outdated in a Vista or Windows 7 - compatiblity issues (even with new compatibility mode, some applications simply crash at the begning). It's even worse that with DOS - at least DOS was "simple" enough to emulate (almost perfectly). Software developers are doomed again.
Just don't tell me open source is a solution - it is not. Being able to compile your code for a long time is not a trivial task. Compilers change, environment change, third party library versions change or are not supported anymore. It's also a trap!
Now we are finally approaching VMs. In theory it should be perfect: low-level instruction set is fixed (forever?), but there is still a little problem with environment and system libraries. User demands grow and we have frequent Java SDK and .NET framework updates. Nobody really guarentee there will be no compatibility issues for VM binaries. Engineers behind those technologies mostly concentrate on portability issues, not the immortality. It's even against economy! The biggest problem is with third party dynamic libraries. If you don't use "fancy" stuff in your code, you should be safe, but can you sleep well ?
I don't even want to go into things like JavaScript - it has compatibility issues even over various web browser.
As a conclusion I ask to myself a real, serious question - will my grand-grand children be able to execute and take advantage of any of my software or we, developers, are all doomed and be utterly forgotten?
I propose a new buzz-word, the direction for new immortal software movement: WOLF = wirte-once, live forever.
Subscribe to:
Post Comments (Atom)
6 comments:
Your grandchildren will not use your software. And not because of changing instruction sets, but because changing software landscape and user habits will make your software inconvenient to use. If you want your software to survive, you have to continuously adjust it to its changing environment.
"It takes all the running you can do, to keep in the same place", said the Red Queen. This is an evolutionary arms race and if you don't co-evolve with changing environment you go extinct.
You are mostly right, Michal. What you have said does not imply it's impossible to survive, but you simply suggested a potential solution!
We could write immortal software that has potential to evolve (on its own? is it possible?). You are already running that kind of "software" in your cells.
Wow, interesting question.
hmm... if you think about the software that has been written a long time ago.
Is TeX such software? I'm not sure how heavily it has been modified.
Plus, hardware changes.. and even VMs cannot guard there (i'll assume that between now and +50 years, e.g. parallelisation will be rather normal, and VMs instruction sets will have adapted.
Another question is, if software will be written by hand at all like today, or if there will be another indirect way of specifying behaviour.
Another idea: I can imagine that input methods will have changed a lot by then. (thinking about change of input styles in mobile phones.)
So the immortal software would have to interact with other software, not directly the user. (which leads to the library compatibility problems again)
so in conclusion i agree with you that the survival of static, unmodified code is rather unlikely.
Another idea: Is there a measure of how fast code changes?
(sorry for probably not checking back, i'm reading my blogs in a rather random order ;))
If I were a manager from M$, I'd say that it's really cool that software isn't immortal, we can rewrite it and sell it again ;).
Frankly speaking, I think that you're mostly focused on CODE, not SOFTWARE. All what you wrote above is true, you're children won't run your software and it's absolutely unavoidable (just because we can't be sure that something like keyboard or mouse will exist in next fifty years).
However, I believe that some computer system projects are immortal. For instance, Emacs exists since 1976 and I don't think that somebody's going to close it. IT Projects are something more than code. That projects supply some philosophy, way of thinking (in fact sometimes very wrong one), finally that create a society of people who are developing it (like Emacs does). That kind of immortality is quite often in Open Source (Tom, you haven't appreciated this movement yet, have you? :)).
So maybe, if you want to make your software immortal, just try to develop it if it's possible...
713A very good and old discussion. Good to see at least people are thinking in this direction as a possibility.
It's True we are not much away from immortal systems. (Imagine Few years back has anybody thought that satellites will be going to mars)
We have a plan and architecture. We need a support of 10 Dev people for 10 months to roll out this system in agile manner. First outputs will be visible in 3 months time. R-0.5
Let the Interfaces go/ change (Please check MIT's pranav Mistry on You tube ) and let the Languagaes change radically - some where we have to enter the relation ship of the entities We believe that We can deliver an Immortal Software Platform.
Note - This platform needs - std templates and derived templates for moving from one Language or architecture to other. Be Sure that We will not be writing Logics again and again!!!
ImMortal Software Dev Platform is Not a compiler.
The Best Intresting thing about Immortal Software Platform is
1) you don't have to Keep testing after transition. Only Needs to check the Test Logs.
2) No Rewriting the code
3) Number of Licences reduces
4) People can concentrate on Core technologies and/ or Business inventions
5) Software Maintennace, Portsability Cost reduces
6) Last but not the least we can use the system written by our grand Parements.
Regards
Manoj
jiformworks@yahoo.com
Post a Comment