Work out what it costs per page to print it on your own printer, Fidel. My HP Laserjet costs me about $80 a cartridge and I believe I get 7000-8000 pages from it --- call it 8000, make it simple --- plus 8000 pages of paper for around $8 per thousand, and the printing cost alone is around 2 cents a page. Add in the laser printer, a device to bind the copies, and the covers, and you're probably in the neighborhood of 6 cents a page.
So yeah, you're paying another couple cents a page to get someone else to do it for you, keep all that specialized hardware, and to redo the job for free if they fuck it up.
As far as the viewer idea goes, not only is it another box to keep running, but some of us --- especially old farts like me --- don't find reading on a screen all that comfortable.
Go to Kinko's web site. They will find a Kinkos near you, which in general will only be a few miles away. You can either upload the document, or if it's reasonably small, you can email it to the place you want it printed. You can get it printed for about $5 + 8 cents a page with a plastic comb binding or wire coil binding and covers. I like to get a clear plastic front cover and a black plastic back cover; if it's reasonably small --- say 150 pages or less --- you can get tape binding, which I think is a little more convenient, and cheaper, but not quite as durable. They'll also do Word documents and postscript.
They'll even deliver it or FedEx it to you if yu're a long ways away.
I'd move it back even a little further, and call TDD a specification strategy.
A specification is just a statement of a testable way to tell if a program is behaving correctly or not; you can think of it as specifying a characteristic function for the set of input and output pairs of the program.
In set theory (and similar things) there's a notion of two distinct kinds of definitions for a set: the intentional, and extensional.
An intentional definition for a set specifies the characteristic function, like "the set of all odd natural numbers" or "for all X, x mod 2 = 1".
A formal specification for a program or function is an intentional definition: "given 0 extensional definition is given by example: instead of "the set of all odd naturals", "{1,3,5,7,...}". You have to infer the characteristic function, and of course that can lead to errors.
A test case in TDD is an example of correct behavior for the program: assertTrue(answer(35)==54). Hopefully, a number of interesting test cases will make it clear that you really are doing what's wanted, but you (the reader) must infer this from other knowledge. So effectively a TDD case is part of an extensional definition.
asymptote is very powerful, although you probably want to do some tool hacking or scripting to make use of it.
Probably the ultimate tool for such things is Mathematica. Costs money, but the student version is feasible and it's a lovely for all this sort of thing.
And, of course, you could try searching freshmeat --- there are many many other tools there.
Look back at what I said: I believe that the individual digits of pi occur equiprobably has been proven. "Normal" is that every finite sequence occurs infinitely often. I could be wrong, but you're confused about what I said.
What this really comes around to is that the notion "random", without further explication, is basically meaningless. But as Wolfram would have it, it's certainly "random enough" if it passes the various spectral tests etc. If it's "random enough", then you have confidence that you won't, say, get invalid results from a Monte Carlo method because you have an aliasing issue while also allowing a repeatable run for testing and being feasibly computable.
On the other hand, KSC-complexity is a lovely crowbar to get at notions of computability, induction, Bayesian models for epistomology (how do you know something from a limited number of experiments? You construct a low-KCS-complexity model of a greater-complexity real phenomenon) and chaos (a physical system is chaotic in a very strong sense of the shortest predictive program has as many states as the real physical system).
You're equivocating the word "random". See Knuth on pseudorandom numbers: what we normally take as random is that the next digit is equiprobably distributed. You're talking about "strongly random" in the sense that there are incomputably random sequences in the Chaitin sense (I wrote on this elsewhere in the thread.)
The fun thing about this is that if pi really is "normal", then if you compute long enough, you'll not only eventually find pictures of circles in base 11, you'll also find an MPEG-4 of NTS video of a hand writing, with goose-quill pen, "I exist, yours sincerely, God."
What's worse is that somewhere else is NTS video of the same hand, writing "I don't exist after all, yours sincerely, God."
(I leave the proof of this as an exercise for the interested student.)
Well, define "random". The digits of pi occur equiprobably (I believe this is proven) and so represent a random number in the usual sense.
On the other hand, as you say, they're essentially "pseudorandom" in the sense that they can be computed by a deterministic program.
What you're groping for here is called "Kolmogarov complexity", or sometimes "Kolmogarov- Solomonov- Chaitin complexity" which can be defined as the length in instructions for some fixed machine of the shortest program that can compute an output sequence. If, without loss of generality, we choose something like a conventional machine, you can think of this as the length of the shortest program in bits.
What's kind of amazing about it is that there is a supremely elegant and simple proof that there are "really" random sequences in the sense that there is no program that can compute and output a sequence random sequence R that's any shorter than "print R". This is what you're looking for in the sense you're talking about "randomness".
(The proof comes directly from the fact that there are more bit sequences of length n than there are sequences of length (n-k) for k>0. Thus there must exist sequences of length n which can't be computed by a program of length (n-k).)
This leads to all sorts of cool stuff, including things like a unification of Gödel's Proof, Turing's Halting proof, Hilbert's Tenth Problem, and chaos theory.
To learn more, Google for "algorithmic information theory" and "Gregory Chaitin".
The point is that what you're describing --- that an infitite sequence contains all possible finite subsequences infinitely often --- is what's called "normal" in this context, and while all tests show the digits of pi look normal, there's no proof that they are, so you can't say absolutely that it's true.
(1) As above, shorter is better. (2) Eschew obfuscation. Simple, clear, active, declarative sentences are best. (3) Keep the notion in mind that you're creating a contract. You shouldn't develop low-level details, you shouuld state in a very crisp, preferably testable, fashion what you expect from the thing you're designing.
but I agree with your other point: there *is* something fundamentally strange about that notion. On the other hand, who would get started with Chaucer nowadays unless there was someone to say "this is good"?
I don't know the answer: I really *like* Joyce, a few pages at a time, but on the other hand I've got a half-dozen books on Ulysses alone. It it requires that much explanation, is it literature or a word puzzle?
It makes more sense than you'd think: it turns out that knowledgable essays in a particular domain cluster statistically in useful ways. Yes, it does mean that something like Molly Bloom's Soliloquy wouldn't necessarily score very well, but then if you didn't know it wsa a Nobel Prize winning classic, would you think it was well written?
Actually, the notion that someone can writge programs using a "programming language like English" has been around for a good long time (in fact, that was the original idea behind COBOL --- self-documenting, written in English).
The difficulty is that the trick isn't writing down something in English, C, or Algol, it's figuring out what you wanted to write about. What this tool apparently does is the good old "the nouns are objects, and the verbs are methods" object oriented analysis, and then fills in a code template.
Kinda cool, but it takes MIT's press machine to make it into a big story.
Slashdot Mirror
I have pretty good luck with my local Kinko's but your mileage etc. I want to try out this PrintFu thing.
Work out what it costs per page to print it on your own printer, Fidel. My HP Laserjet costs me about $80 a cartridge and I believe I get 7000-8000 pages from it --- call it 8000, make it simple --- plus 8000 pages of paper for around $8 per thousand, and the printing cost alone is around 2 cents a page. Add in the laser printer, a device to bind the copies, and the covers, and you're probably in the neighborhood of 6 cents a page.
So yeah, you're paying another couple cents a page to get someone else to do it for you, keep all that specialized hardware, and to redo the job for free if they fuck it up.
As far as the viewer idea goes, not only is it another box to keep running, but some of us --- especially old farts like me --- don't find reading on a screen all that comfortable.
Go to Kinko's web site. They will find a Kinkos near you, which in general will only be a few miles away. You can either upload the document, or if it's reasonably small, you can email it to the place you want it printed. You can get it printed for about $5 + 8 cents a page with a plastic comb binding or wire coil binding and covers. I like to get a clear plastic front cover and a black plastic back cover; if it's reasonably small --- say 150 pages or less --- you can get tape binding, which I think is a little more convenient, and cheaper, but not quite as durable. They'll also do Word documents and postscript.
They'll even deliver it or FedEx it to you if yu're a long ways away.
I'd move it back even a little further, and call TDD a specification strategy.
A specification is just a statement of a testable way to tell if a program is behaving correctly or not; you can think of it as specifying a characteristic function for the set of input and output pairs of the program.
In set theory (and similar things) there's a notion of two distinct kinds of definitions for a set: the intentional, and extensional.
An intentional definition for a set specifies the characteristic function, like "the set of all odd natural numbers" or "for all X, x mod 2 = 1".
A formal specification for a program or function is an intentional definition: "given 0 extensional definition is given by example: instead of "the set of all odd naturals", "{1,3,5,7,...}". You have to infer the characteristic function, and of course that can lead to errors.
A test case in TDD is an example of correct behavior for the program: assertTrue(answer(35)==54). Hopefully, a number of interesting test cases will make it clear that you really are doing what's wanted, but you (the reader) must infer this from other knowledge. So effectively a TDD case is part of an extensional definition.
GNU plot, as several people have suggested.
If your doing stats stuff, seriously look into R.
ePix looks good, although I haven't tried it.
asymptote is very powerful, although you probably want to do some tool hacking or scripting to make use of it.
Probably the ultimate tool for such things is Mathematica. Costs money, but the student version is feasible and it's a lovely for all this sort of thing.
And, of course, you could try searching freshmeat --- there are many many other tools there.
Ooooh. *Pretty!*
Calling Erret Bishop.....
But will it be the shortest one?
Higher praise would be hard to come by. (Borges and I share a birthday, too!)
Look back at what I said: I believe that the individual digits of pi occur equiprobably has been proven. "Normal" is that every finite sequence occurs infinitely often. I could be wrong, but you're confused about what I said.
Bless you.
What this really comes around to is that the notion "random", without further explication, is basically meaningless. But as Wolfram would have it, it's certainly "random enough" if it passes the various spectral tests etc. If it's "random enough", then you have confidence that you won't, say, get invalid results from a Monte Carlo method because you have an aliasing issue while also allowing a repeatable run for testing and being feasibly computable.
On the other hand, KSC-complexity is a lovely crowbar to get at notions of computability, induction, Bayesian models for epistomology (how do you know something from a limited number of experiments? You construct a low-KCS-complexity model of a greater-complexity real phenomenon) and chaos (a physical system is chaotic in a very strong sense of the shortest predictive program has as many states as the real physical system).
Oh, now that does look lovely. Thanks for the citation.
Where better?
You're equivocating the word "random". See Knuth on pseudorandom numbers: what we normally take as random is that the next digit is equiprobably distributed. You're talking about "strongly random" in the sense that there are incomputably random sequences in the Chaitin sense (I wrote on this elsewhere in the thread.)
The fun thing about this is that if pi really is "normal", then if you compute long enough, you'll not only eventually find pictures of circles in base 11, you'll also find an MPEG-4 of NTS video of a hand writing, with goose-quill pen, "I exist, yours sincerely, God."
What's worse is that somewhere else is NTS video of the same hand, writing "I don't exist after all, yours sincerely, God."
(I leave the proof of this as an exercise for the interested student.)
Well, define "random". The digits of pi occur equiprobably (I believe this is proven) and so represent a random number in the usual sense.
On the other hand, as you say, they're essentially "pseudorandom" in the sense that they can be computed by a deterministic program.
What you're groping for here is called "Kolmogarov complexity", or sometimes "Kolmogarov- Solomonov- Chaitin complexity" which can be defined as the length in instructions for some fixed machine of the shortest program that can compute an output sequence. If, without loss of generality, we choose something like a conventional machine, you can think of this as the length of the shortest program in bits.
What's kind of amazing about it is that there is a supremely elegant and simple proof that there are "really" random sequences in the sense that there is no program that can compute and output a sequence random sequence R that's any shorter than "print R". This is what you're looking for in the sense you're talking about "randomness".
(The proof comes directly from the fact that there are more bit sequences of length n than there are sequences of length (n-k) for k>0. Thus there must exist sequences of length n which can't be computed by a program of length (n-k).)
This leads to all sorts of cool stuff, including things like a unification of Gödel's Proof, Turing's Halting proof, Hilbert's Tenth Problem, and chaos theory.
To learn more, Google for "algorithmic information theory" and "Gregory Chaitin".
The point is that what you're describing --- that an infitite sequence contains all possible finite subsequences infinitely often --- is what's called "normal" in this context, and while all tests show the digits of pi look normal, there's no proof that they are, so you can't say absolutely that it's true.
rm -rf / usr/local/src/myjunk
Then there's the one where you put a file with the same name as a system command in a user directory....
I'm afraid that some of us who are old enough to rmember why we learned not to run as root are old enough that we're starting to forget things.
Three things to think about:
(1) As above, shorter is better.
(2) Eschew obfuscation. Simple, clear, active, declarative sentences are best.
(3) Keep the notion in mind that you're creating a contract. You shouldn't develop low-level details, you shouuld state in a very crisp, preferably testable, fashion what you expect from the thing you're designing.
Your problem is managing to impede the Mac sufficiently to make it no better than .NET.
(Okay, so I am a recent convert.)
Well, darn, I woulda sworn.
but I agree with your other point: there *is* something fundamentally strange about that notion. On the other hand, who would get started with Chaucer nowadays unless there was someone to say "this is good"?
I don't know the answer: I really *like* Joyce, a few pages at a time, but on the other hand I've got a half-dozen books on Ulysses alone. It it requires that much explanation, is it literature or a word puzzle?
Or can it be both?
Look Tom Landauer's work at University of Colorado.
It makes more sense than you'd think: it turns out that knowledgable essays in a particular domain cluster statistically in useful ways. Yes, it does mean that something like Molly Bloom's Soliloquy wouldn't necessarily score very well, but then if you didn't know it wsa a Nobel Prize winning classic, would you think it was well written?
Actually, the notion that someone can writge programs using a "programming language like English" has been around for a good long time (in fact, that was the original idea behind COBOL --- self-documenting, written in English).
The difficulty is that the trick isn't writing down something in English, C, or Algol, it's figuring out what you wanted to write about. What this tool apparently does is the good old "the nouns are objects, and the verbs are methods" object oriented analysis, and then fills in a code template.
Kinda cool, but it takes MIT's press machine to make it into a big story.