Field Guides

Army Ranger Handbook: $20 new, $40 used (wtf). There is also a seller on Amazon selling them for $8.50. The U.S. Army publishes all sorts of survival handbooks, some of which are readable online. However, this one is, as far as I can tell, the best of the lot (I obviously haven’t bought them all, geez).

Where There Is No Doctor: $20 new, $21 used (really, Amazon?). A great, great reference for all sorts of doctoring. If you plan on going…well, where there is no doctor, you should have this book. First written in the 1970s, updated over the years and most recently in 2007. I own a copy and take it with me on trips everywhere. It has info on everything from gangrene to various bites to hypothermia and cholera.

Pocket Ref: $9.32 new, don’t buy used. This book, by some miracle of small font and thin pages, crams TONS of information into a book that will easily fit in your pocket. I recommend clicking on “Look inside this book” on Amazon and checking out the table of contents and stuff. Funny story: When I was going to buy this, I figured that I would check to see if it had something random I wanted to know. If it did have it, I would buy it. I wanted to know about cloud formations and what weather they signaled. Well, it didn’t have it but I bought it anyways. Then, when it arrived, I checked again and it had three pages about various cloud formations. Jackpot!

The Zombie Survival Guide: $10 new, $6 used. You might need this sooner than you think. Very comprehensive.

Programming/Math

Programming Pearls, 2nd edition: $30 new, $20 used. This book is an amazing collection of various code examples that illustrate all sorts of algorithms and techniques. A great read.

Edward Tufte’s books on data visualzation: I like Edward Tufte’s books. They have some amazing stuff in them. However, unless you’re hardcore into statistics and data visualization, you could settle for Envisioning Information ($35 new, $17 used) and The Visual Display of Quantitative Information (2nd ed. $28 new, $17 used).

Schaum’s 3000 Solved Calculus Problems: ($19 new, don’t buy used). Worried about your Calculus skills going to waste when you have no math-related classes? I do. Hence this book, recommended by my Calc prof. Do a couple problems a day and you should be good to go.

Bathroom Companions

Mental Floss: Condensed Knowledge and others: $10 each. Great books by the mental_floss magazine, which is itself pretty excellent. Full of fun trivia and informative tidbits! All you need to do to appear cultured is to remember half the material in one of these books.

MAD Bathroom Companion: The Mother Load: $20. MAD Magazine compiled a bunch of stuff into this ridiculous, funny, huge book consisting of hilarious comics and crude jokes. As its name suggests, it truly is a great bathroom companion.

Philosophy

Koran (Qu’ran) [alternate translation]: $10.00 new, $5.00 used. alternate translation $5.00 new. I’m disappointed by the number of Americans who blindly judge the Muslim faith. This text is the Muslim text, and honestly if you read it, it’s not at all bad. It is a very open religion, and it’s only the jihadists who, like the Catholic inquisitors, break the very tenets of their faith in blind misguidance. If nothing else, it’s a good read.

Tao te Ching and Chuang Tzu: $10.00 each new. Taoism is a religion that has got it right, if you ask me. These two texts are central to the Taoist faith. Whether or not they make sense depends on how slowly you read them, but the Taoist philosophy is outlined here, as a gem in the rough, that can help anyone with some spiritual improvement.

Bhagavad Gita: $10.00 new, $7.00 used. An excellent translation by Stephen Mitchell, this book provides a surprising insight into Asiatic and Indian religion. The Bhagavad Gita is the central text of Hinduism,  from which both Taoism and Buddhism have sprung. It has lots of good ideas, and understanding the Gita is important if you want to understand Indian culture (this is less true now, but still).

King James Study Bible: $30 new, $25 used. Although I haven’t bought this bible myself, having inherited two or three bibles from my parents, I plan on getting it eventually. The Bible is a great story, and it presents interesting ideas. I wouldn’t base my life on it, but oh well. Study bibles have tons of additional stuff. This particular bible has over 2,000 pages!

Plato’s Republic: $13 new, $4 used. I don’t know what to say about this one, to be honest. It’s one of the books I just bought. Apparently one of the best translations of Plato, and it comes with a glossary and introduction and essay and stuff (standard fare). Plato’s Republic is probably the most well-known piece of Greek philosophy, although not the most recognized piece of literature (that would probably be the Odyssey, which, along with the Iliad, also has an entry on this list). Like most (all?) of Plato’s work, Republic is a Socratic dialog: Socrates and various other people talking. Republic had a pretty major impact on politics and political science, including setting the groundwork for our society today.

Comics

Bone: One Volume Addition: $25 new, $15 used. An absurdly excellent comic with an epic plot and hilarious writing. Highly recommended! It’s sort of a “thinking man’s comic” if said thinking man likes to crap his pants from laughing.

Fiction

The Iliad and The Odyssey. $10 each new, $3-4 each used. Classics in every sense of the word, these epic poem/novels are not only ancient but they are still very engrossing. In the Iliad, relive the epic of the Trojan War in a way that no later book has been able to reproduce. In the Odyssey, follow the journey of Odysseus through many perils to his front door, and then observe as he acts really sneaky and kills lots of dudes in his house.

Recursive Simulations

It might have occured to you to wonder about the people that (may have) made the simulation you (may be) living in. Doesn’t the same logic apply to them, indicating that they are probably living in a computer simulation?

Well, just like you, they probably are. Eventually, though, the odds will be overcome. Eventually, somewhere in the (probably long) string of simulations that would be assumed to exist, there must be an original simply by chance. However, note that as soon as you accept an additional level of simulation recursion, the chances of being biological decrease drastically. If N is the number of minds presumed to be in all simulations created by a society, S is the number of societies per simulation that develop simulations themselves, R is the number of recursions accepted, and P is the number of biologically real entities in the universe, then the chance of being real is given by:

As you see, each additional level of recursion reduces the chance of being original by (S*N), the number of simulatons created within each simulation (or within reality): a very large number, presumably.

Religion In Simulated Reality

An interesting side effect of living in a simulated reality is that it makes God-based religions inherently possible. We were created by someone, maybe, who may have a purpose for us. However, the idea lends itself best to Taoism, which is complicated to summarize but basically believes in a central “life stream” called the Tao, or Way, that it is your job to follow. This is very easily applicable to life inside a computer program, which has a general flow of execution, and similarly applicable to life as a computer program, which is designed naturally to do specific things. This is good because I also think that Taoism is an extremely valid philosophy for life even if it’s not in a computer simulation.

Life After Death

Basically there is probably none. Your consciousness ends, your thread in the program is terminated. However, depending on the intent of the system, it could be that certain essential aspects of your personality, assigned when you are born, are recycled for future threads (purely speculation based on the use of the simulation. If it is designed to examine how certian types of individuals act in different environments, then your “type of individual” might be recyclable). And the memory used by your consciousness’s thread probably will be recycled in any case, but that is hollow: one object that uses memory doesn’t influence objects that use that same memory later.

I mean, when you look at this operation from the outside, it’s pretty simple. Regular brain goes dead, cyber brain wakes up. Consciousness transferred. Right? However, what if you’re the dude actually using the regular brain. If you think about it, moving data is the same as copying it and then deleting the original. In this context, it meas that your consciousness is cloned, and then the original consciousness, you, is destroyed.

So you have a clone of your consciousness in the cyber brain, sure, and it might even be thinking, “Yes! The operation was a success! My consciousness was transferred perfectly!” while, of course, the original consciousness, you is dead. This puts a major damper on my desire to be cyberized, which I’ve had for many years. Sure I get to clone myself into a computer brain, but how does that help me any?

Weird.

The idea itself is rather simple. Given that a) there exists, will exist, or has existed a sentient species or individual with the technology to create simulated reality, b) said species or individual only uses a tiny fraction of their resources to create this simulation, c) said species or individual would want to create, and would in fact create, said realities in large numbers, and d) there are enough conscious minds in these realities that, when realities are created en masse, there are orders of magnitude more conscious minds in simulated realities than there are in true reality, then your conscious mind is more likely to be in a simulation than to be real. I will examine these premises one at a time.

A. There exists, will exist, or has existed a sentient species or individual with the technology to create simulated reality.

This particular premise seems the most obvious to me, but is apparently difficult for some people to come to grips with. I suggest reading the original argument for a detailed analysis of its plausibility. In it, the author Nick Bostrom gives a detailed analysis of the theoretical feasibility of having the computing power necessary to simulate reality. He comes to the conclusion that “a rough approximation of the computational power of a planetary-mass computer is 10^42 operations per second, and that assumes only already known nanotechnological designs, which are probably far from optimal. A single such a computer could simulate the entire mental history of humankind (call this an ancestor-simulation) by using less than one millionth of its processing power for one second.”

Whether or not this is true, I cannot say. I think of it this way: The universe is nearly infinite in size, relative to the scale of Earth. Similarly, the time scale we are talking about (which is “any time at all”) is nearly infinite. It can simply be said that, with nearly infinite space, nearly infinite resources, and nearly infinite time, basically anything can happen. It’s even possible that humankind will be able to develop this technology ourselves.

B: Said species or individual only uses a tiny fraction of their resources to create this simulation.

This statement is considered true for the same reasons given above. If the race can create simulated reality, it won’t be long before they can do it really easily. Eventually, it will be a trivial task (as stated above, using a suboptimal planetary computer, you could calculate the entire mental history of humankind one million times in a second). Basically, if you can swallow premise A, this one should follow without issue.

C: Said species or individual would want to create, and would in fact create, said realities in large numbers.

Okay, here we might get fuzzy. On one hand, who wouldn’t want to make a bunch of realities and play God? I sure would! I have a feeling that once we have the computing power to do this, we totally would make them all over the place. There are lots of reasons to do so: we could simulate our own evolution with slight variations to determine how it would alter the future, replay the development of humankind for entertainment purposes, or complete a totally different species to determine how they would survive. The realities would be good for research but they would also probably be a lot of fun. Think of it as the ultimate Sims.

On the other hand, though, I question the assumption that the society or individual would make a bunch of these realities (a bunch = more than 100,000, say) for the same reason that I don’t use my computer for running 100,000 instances of Nethack instead of playing Team Fortress 2: why bother with old technology? When your computing power vastly outstrips that which is required for simulations, why bother generating them (since you probably have something that needs even more computing power to do).

D: There are enough conscious minds in these realities that, when realities are created en masse, there are orders of magnitude more conscious minds in simulated realities than there are in true reality.

This premise goes without saying, and indeed, went without saying in Prof. Bostrom’s report: how many minds are in these simulated realities? If each only has one, well… um. Yeah. However, It is assumed that each created reality has a bunch of AIs in it (tens of billions or more): enough that the number of consciousnesses in the simulated realities dwarf the number of consciousnesses in the actual reality.

Conclusion: You’re In Another Reality?

If these four statements are true, the result is that you are probably in another reality! Since far more conscious minds exist within simulated realities than exist out of them, your conscious mind is far more likely to be in a simulated reality. Fun!

Look for future episodes in the “Computer Simulation” crazy train including recursive simulations, probability of technology, and maybe even some concrete proofs (though the original has some nice maths along these lines in Section IV).

In short, a sparkline is a small plot, generally a line plot, that is about the same height as the text around it. It should also have a dot at its maximum point, if it’s trying to be a real, true sparkline, and it should have a greyish line. However, there is a lot of variation here, and people even make sparkhistograms and sparkpiecharts.

Now that you know what sparklines are, I bet you want to make some. Well…okay! There are a lot of ways to do this. There are (presumably good) sparklines libraries for PHP, Ruby, jQuery (this one looks especially interesting), and even Excel. Or, if you’re a bit crazy and/or like doing things yourself, you could make your own sparkline library! I chose the latter option.

Thus, I’ve created a working, not-yet-perfect sparkline maker for Squeak Smalltalk. Squeak makes graphics (called Morphs) ridiculously easy, and thus makes sparklines pretty simple. Before we begin, a quick note: Squeak represents (x,y) positions as x@y.

Step 1: Create a Form for drawing. I’m going to make an ImageMorph, which has an empty ColorForm as its image. The ColorForm is given a width and height based on various properties of the SparkLinePlot instance.

morph := (ImageMorph new) openInWorld.
morph isOpaque: false.
morph image: (ColorForm extent: (((data size) + 2) * (pointSpace))@(height * 2) depth: 8).

Step 2: Prepare a few variables for use. x and y are going to refer to the (x,y) coordinates of each point, while scale is going to be multiplied against each data point to “shrink” the data to fit into the desired…well, scale.

scale := (height) / (data range).
x := y := 0.

Step 3: Next, we’re going to make a Pen object that’s going to draw the lines for us. Pen objects are remarkably simple to operate: just create one and move it around with the place:, go:, and goto: messages (e.g. “pen goto: 4@4″). The place: method doesn’t draw lines on its way, so it’s good for initial positioning.

pen := (Pen newOnForm: (morph image)) defaultNib: lineWidth.
pen place: x@y.

Step 4: Finally, we get the pen to draw! The do: message iterates over a collection, calling the associated block once per item in the collection (That is to say, the block runs once per item in the collection, each time setting the variable “dp” to be equal to that item). The y variable is negated because, in Squeak, positive y is down.

data do: [:dp |
		y := height + ((dp * scale) negated).
		(x = 0) ifFalse: [pen goto: x@y] ifTrue: [pen place: x@y].
		x := x + pointSpace.]

Step 5: Let’s make this plot pretty. I want to see a little indicator where the max data point is, and maybe even have it change colors from positive to negative. Not so hard! Inside the “data do: []” block, we could add stuff so it looks like the following:

data do: [:dp |
	y := height + ((dp * scale) negated).
	(x = 0) ifFalse: [pen goto: x@y] ifTrue: [pen place: x@y].
	(dp = data max) ifTrue: [ pen color: Color yellow lighter.
		                         pen goto: (x + (lineWidth * 2))@
                                                       (y - (lineWidth * 2)).
					 pen goto: (x - (lineWidth * 2))@
                                                       (y - (lineWidth * 2)).
					 pen place: x@y.].
	(dp >= 0) ifTrue: [pen color: colorPositive]
			 ifFalse: [pen color: colorNegative].
	x := x + pointSpace.]

Of course, all this stuff, the meat of the sparkline-generation, is wrapped up in a message called drawPlot. The message belongs to SparkLinePlot, a class that provides storage for variables and some convenience messages.

The point of having a SparkLinePlot class is that you can be both succinct:

plot := SparkLinePlot newWithData #(1 2 3 4 3 2 1 4 4).
plot drawPlot.

plot := SparkLinePlot newWithData #(1 2 3 4 3 2 1 4 4).
plot height: 10; negativeColor: Color black; lineWidth: 2; pointSpace: 20.
plot drawPlot.

One final note: These sparklines are created “in the world”: they just pop into being in the Squeak window alongside your code. However, you can drag them around and stuff, and if you right-click on them, you can export them into various image formats including JPEG and PNG.

class SourceCode
    attr_accessor :sexiness
    def make_pretty(are_you_sure)
        if are_you_sure == 'yes'
            self.sexiness += 99999
        end
    end
end

Also, I ran into a problem: I say that if you don’t like the site design, you should subscribe to my RSS feed. However, it turns out that I didn’t like the site design. Since I have to look at it a lot, I changed it! Sorry!

Yes (both different and easier). Well…the parser was easier, anyways. I made my own subclass of the SAXHandler class, and gave it a message for collecting data from each element:

startElement: elementName attributeList: attributeList
(elementName = 'row')
ifTrue: [self saveAttributes: attributeList]
ifFalse: [Transcript show: 'Parsed "', elementName, '" is not a  element. Skipping.'; cr

Then, I defined a saveAttributes message (so I don’t have to rewrite too much if I want to find different data later). I started out simply getting the reputations from all the people and putting them in a Bag: a dictionary that keeps a counter for each different item in it (so, if there are 5 1s, the bag would have a key “1″ and value “5″):

saveAttributes: attributeList
"This method should be edited to provide proper searching for the desired attributes."
| foundData |
foundData := (attributeList at: 'Reputation') asNumber.
self data add: foundData.

Note that “data” is a reference to an instance variable that was created as a Bag when an instance of the class is created. I took a while trying to figure out how to get this thing to actually return the bag so I could do stuff with it, and finally ended up rewriting the SAXHandler’s message parseDocumentFromFile: (I named it the much shorter parseFile:). I rewrote it so that it created the SAX driver and handler and started the parsing all in one function, and gave it a return statement, returning the data instance variable.

parseFile: fileName
   | stream driver parser |
   stream := FileDirectory default readOnlyFileNamed: fileName.
   driver := SAXDriver on: stream.
   driver validating: true.
   parser := self new driver: driver.
   parser useNamespaces: false.
   parser startDocument.
   parser parseDocument.
   ^ parser data

aBag := StackOverflowParser parseFile: 'C:/dir/subdir/file.xml'.

Squeak reminds me a lot of Ruby, although the syntax is quite different. Both languages are (extremely and completely) object-oriented, both languages have a lot of high-level commands (Squeak has more) and both languages make use of blocks (do…end in ruby, [...] in Squeak). Here are some standard expressions in Squeak and Ruby:

Object method: [block].

Object.method {block}

#(1 2 3 4 5) do [ :n | Transcript show: (n * n); cr ].

[1, 2, 3, 4, 5].each do |n| puts(n*n) end

However, Squeak has some interesting components that I don’t think Ruby has (If it does, it’s hidden from the programmer). For example, conditionals are actually messages (the equivalent of methods) to the Boolean class. If the object that they are called on returns the right boolean value (true or false), the conditionals execute the contents of a block. Example:

(2 > 1) ifTrue: [Transcript show: 'Trueness!'].

(2 > 1) ifFalse: [Transcript show: 'I hope to God this never happens'] ifTrue: [Transcript show: 'Whew, math still works!'].

Also, the periods at the end of the Squeak expressions are not accidental! Squeak ends expressions with “.” rather than “;”. Squeak doesn’t just generate variables like Ruby does, so you can’t go: “x = 1″ out of the blue. However, Squeak does let you declare temporary variables in a succinct and unusual way:

| x y |
x := 1
y := 2

Anyways, that stuff isn’t even the weirdest or most interesting aspects of Squeak, but it’s simple to explain, so there you go. Squeak is weird, sure, and the development environment might at first seem irritating (why can’t I write everything in one file with my favorite text editor?) but quickly becomes one of the most awesome things about Squeak as you get to know it. Give it a try, it’s pretty cool.

Clojure is a functional programming language. What does that mean? It means that, like Haskell (for example), Clojure has immutable data structures. You can make a list or a vector or whatever, but you can’t change it later, only make another one. This raises lots of questions for people coming from an imperative programming background (C, C++, Ruby, Python, etc.): Wait! You mean I can’t change variables? How do I do my FOR loops? The problem with this thinking is that you can’t do your FOR loops. However, anything you could accomplish with those, you can still accomplish in a different way. Another major aspect of a functional programming languages are first-class functions, meaning that functions can be treated just like data. You can pass a function to a function as an argument with nary a whistle (And you will, believe me!)

Anyways, let’s talk about how a functional program looks. Generally, you define a bunch of functions, and then you use them in your main function that runs when the program is executed. In Clojure, you don’t really need a main function; just like in an imperative language, anything that isn’t a definition is just run right off, and the compiler just works its way down the file…but you should pretend that this doesn’t happen! Define as much as you can in functions, and then have a single, main function that executes your program. It’s the Functional Way. (If you must muck around with multiple-function mainloops, I suppose it won’t make stuff explode). Here’s an example:
(defn read-data-from-file [file]
... ) ; returns the data that was read from the file.
(defn write-data-to-file [data, file]
... ) ; returns...a 0, I guess. Doesn't much matter.
(defn mess-around-with-data [data]
... ) ; returns the altered data
(write-data-to-file (mess-around-with-data (read-data-from-file "/home/lolcats"))) ;Main function (not wrapped in a defun)


This method of programming may look odd, or seem unmaintainable (You end up with one big function, I mean, geez. Big functions are bad) but in reality this sort of code is even more maintainable than imperative code. In fact, this is a major selling point of functional languages. I’m not going to push you too hard, though. If you don’t want to program functionally, then just don’t (or start practicing in a language that supports functional and imperative paradigms, like Common Lisp…or Perl). After all, it will only make you a better programmer and make concurrent programming simpler.

In future episodes of FPiC, I will describe some fun functions and tricks for functional programming. Don’t touch that–wait. The internet doesn’t have dials.

To help me manage this rating system, I did what any sane person would do: I made a spreadsheet. I currently have point measures for movie length, IMDb rating, and awards earned (Grammy, Oscar, and Golden Globe only!) I also assign bonus points based on genre, director, and actor. The way I’m exporting the spreadsheet doesn’t seem to let you view the formulas used, so I listed them next to the–well, you should just look at the spreadsheet.

In case you don’t, the biggest modifier is the movie’s IMDb rating, which is calculated by (rating – 5) * 15. Thus, it actually gives negative points if the movie is rated below 5! Harsh. I find ratings to be the biggest indicators of how good a movie is, so if a movie has a good IMDb rating (8.5 or more, say) it can get upwards of 50 points from the IMDb rating alone.

It currently seems to work well for movies at the high end of the spectrum (Inglorious Basterds, The Godfather), but for movies that are out of my usual action-adventure zone (such as Up in the Air) are rated too low, because I assign negative scores to Romance and Comedy categories. Maybe I’ll just have to find out about those types of movies myself.

I also plan on incorporating a Bayes classifier to add or subtract points to my rating based on what it finds…but that’s pretty far into the future.