It might be horrendous work to update all standards and templates and such, but it is inevitable that this will happen at some point in the (near) future. The battle that is fought within the EU at the moment is not about OS (operating systems) nor about OS (open source), not even about OS (office suites), but about OS (open standards).
The situation you sketch above with migration problems for ms-office, is very scary for a government that is supposed to have some openness and accountibility. Currently nearly all governements in the western world have 'standardized' on some microsoft format, but none of these governments can actually guarentee that these documents will be available for reading in 10 years time, simply because Microsoft does not give any such guarantees. In fact, the situation you sketch with public data that is only accessible through the software made by a single company should be made illegal.
People are starting to realize the danger of this situation, that all these nice documents and templates can become unreadable simply because a commercial company decides that it is not in their interest to be compatible with their older formats. Other issues in government are proprietary database formats. In many places it is such that the data of general practitioners cannot be read in the hospital's system and vice-versa. At this point to collect a person's medical dossier, the only way is to print out everything that is known and collect it through regular mail. This simply costs lives, as ambulance personal has no way of knowing that the person who just broke a leg is on a particular type of medication that cannot be combined with particular pain-killers.
The only way out of this mess is the use of Open Standards, which is a much less controversial issue than the use of Open Source. It seems that the awareness of this issue is rising, even though many people will not let go of MS-Office willingly. At some point (which I think is not far off), it will become illigal for a governmental body to standardize on MS formats, unless MS will create an open standard of it. When this situation arises, MS will probably comply, but this does mean that suddenly the playing field is leveled, as everyone has access to the specs and can write their implementations/frontends.
However, although this (political) struggle for Open Standards is fought for a large part by the Open Source community, it is actually hampered by the community as well. Unlike Open Standards, which is non-controversial, Open Source is (This is mainly caused by economic arguments: governements want to endorse a local software industry, and open source is not much of an industry).
By pushing both Open Standards and Open Source, the non-controversial point (Open Standards) is obscured by the controversial one (Open Source). It is easy to convince even the most business-friendly official that Open Standards are mandatory for a governmental body, but much more difficult to do the same for non-corporate backed software.
Ironically, if Open Standards are compulsory in government, this will be a big boost for Open Source, as then it is no longer neccessary to reverse engineer formats, and software can be evaluated on their merits (compliance to standards, functionality, price, etc.)
Thus in my opinion, by wanting to have both issues resolved at the same time, the Open Source lobby hampers its own goals. To get back on topic, although it is great that some council in the UK is starting to use open source, the issues that are raised in this discussion seems to center on the possibility of loading in proprietary formats of Star/Open Office. The important question that I miss being asked here is: On what formats does this Council standardize now?, and how are they planning to exchange information with other governmental bodies?
I'll finish this rant with a plea to the Open Source community as a whole: when dealing with governments, keep pushing Open Standards, and lobby for official stand
Also wrong, given the precision, 0% is the correct answer. Or would you want to argue that the fraction of even prime numbers is 1% or (god forbid) higher?
WOW, +5, insightful and 100% wrong.
Probability assessment is about making a valid guess based on limited information. Given your argument (50-65% of adults and 75% for children and the general balance of children and adults in the world), 2/3 (NOT 66.6666667%, that's a totally different statement), is a perfectly valid guess. 16 + 2/3 is as good as 17% and obviously, given that all the grandparents statistics are correct, the last one is not, is, is not, is, is not, is...
So, you use a specialized fork for every meal? Does your dinner come with plates as well? When was the last time you washed, conditioned, combed and dried your hair with this single tool? When using public transport, do you insist that the train will take you to your place of work, or would you also take a bus and do a bit of walking? Where are the monolithic apps in real life?
I sure hope for these guys that the helmet will still be effective to stop bullets (at the appropriate angle), shrapnel and the like. Otherwise their heads will be filled with metal before they'll get their next command from doctor Strangelove.
Big Deal! Back in my day, we ran a filesystem over smtp: sent your commands per email, have it executed remotely, and send the results back to the sender. Imagine:
To: user+bash@host.com
ls/usr/bin
And get the result back by email. The tricky part was to do (insecure) copy: cat piped to uuncode etc.
To paraphrase: it's not really the easiest thing to automate but it sure worked for day-to-day computing
Excellent example for the use of operator overloading. Most languages out here support the:
b = a + 1
idiom for vectors and (multidimensional) matrices. The fact that this is impossible for Java really constitutes a problem for library builders (mere application developers should indeed be forbidden to do operator overloading, but for a library it is often a *must*).
Maybe complain about the fact that even if you actually got off your ass instead of complaining all the time, there's no way you can do anything about how Java evolves other than complain about it.
Well, I've written around 250,000 lines of Java code, and I can count on one hand the number of times I found it necessary to use a debugger.
Doesn't this have a tiny bit to do with Java always running inside some minimal debugger? Imagine rigging C++ in such a way that it will always run through gdb and on error will provide you with a stacktrace. The stacktrace gives enough info for the majority of the bugs, but would you then with a straight face claim that you can program C++ without ever using a debugger?
20 years from now, everything that is written is controlled through DRM. If you want to read a book, you'll pay a one time read license fee. The book will be unavailable after that read unless you continue to shell out money. If you don't have the money, you can't read books. If you can't read books, you can't educate yourself. If you can't educate yourself, there's no way you'll ever be able to make enough money to let your children read books.
So now with DRM we will be extending the gap between the haves and the have nots from tangible goods: food, water and pretty automobiles, to the basis of self-improvement: education, information and knowledge. It will permanently make it impossible for the poor to educate their children, for geniuses in poor countries to learn from the geniuses that came before them.
Next to that, all knowledge through DRM that becomes out of vogue for even a short period of time will become lost forever. Companies go broke, the keys that open the locks to the books get lost. Large parts of our culture will simply dissappear.
No, this is not a crime against humanity, as no humans will get killed, it's a crime against human culture, and it's got the potential to end it alltogether. There's no problem with that, we'll just start living in caves again, bashing each other's skulls.
pspam = P(spam); pnospam = P(not spam); foreach unique words w in e-mail do pspam = pspam * P[w][spam]; pnospam = pnospam * P[w][nospam]; endfor
if (pspam > pnospam) then return IS_SPAM; else return IS_NO_SPAM;
You'll soon be running out of bits to store the floating point results. Implement it by adding logarithms of probabilities instead of products of them, thus:
lpspam = log(P(spam)); lpnospam = log(P(not spam)); foreach unique words w in e-mail do lpspam = lpspam + log(P[w][spam]); lpnospam = lpnospam + log(P[w][nospam]); endfor
if (lpspam > lpnospam) then return IS_SPAM; else return IS_NO_SPAM;
If you have a couple of hundred key-words, this will make a lot of difference concerning the accuracy of the predictions.
Interesting thought, though not likely. What you'll get is a case against the linux-developer that put the code in the linux-base, any discussions about the code on public record (open source, remember), and the developer from SCO that claimed he wrote it. That SCO-developer has to testify and risks purgery charges, possibly prisontime, when found out. Any of his co-workers at the alleged time of development (that do not neccessarily work for SCO anymore) can countertestify that the guy never wrote anything of the sort and might put the guy in jail. For how much money would you take such a risk?
IBM, just go ahead, buy SCO, and sue Microsoft for every penny they have for the apparent theft (why only now suddenly pay license fees?) of SCO's (now IBM's) IP.
Good advice, but an urban legend in its own way. The "saving optimizations where it is needed" statement presumes that the code is decent enough already. Very often it isn't. Consider a situation where a C programmer passes everything (even large structs etc.) by value. Performance is hurting and he runs a profiler. The profiler cannot pinpoint a location that runs slowly, as the problem is everywhere. In this particular case, because it involves every function and every struct, there's no 10% of code that can be optimized to improve performance, no 100% of the code needs to be changed to improve it.
Something similar can hold for Java. Because memory management is done by the GC, many new programmers are taught not to worry about MM. What they end up with is a program that has a horrible memory footprint, and there's no 10% of the code that can be improved to lessen the burden. Here again, 100% of the code needs to be optimized.
And yes, this does happen a lot. Due to the urban legend, people are not concentrating on writing efficient (not optimized, efficient!) code, and
I've seen it happen that once they finish the product is hardly deployable because of speed/memory issues that are scattered around the entire source base.
Consistency: no contradictions can be derived. If you create a theorem prover where both something and its negation are true, you've got an inconsistent formal system. Note that this has nothing whatsoever to do with the fact that the underlying computer itself is functioning consistently. An example of an inconsistent theorem prover is:
int prove(theorem) { return 1; }
or, if you prefer, in Prolog:
_.
Thus the axiomatization of this system is simply that everything is true. From this formal system I can derive that false equals true. What is my misinterpretation of this axiom?
As others here have said, what good is a brain until we get a useful BODY working?
I would say that a body that can telnet to port 80 to different locations and analyze the output from that should be plenty enough for an AI to get at least a chaotic, interesting environment to dwell in.
No, it would be an inconsistent system that resembled Peano arithmetic. It's ridiculously easy to create an inconsistent formal system, the fact that it can be run on a computer has nothing to do with its consistency.
Suppose we have such a little critter who is stuck at a silly line terminal, and all it can do is type input like:
$> telnet 216.239.51.100 80 Trying 216.239.33.100... Connected to 216.239.33.100. Escape character is '^]'. GET index.html HTTP/1.0
From the output of this little conversation, now what can our little critter actually sense?
Robotics is nice and all, but we've got pretty intelligent vision and moving machine already. They grow tired and all, so there is some market for more powerful machines, but what the real challenge of AI is, is to create true information critters, masters of the domain of simple line terminal input and output, a domain that is hugely powerful, infinitely complex, and in which people aren't very proficient.
Not for all possible values of Unix. For Unix equals zero we would get "GNU's Not Indeterminate", or "GNU's Not Not A Number", depending on your floating point support.
Hmm, given all these results, we might conclude that GNU is not One, and if Unix is Zero, GNU is determinate and a number. Thus GNU's a determinate number, eventhough that number still needs to be determined.
Re: I've used genetic algorithms
on
Digital Darwin
·
· Score: 1
The only general approach I have seen to date to tackle this question is Tom Ray's Tierra program (don't feel like linking, try google: Ray Tierra). Here selection is based on the only resource present in a computer, CPU-time. Very interesting behaviour, and although old (late 1980's) the most convincing experiment in artificial evolution to date.
And yes, genetic algorithms model artificial selection (breeding) more than natural selection (struggle for survival).
Where do I pay these license fees? The only thing I can find is this.
In any case, a colloborative search engine API using distributed computing might still be a nice thing for not-for-profit purposes. One of the applications I wanted to use this API for was be a plagiarism search for teachers to quickly scan student papers to see if they were simply pulled of the net. This was bombed by the 1000 query limit of Google's api, as to do the search properly would require a few tens of queries for each paper. If you have to check tens of these papers the limit can be reached fairly soon.
For this purpose speed wouldn't be so much of an issue, so maybe a distributed cataloguing (sp) and search system might be something interesting?
Apart from the multithreading, why on earth is example 1 piss poor code and example 2 good code? Number 1 has excellent data hiding, so good that noone can access the local data without changing the function code. No 1. has much less maintainance problems as the maintainer does not have to worry about people sending it all kinds of foolish objects with arbitrary values. All it has is local data: the use of the static is confined to the single function, problems with it are confined to the function.
No. 2 however has some arbitrary structure that needs to be known to the user of your code. It needs to know how to initialize it, how it is used in your function, and whether or not it can touch it. The data you send through it is probably only relevant for this one function, so why on earth should anyone else care about it, much less be forced to you it? If you have a problem with some code using this function, you will have to wade through hundreds of different functions to figure out where in the macaroni (OO's spaghetti substitute) the data is modified.
Piss poor programming indeed.
With thread local storage (a C(++) extension that some compilers have for you), the no. 1 example can even be made thread safe by inserting a single keyword.
Slashdot Mirror
The situation you sketch above with migration problems for ms-office, is very scary for a government that is supposed to have some openness and accountibility. Currently nearly all governements in the western world have 'standardized' on some microsoft format, but none of these governments can actually guarentee that these documents will be available for reading in 10 years time, simply because Microsoft does not give any such guarantees. In fact, the situation you sketch with public data that is only accessible through the software made by a single company should be made illegal.
People are starting to realize the danger of this situation, that all these nice documents and templates can become unreadable simply because a commercial company decides that it is not in their interest to be compatible with their older formats. Other issues in government are proprietary database formats. In many places it is such that the data of general practitioners cannot be read in the hospital's system and vice-versa. At this point to collect a person's medical dossier, the only way is to print out everything that is known and collect it through regular mail. This simply costs lives, as ambulance personal has no way of knowing that the person who just broke a leg is on a particular type of medication that cannot be combined with particular pain-killers.
The only way out of this mess is the use of Open Standards, which is a much less controversial issue than the use of Open Source. It seems that the awareness of this issue is rising, even though many people will not let go of MS-Office willingly. At some point (which I think is not far off), it will become illigal for a governmental body to standardize on MS formats, unless MS will create an open standard of it. When this situation arises, MS will probably comply, but this does mean that suddenly the playing field is leveled, as everyone has access to the specs and can write their implementations/frontends.
However, although this (political) struggle for Open Standards is fought for a large part by the Open Source community, it is actually hampered by the community as well. Unlike Open Standards, which is non-controversial, Open Source is (This is mainly caused by economic arguments: governements want to endorse a local software industry, and open source is not much of an industry). By pushing both Open Standards and Open Source, the non-controversial point (Open Standards) is obscured by the controversial one (Open Source). It is easy to convince even the most business-friendly official that Open Standards are mandatory for a governmental body, but much more difficult to do the same for non-corporate backed software.
Ironically, if Open Standards are compulsory in government, this will be a big boost for Open Source, as then it is no longer neccessary to reverse engineer formats, and software can be evaluated on their merits (compliance to standards, functionality, price, etc.)
Thus in my opinion, by wanting to have both issues resolved at the same time, the Open Source lobby hampers its own goals. To get back on topic, although it is great that some council in the UK is starting to use open source, the issues that are raised in this discussion seems to center on the possibility of loading in proprietary formats of Star/Open Office. The important question that I miss being asked here is: On what formats does this Council standardize now?, and how are they planning to exchange information with other governmental bodies?
I'll finish this rant with a plea to the Open Source community as a whole: when dealing with governments, keep pushing Open Standards, and lobby for official stand
Also wrong, given the precision, 0% is the correct answer. Or would you want to argue that the fraction of even prime numbers is 1% or (god forbid) higher?
WOW, +5, insightful and 100% wrong. Probability assessment is about making a valid guess based on limited information. Given your argument (50-65% of adults and 75% for children and the general balance of children and adults in the world), 2/3 (NOT 66.6666667%, that's a totally different statement), is a perfectly valid guess. 16 + 2/3 is as good as 17% and obviously, given that all the grandparents statistics are correct, the last one is not, is, is not, is, is not, is ...
So, you use a specialized fork for every meal? Does your dinner come with plates as well? When was the last time you washed, conditioned, combed and dried your hair with this single tool? When using public transport, do you insist that the train will take you to your place of work, or would you also take a bus and do a bit of walking? Where are the monolithic apps in real life?
I sure hope for these guys that the helmet will still be effective to stop bullets (at the appropriate angle), shrapnel and the like. Otherwise their heads will be filled with metal before they'll get their next command from doctor Strangelove.
To: user+bash@host.com
ls /usr/bin
And get the result back by email. The tricky part was to do (insecure) copy: cat piped to uuncode etc.
To paraphrase: it's not really the easiest thing to automate but it sure worked for day-to-day computing
Maybe complain about the fact that even if you actually got off your ass instead of complaining all the time, there's no way you can do anything about how Java evolves other than complain about it.
Doesn't this have a tiny bit to do with Java always running inside some minimal debugger? Imagine rigging C++ in such a way that it will always run through gdb and on error will provide you with a stacktrace. The stacktrace gives enough info for the majority of the bugs, but would you then with a straight face claim that you can program C++ without ever using a debugger?
So now with DRM we will be extending the gap between the haves and the have nots from tangible goods: food, water and pretty automobiles, to the basis of self-improvement: education, information and knowledge. It will permanently make it impossible for the poor to educate their children, for geniuses in poor countries to learn from the geniuses that came before them.
Next to that, all knowledge through DRM that becomes out of vogue for even a short period of time will become lost forever. Companies go broke, the keys that open the locks to the books get lost. Large parts of our culture will simply dissappear.
No, this is not a crime against humanity, as no humans will get killed, it's a crime against human culture, and it's got the potential to end it alltogether. There's no problem with that, we'll just start living in caves again, bashing each other's skulls.
You'll soon be running out of bits to store the floating point results. Implement it by adding logarithms of probabilities instead of products of them, thus:
If you have a couple of hundred key-words, this will make a lot of difference concerning the accuracy of the predictions.
I think you should be more explicit in step 2.
needless to say, IANAL
IBM, just go ahead, buy SCO, and sue Microsoft for every penny they have for the apparent theft (why only now suddenly pay license fees?) of SCO's (now IBM's) IP.
Something similar can hold for Java. Because memory management is done by the GC, many new programmers are taught not to worry about MM. What they end up with is a program that has a horrible memory footprint, and there's no 10% of the code that can be improved to lessen the burden. Here again, 100% of the code needs to be optimized.
And yes, this does happen a lot. Due to the urban legend, people are not concentrating on writing efficient (not optimized, efficient!) code, and I've seen it happen that once they finish the product is hardly deployable because of speed/memory issues that are scattered around the entire source base.
or, if you prefer, in Prolog:
Thus the axiomatization of this system is simply that everything is true. From this formal system I can derive that false equals true. What is my misinterpretation of this axiom?
I would say that a body that can telnet to port 80 to different locations and analyze the output from that should be plenty enough for an AI to get at least a chaotic, interesting environment to dwell in.
No, it would be an inconsistent system that resembled Peano arithmetic. It's ridiculously easy to create an inconsistent formal system, the fact that it can be run on a computer has nothing to do with its consistency.
From the output of this little conversation, now what can our little critter actually sense?
Robotics is nice and all, but we've got pretty intelligent vision and moving machine already. They grow tired and all, so there is some market for more powerful machines, but what the real challenge of AI is, is to create true information critters, masters of the domain of simple line terminal input and output, a domain that is hugely powerful, infinitely complex, and in which people aren't very proficient.
Hmm, given all these results, we might conclude that GNU is not One, and if Unix is Zero, GNU is determinate and a number. Thus GNU's a determinate number, eventhough that number still needs to be determined.
And yes, genetic algorithms model artificial selection (breeding) more than natural selection (struggle for survival).
'ls' in PDP-10 compatibility mode?
In any case, a colloborative search engine API using distributed computing might still be a nice thing for not-for-profit purposes. One of the applications I wanted to use this API for was be a plagiarism search for teachers to quickly scan student papers to see if they were simply pulled of the net. This was bombed by the 1000 query limit of Google's api, as to do the search properly would require a few tens of queries for each paper. If you have to check tens of these papers the limit can be reached fairly soon.
For this purpose speed wouldn't be so much of an issue, so maybe a distributed cataloguing (sp) and search system might be something interesting?
Apart from the multithreading, why on earth is example 1 piss poor code and example 2 good code? Number 1 has excellent data hiding, so good that noone can access the local data without changing the function code. No 1. has much less maintainance problems as the maintainer does not have to worry about people sending it all kinds of foolish objects with arbitrary values. All it has is local data: the use of the static is confined to the single function, problems with it are confined to the function.
No. 2 however has some arbitrary structure that needs to be known to the user of your code. It needs to know how to initialize it, how it is used in your function, and whether or not it can touch it. The data you send through it is probably only relevant for this one function, so why on earth should anyone else care about it, much less be forced to you it? If you have a problem with some code using this function, you will have to wade through hundreds of different functions to figure out where in the macaroni (OO's spaghetti substitute) the data is modified. Piss poor programming indeed.
With thread local storage (a C(++) extension that some compilers have for you), the no. 1 example can even be made thread safe by inserting a single keyword.
+ Nothing sucks like a VAX