partition

I completely agree with your general sentiment. I think everyone who is downvoting you has installed in themselves a despicable world-view: that professional psychiatric support along with medication is a necessary part of having a fulfilling life, for those of us who were unlucky enough to go through hell on earth. It's not getting real results in the real world, or having fulfilling relationships, no, these people are sub-human because of their mental illness, they have to sign up to see a _therapist_. As for all of you disagreers: No, don't support these people, or question how your actions day-to-day might affect the well-being of others! Fully buy into the notion of man as sociopathically selfish and live it to the hilt, as you were well trained to do by school (and startup culture).

I say that "depression" along with "mental illness" are cop-out concepts used to shift the burden off society and onto the individual, by placing blame on some nebulous, bullshit entity.

I believe that the "root causes" of depression are what actually deserve any attention, and they are a combination of genes, society, environment and psychology that has been ingrained by these factors. Depression is like smoke from a fire, and we're currently treating it by installing fans to blow the smoke away.

This has been supported by research psychology about what makes a fulfilling life: a sense of autonomy, mastery, and relatedness. I guarantee you that someone missing even one of these will be "depressed." What do we say then? We don't think about how the environment he's living in is not encouraging these things, and we don't think about specific actions he can take to improve these factors.

No, we just say "Depression!" and tell him to go the therapist. Most people in modern society have eaten this psychiatry bullshit whole and as a consequence are more fit to tend houseplants than to maintain even the shallowest of friends.

So NO, what made the people who went through living hell different wasn't the fucking fake concept that is "depression", it was the SUPPORT.

I say we don't ever talk about depression. The very existence of the word "depression" pushes real societal and individual shortcomings and responsibility off the table.

We talk about what's going right and what's going wrong in the person's life, and if we don't have good advice on how to fix the things that are wrong, at least stop trying to grandstand and signal your social status with some useless platitudes and endlessly repeated refrains about the benefits of therapy and medication.

This looks like just another computer with a lot of cores. What are the physically-based arguments against large advances in speed of _serial_ processors besides the cliched "Moore's Law isn't working anymore" semantic stopsign?

http://matt.might.net/papers/might2009manycorefad-talk.html

Even in the GPS example, it's not a poor choice. What if there are places you decide to visit or not visit, based on the availability of GPS? For example, exploring a new city in your car; if I didn't have my iPhone so I could search interesting locations (where the definition of "interesting" is not up to me) and find directions for them immediately, I probably wouldn't go through the trouble of exploring in a lot of cases. So even with this example, it's already not clear who is "commanding" who.

This touches on an ethical problem that is also briefly mentioned in the book "Programming by Demonstration," which I think restates the problem in the best way:

http://acypher.com/wwid/FrontMatter/index.html#Foreword

"In any case, I think the most important issues regarding end-user programming and its subbranch of programming by example are pedagogical and ethical. There is no question that a human with a goal wants to have the sub-goals ready made and at hand. One shouldn't have to learn about Carnot cycles of internal combustion engines--or even just hand cranking it--in order to drive an automobile. And agents that can be told goals and can go off and solve them have been valuable and sought after for as long as humanity has endured.

On the other hand, it takes a very special value system for children and adults to be able to exist as learning creatures--indeed as humans at all--in the presence of an environment that does all for them. 20th century humans that don't understand the hows and whys of their technologies are not in a position to make judgments and shape futures. At some point it is necessary to understand something about thermodynamics and waiting until then to try to learn it doesn't work. Nature's rule is "use it or lose it"--most social systems that have incorporated intelligent slaves or amanuenses have "lost it". In fact most never gained it to lose. In a technopoly in which we can make just about anything we desire, and almost everything we do can be replaced with vicarious experience, we have to decide to do the activities that make us into actualized humans. We have to decide to exercise, to not eat too much fat and sugar, to learn, to read, to explore, to experiment, to make, to love, to think. In short, to exist.

Difficulties are annoying and we like to remove them. But we have to be careful to only remove the gratuitous ones. As for the others--those whose surmounting makes us grow stronger in mind and body--we have to decide to leave those in and face them."

Yes! So can we stop pretending (through monetary and social credit) that for everything worth developing, it was just one guy acting alone?

I think what might be more problematic is our systemic bias toward attributing the "credit" (monetary and social credit) to any significant work to one person. This just causes pretty much any collaborative work that is not between "pure" friends to devolve into resentment.

I think this has deep roots in American individualistic philosophy, and it's an example of how damaging it can be.

I agree that this is suboptimal. But it's true that you need both business and technical skills to get something out the door competently. And for these engineers and workers, the feeling of fulfillment that they have working for Steve is real and satisfies what I believe to be an actual human need: to feel competent and useful.

I just wish there was some other way to go about things than for, basically, impressionable technical types to be manipulated into doing work for narcissists.

Maybe the problem is, again, education. School generally doesn't prepare you to be a good salesman, which is unfortunate because that's the only kind of skill you need to actually get ahead in the real world.

Here are some points I'd like to discuss:

1. It's clearly not beneficial to "never settle" for everything. Some things you _do_ settle on, hell you settle on them _out of habit_. Other things, like your career or love life, is not so clear. But I believe the "never settle" attitude and everything that comes with it is just useful all by itself, even though you're most likely to end up with a dead end job and die alone or with someone who hates you. Even so, the linked article is a good reminder that it's not enough to "find what you love, then do it"; you have to not be the ~99% of people who either can't find such a thing (not for lack of trying), or be stuck doing it badly. Cal Newport poses "love what you're doing" as an alternative; but is that just consolation for being a slave in whatever system you're working in?

2. Steve Jobs is known for having a personality cult. Many people on this very site have expressed that they are _unusually_ deeply affected by his death, it's kind of scary. I say this as someone who is sad that he died and as someone who uses Apple products on a daily basis. But the hero worship? I think there's something more to this part. I think most people aren't really engaged with their lives and actually despise them. The second the slightest _external_ source of inspiration appears, they're engaged and ready to do their life's work. And this is what Steve Jobs is good at doing, more than anything else: inspiring people to work harder for his company by essentially exploiting basic human psychology about feeling effective and belonging to a community. So does the world really just belong to the people who can get away with the most social manipulation? Or does this system of social manipulators being at the top only work in cultures like in America? I just wish there was some better way of doing things, to be engaged in life but not in service of a _personality_, either directly or indirectly. Or is that the only real point to life that has any behavioral consequences?

3. Steve Jobs was probably the biggest idea man ever. It is possible to categorize people into two groups: those who have the idea and those who do the implementation. Steve Jobs was good at bringing implementors together to build around a certain idea. But, often, implementors feel that they don't get enough credit, either monetarily or socially, for what they do. Yet, from personal experience, I think it's better if possible to be both at the same time. Then you know both the problem and solution in intimate detail, and don't have to deal with people, either manipulating them into doing work for you or feeling resentful at being manipulated. And for the technical side, there are a lot of nice force multipliers in the form of programming languages and libraries. But if everyone wants to be this, then we all end up working alone or with as few people as possible. How does one balance the loneliness of being both the idea guy and implementor against the resentment involved in being just one of them? Or is there some different perspective I haven't considered that isn't feel-good bullshit about the members of a team being "equally" valuable?

Great idea. But what if no one loves you?

To address this, you might be able to automatically generate moral support. You just need to add a 'link to Facebook' feature along with a little machine learning + speech->text->speech algorithms so that the most 'appropriate' message can be generated given the current time and the user's Facebook status.

With enough data to bootstrap the system, we'll probably end up not even needing other people IRL.

This 'article' is very clearly another instance of trollish, uninformed misleading shit designed to sell copies of <author>'s book. The whole piece is pretty much 'Revenge of the Nerds' tripe, containing the usual, trite anti-jock (and, lol, anti-minority) rhetoric combined with facile AP/SAT test-score elitism (I'd have thought HN would be suspicious of arguments that use test scores as a proxy of education quality).

Caltech is in some class by itself, sure, but not for the reasons he cites, which are plain bullshit, and definitely not a completely 'positive' class---there are definite, subtle tradeoffs of a Caltech education that are not highlighted by the rather crude level of discourse this article has encouraged.

Already mentioned and debunked here is the asinine assumption that AP/SAT scores are used as proxy for actual academic excellence by the admissions committee.

http://news.ycombinator.com/item?id=2089717

However this next comment, while probably made on the wrong premises (that the admissions committee uses test scores as the sole criteria), is probably the only assessment of Caltech I've seen that has a hope of getting the real issues that show going to Caltech can be a bad decision if there are other respective alternatives available:

http://news.ycombinator.com/item?id=2090087

"Well, from the article, it sounds like most of the Cal Tech freshmen have already wasted a few years getting ready for the SATs, making straight A grades, and taking AP courses. Sorry, guys, but that's a LOT of work, a good recipe for early 'burn out', and indicative of a lack of seeing reality. What Cal Tech is insisting on looks very much like at least simplistic understanding and likely 'obsession', and a big, HUGE, problem with these two is that they overwhelm rationality and ability to see reality clearly and, net, are from harmful down to debilitating."

Indeed, even though the admissions committee emphasizes the fact that test scores do not completely determine admission, preparing for tests and 'burning out early' is exactly what the majority of applicants end up doing anyway to get into this place. Then Caltech has (and misses) a great opportunity to end up educating people the right way, as you say.

What many people who go to Caltech do is end up learning all the right subjects but the wrong lessons. There is hardly room for introspection, broadening one's perspective, and really learning the why and how of research---there is only the assumption that you are enthusiastic as hell at math/science and you are going to signal this by overloading, taking the hardest classes for no good reason, and trying to impress Head Nerd in <subject of your (their) choice>. This is your life---this is a social group where your self-worth is measured by your GPA and how many papers you publish. Too many people I knew have been sucked in this way and ended up burning out in one way or another.

The end result is that there are no 'jocks' at Caltech in the usual sense---what you have is a similarly wretched, caveman-like hierarchy, but with 'sports' replaced by 'academic achievement.' Surely a different and perhaps more productive contest than what goes on at other colleges, but no less of a harmful environment. Unless you are at or near the top of the hierarchy, the environment has the structural effect (as in, may not be intentionally designed) to beat any previous interest you had in math or science out of you. Could this be an explanation for the high suicide rate at Caltech (and other elite institutions like it)?

Basically: Where was the education? For being a fairly good student who clearly could learn subjects straight from books: how to learn what to learn? To educate yourself in the right way? To see the world for what it is and make independent, informed choices? To be rational?

Hell, this shouldn't be exclusive to Caltech---with the availability of information these days it seems to be a much better payoff to educate people in this alternative way instead.

So, go to Caltech only if you really understand it as just one small step in a longer research career, you know how to be rational and not get taken in by the social hierarchy there, and you are in contact with helpful faculty with whom you know you will have a productive relationship. Or, if you estimate P(Head Nerd) as being really high, so you can start your own little fiefdom.

Full disclosure: I went to Caltech (class of 08) and thankfully am in a good Ph. D program right now where I can 'pick up the pieces,' as it were, and reignite my interests.

I am constantly in conflict about this---would I have done 'better' (for some definition of better) overall if I hadn't gone there, and instead gone to an easier school?

Or do I just remain grateful about my current situation and just stop thinking when I think about this? I am forever indebted to my parents for their sacrifice in paying my Caltech tuition, and I really think there could not be a better place for learning engaging subjects with the brightest people around. All my career opportunities were made possible because I networked in the Caltech community.

But I just think there could have been a much more principled, less psychically costly way of doing it.

This is excellent. Thanks for linking this. I'm still kind of new to PL research and this looks like a ''who's who'' of higher-level PL topics.

Anyone have recommendations on the right books to read, by the way? I'm working through Pierce's Types and Programming Languages along with Purely Functional Data Structures and Pearls of Functional Algorithm Design. I understand the sequel to TaPL covers more modern concepts. Would that be the natural next choice?

I pretty much agree with this.

In fact, when execution can be cast as implementing a computer program, one can be very formal about comparing ideas and execution; they are related the same way theorems and proofs are.

If we use the Curry-Howard isomorphism; the idea is often a type ("Let's make a program that turns X into Y!") (a theorem) and the execution is often a program (a term realizing that type) (the proof).

So it seems that the value of an idea with no execution (which is not a theorem until it has been proved!) would be abstractly the same value as an unproved proposition. Except now, the proof not only says that the proposition is true, but also realizes whatever that proposition denotes, because it's a computer program. In that sense, execution of an idea is worth a lot more than the idea, because it also provides evidence that the idea is not nonsense.

But who to give more credit to? The idea guy or the implementor? Consider that when we change even a little bit of our execution, we are changing the idea , because it will prove something different. In this sense, both the idea and execution are very much in the hands of the 'implementor,' and the 'idea guy' only provides initial inspiration, which by its commonality is pretty much worthless.

Well, or maybe not; there is value in picking the right initial inspiration and perspective. Is that something only really experienced 'veterans', 'masters', 'talented people', and 'gurus' can have, or can it be explicitly trained and taught, so that this nebulous notion of 'having the right perspective' can be as simple and clear-cut as using a cookbook? I think the latter.

What about when execution consists of other, non-programming factors like talking with the right people, or marketing or whatnot? It's certainly harder to formalize, but I wonder what value there is in treating the non-obviously-programming parts of what is viewed as 'execution' as just another kind of programming, but not done with the usual compilers/interpreters.

Would you mind sending some my way too? My specialization is more in applications; in libraries/domain specific languages, particularly ones for AI/statistics applications and functional logic programming.

Email's in my profile.

I'm taken aback by this whole discussion. For all the bashing that goes on in HN about schools being glorified test prep centers and not living up to their potential for educating students, we sure are quick to accept "studies" like this that use test scores as an indicator of intrinsic worth of the educational system in a country.

> I think the escape hatch is that the information conveyed is not the points on the screen, but the rule on how to generate those points. Going back to my other post this means that the city builder conveys no information about a particular city map.

Yep. The amount of information conveyed can be considered 'equivalent' to the length of the shortest algorithm used to get from one string to the other.

The field that is concerned about thinking about this problem in a disciplined manner is algorithmic information theory:

http://en.wikipedia.org/wiki/Algorithmic_information_theory

In particular, they show that the quantity is incomputable (the Komolgorov complexity).

You touch on a very interesting and general concept, and that is the correspondence between lossless compression algorithms and probability distributions, and the subsequent correspondence between probability distributions and procedural generation algorithms.

Consider the first correspondence. Suppose you knew a certain class of strings arose from a probability distribution. Then you can talk about the strings that are most likely to occur, or, more useful in general, about the individual characters that are most likely to occur given a history of previous characters. Using this, you can make a compression algorithm that will map (symbol, probability) or (symbol + history, conditional probability) starting from the highest probability, to the numbers 0, 1, 2 ...

This is arithmetic coding.

http://en.wikipedia.org/wiki/Arithmetic_coding

The result is optimal in terms of expected compressed string length assuming the strings you use this on really do come from that distribution.

Now consider the other way around. Suppose you have a lossless compression algorithm. Find the (uncompressed symbol, compressed symbol) pair (possibly with context) that achieves the highest compression. Assign that a high probability. Then find the next pair. Assign that a slightly lower probability (This can be done in a more principled manner than I'm alluding here). Then you have yourself a probability distribution.

More on data compression theory:

http://en.wikipedia.org/wiki/Data_compression

But what happens once you have a probability distribution over some data type, is that you may cast the problem of automatically generating instance of that data type as sampling from the distribution. Many procedural generation algorithms that give nondeterministic results (and the useful ones do, otherwise the work the modeler has to do is fundamentally the same) can be re-cast as sampling from a probability distribution; look at what the algorithm is generating and learn the distribution.

Note that this is uncomputable in general for the same reason Kolmogorov complexity is. This is known as Solomonoff induction:

http://singinst.org/blog/2007/06/25/solomonoff-induction/

So to answer your original questions:

1. The information (as in information entropy) in the algorithm in the CD is the entropy of the true probability distribution from which your levels originate.

2. And yes, in principle you can use the correspondence between data compression and procedural generation to generate instances of any arbitrary data type, not just 3D game levels. It may be hard to design a probability distribution that will create well-formatted instances though :)

OK, I should check out the ACM article.

It definitely seems like one needs to pare down the interactions with the provider to some bare minimum. Limiting it to single, uncorrelated map-reduce (or even just reduce) steps seems like it would remove a lot of potential for abuse.

But who knows---if service providers tend to take in and operate on more data than clients (especially from multiple clients), it seems there is a fundamental information imbalance, and obfuscating techniques by clients can't possibly do as well as deanonymizing techniques by the provider in the long run.

I wonder if it is the case that fully homomorphic encryption might _increase_ the potential for such information leakage relative to a partial homomorphic encryption; the more algebraic structures for which an encryption function is a homomorphism the more vulnerable it is. If a fully homomorphic encryption captures the +, * operations of a ring, you can exploit two identity elements, one for * and one for +. The next step in 'badness' would then be something like R-modules, where in addition to the ring you have another group (and another operation and identity element).

I have a question about homomorphic encryption and information leakage.

Do I have this right: A homomorphic encryption is a function

    e :: P -> C 

between groups (P, -) and (C, +), where P is the set of plaintext and C is the set of gibberish and -, + are the respective group operations in either space, such that e is a homomorphism in the group theoretic sense?

Because if so, the following basic properties must hold:

    e(id_P) === id_C
    e(inv(p)) === inv(e(p))

Suppose you are a malicious cloud services provider and you are manipulating encrypted data. Couldn't you use these group properties to make much more informed observations about the encrypted data without ever having to decrypt it?

A very simple example: as a malicious cloud services provider, if you see a bunch of gibberish strings x, y1, y2 ... yn, and it turns out that x + y1 == y1, x + y2 == y2, ... x + yn == yn, wouldn't you at least have a sneaking suspicion, that x is the identity element? And in the situation where you could potentially make very damaging (to the other party) decisions based on this information, it would seem to defeat the purpose of homomorphic encryption.

Moreover, recall that the cloud services provider is technically also allowed to run any additional set of calculations using the group operation on the data you give it, not just those you provided. It seems that, in general, even with very unstructured data you could use the properties of homomorphisms to de-anonymize data very easily.

How is this issue addressed?

While programming in Haskell I also struggled with Haskell's brand of whitespace indentation, even though I come from Python. The key difference in usability between Python's whitespace indentation system and Haskell's indentation system is that you cannot start the lines in a block on the same line as the block.

Python's is more restrictive: you must skip a line before starting a multi-line indented block; i.e., this is not legal:

    if a == b: print "asdf"
        print "a"
    else:
        print "a"

This lets you decide on a very simple rule for dealing with whitespace indentation: Each new block is started by inserting a carriage return and the proper number of tabs.

Not so in Haskell, because you are given the freedom to put the first line of a block in the same line as the block starter:

    let x = 1
        y = 2

    do x <- 1
       y <- 2

Now you need to decide whether to be 3 or 4 spaces in depending on whether it is a let or do block. You cannot use the rule, because the appropriate number of spaces is no longer a multiple of your indentation unit.

That's just the simple case, because you are also allowed to put these block starters (let, do, case, etc) at arbitrary points in an expression:

    f = let x = 1 in let y = x + 2 in
     y + 1

This is syntactically correct Haskell; but personally I like the idea of lexical scope being represented by indentation level, which is not reflected here.

It becomes very easy to get yourself into situations where you cannot use the Python rule. But you can also impose restrictions on yourself so you _can_ use that rule. Like always treating let, do, in, etc as "{"'s in C:

    f = let
            x = 1
        in
            let
                y = x + 2
            in
                y + 1

This may look a little verbose. But in real cases there would be a lot more statements there. In the middle of all this I want to maintain the idea "number of tabs corresponds to lexical scope". We can also push the analogy to "{"'s in C and adopt the "K&R" style, but on block-starting expressions:

    f = let
        x = 1 in let
            y = x + 2 in
                y + 1

There's also the solution of editors that just figure out where to indent, in which case we can make it look pretty and still get the indentation right. I think it's best to develop a consistent style that will work across editors though.

I have mixed feelings about this.

On the one hand, the peer review system was designed specifically to keep out the low-quality material that blogs let through for free because of their more inherently democractic nature; I can't be the only one who thinks many people who blog (and even some who appear on HN) are not presenting useful enough or clear enough material to be worth reading by any audience. People's lives are finite and time spent reading published work that is useless detracts from time spent reading useful work that helps in one's own line of inquiry.

Smooth talking bullshitters like Ron Jeffries who promote objectively useless or even counterproductive methods abound, taking bandwidth away from more useful ideas. You need only remind yourself of this exchange:

http://ravimohan.blogspot.com/2007/04/learning-from-sudoku-s...

http://pindancing.blogspot.com/2009/09/sudoku-in-coders-at-w...

It will be sad the day a Ron Jeffries of the academic world wastes as much of other people's time reading his posts.

But has that day come already? On the other hand, it's not like the peer review system is immune to gaming and corruption either. We've got people chopping whatever work they've done into least-publishable-units and objectively good work being ignored because it is not like the other peer-reviewed work out there. And since most people working in a scientific field have not also gone through educating themselves against bullshit techniques (i.e., rationalism), we get plenty of bad papers that only serve to lengthen CVs (An aside: instead of chemistry, physics, computer science or other subjects, I think it is much better for one to begin a scientific education with a course in _rationalism_).

In the meantime, I think a useful course of action would be to just do what sensible people are already doing, which is to throw our hands up with respect to relying on any _system_, be it blogging or peer review, as a channel for useful information and continue to be unbiased about evaluating the usefulness of any communication, disregarding its source. As for blogging your scientific work, sure, go ahead, but I would be as responsible about it as I would a peer-reviewed publication, if not more, simply because of the larger audience. This is not to say that it decreases the set work you can put out in blog form, as another fundamental difference is in how finished the work in a blog versus a paper is. But place ample disclaimers if you do frame it as science.

I think the root problem is really the motivation for blogging or writing papers in the first place. Is it motivation to get fame and money? Or to use these channels at "face value"; that is, as forums in which useful things get posted? I have not come up with a solid, brain-dead algorithm (which is necessary because I am biased as well) that would distinguish between these sources of motivation given a set of postings/papers, but with a little thought perhaps someone can.

Or maybe we shouldn't tie so many extrinsic rewards to blogging/publishing papers. Then the problem would "take care of itself."

While browsing for related source after making my post I found this site:

http://tunes.org/wiki/category_20theory_20101.html

I liked their explanations of algebras and coalgebras.

I thought group theory was the easy part. Indeed, that's pretty much what crypto is based on. Many other security applications in CS also rely on group-theoretic notions. Consider homomorphic encryption; the idea that one can develop an encryption algorithm that allows an untrusted source to work with your sensitive data without discovering your data itself, due to the fact that there exist 'one-way' functions from plaintext to gibberish that actually preserve certain operations you care about; i.e., if

encrypt(x) = x' encrypt(y) = y' encrypt(z) = z'

and x + y = z, homomorphic encryption for (+) gives you that x' + y' = z'.

Farther away from completely direct applications like these are algebraic ways of viewing a CS problem. Consider vectorizing a for loop that does in-place update of a variable with +=. We know that this can be turned into a parallel reduction, where if N is the length of the list over which the for loop is iterating, the parallel reduction will take O(log N) time. But what other operations does it work with? Associative ones? What can we do if it's not associative, or the return type of the in-place update is different? And so on.

That's pretty much the tip of the iceberg when it comes to abstract algebra being used in CS.

Now on to category theory. I'm still very, very new to it, but I've been seeing tons of connections anyway. I figure I can view the higher level of abstractness two different ways; that it's going to be hard and impractical to make any connection to anything concrete; or, that excitingly many things admit a categorical view precisely because of how general the theory is.

Let's start with the category-theoretic notion of functors; functions taking functions to functions. Never going to see these outside of functional programming, right? You've worked with functors if you've ever spent any significant time in a Unix shell.

Here's a nice blog post on the connection:

http://conway.rutgers.edu/~ccshan/wiki/blog/posts/Higher-ord...

Indeed, 'sudo' can be seen as a functor, taking commands (handwavingly, morphisms from the set of user-privilege states to itself) to higher-privileged commands. Let's check the idea with respect to the functor laws. Does sudo <cmd1>; sudo <cmd2> behave the same as sudo cmd3; (where cmd3 is a script that does <cmd1>;<cmd2>). What is sudo sudo cmd? Now think of any Unix command modifier you would care to write. How would it satisfying the functor laws make it an easier command modifier to use?

Also important is the notion of initial objects in the context of proving properties about the behavior of any algorithm on any data structure (including an interpreter, on a programming language!). It generalizes the notion of a 'starting object' in the context of a set of objects related to each other by transformations; like the empty list in the set of lists related by concatenation. What's useful about this? Proving things on structures that do come from initial objects admit easy proofs by induction. Moreover, if you can come up with the proper set + transformations, you can come up with very 'useful' initial objects for whatever you're trying to prove.

More on that here:

http://en.wikipedia.org/wiki/Initial_and_terminal_objects

Discrete math and probability have been done to death as computer science-related topics. You cannot get far in a CS program without learning these topics forward and back. That being said, this book is good as a starting point that collects these topics together; I have not seen a similar book that does the same job.

What's not getting enough attention as "mathematics for computer science" is category theory. Put very roughly: it gives you some very powerful formal patterns that will crop up in every computer science-related thing you do. This includes everything from theoretical computer science to the most 'boring' of dead-end programming jobs. Think of it as software engineering/design patterns without all the informal handwaving and zealotry for/against <latest fad process or design pattern> that it allows.

Category theory, if properly learned with an eye toward application, will make you become utterly ashamed of the programs you write, and the languages you write them in. The end result is a program that still does not match the one in your head built with a much more elegant set of abstractions, but is very clear nonetheless.

http://plato.stanford.edu/entries/category-theory/

I would personally caution against the championing, if not the individual embracing of such an idea. This looks like a 'race to the bottom' to me.

Consider what happens in the long run. Sooner or later people will either catch on or get used to a website always having users or content, no matter how new or actually fake it is.

Some or all of these things may happen:

1. Online communications between 'people,' real or fake, becomes devalued. They are already devalued with the flood of people with bad taste. Of course, one can argue that communication is value in itself; the feeling of connecting. In that case I have a great startup idea; one that makes you talk with chat bots but feels like actually conversing. If you use sophisticated enough text generation techniques and market it to stupid/desperate enough people I seriously think this could work to some extent.

2. You will have to work extra, putting in fake content, just to launch a socially-oriented website. Otherwise it will not get off the ground. I await the day until a website has to send me flowers through the mail in order to grab my attention. Perhaps this is a good thing, because there are already more than enough socially-oriented websites.

But what can we do about it now?

One can take the view that this was a great blog post. Not only because it has named startups that use this approach, so the more principled of us have extra data on which kind of people are honest enough to do business with, but people of varying degrees of honesty have come out in the comments section, some virtually boasting of their 'faking it' techniques. We now have more data; you may now do as you wish with it.

Reflect on the business culture and environment that requires this sort of behavior and make a decision; is this the kind of thing I want to associate myself with?

I'm curious about the general effectiveness of the latest versions of GHC in optimizing single-threaded code. We know of huge gains with the parallelism libraries, but I'm wondering what the consensus is for code that's more inherently sequential.

There are two things I like about paper that make it superior to viewing text on an LCD or CRT (for most forms of text that exist), that unfortunately the article, which is FUD shill from the paper industry, doesn't cover.

1. Ease of annotation and manipulation.

I can mark up text with physical writing implements much more easily than I can with an annotation tool in some document viewer. Personally I find this critical for absorbing material like technical papers and lecture notes. Especially for mathematical notes.

The best electronic-display approximation to this would be a tablet that doubles as a display, such as the Wacom Intuos. The iPad and Kindle are the closest alternatives if it is not important to annotate text. Even then, big sacrifices are made in manipulability.

Probably the best thing about paper is the fact that I can get one piece of paper at much less cost than an iPad or Kindle. It's not just that you can do some task on a single sheet of paper better than you can on the iPad app that tries to replicate that task. It's that the cost difference also applies for N pieces of paper versus N iPads; there are tasks that operate on multiple sheets of paper that are hard to do with the usual solutions that exist today for this, which are window managers. Either window managers need to get a lot better (I've used Windows + WinSplit, xmonad, Divvy and a few other attempts at reigning in the horrible wm in OS X), or there needs to be better hardware for doing so. Multitouch trackpads might be a good starting point.

2. How it interacts with ambient light.

I find that reading text on paper is much easier on the eyes than reading an electronic imitation of it. This is because of how unreadable electronic text is in comparison:

a. Content creators tend toward black text on white backgrounds. This is much higher contrast than you get with black text/white background for paper. The readability of the content is worse the higher the contrast ratio of your display.

b. The rest tend toward a variation of white text on black backgrounds. That is almost as bad.

c. Monitor settings. The monitor's brightness needs to be appropriate for both the amount of ambient light and the content being displayed in particular. There are solutions like Apple's laptop LCD displays that depend on ambient light, but in general the monitor setting is more often the wrong setting than the right one because of (a, b) content being used together frequently + the hassle of adjusting the brightness and ignorance of 'correct' brightness settings in general.

This is where I think there might be an electronic solution; for instance, how about a PDF viewer or display driver hook that remaps the colors of the documents to something more bearable? You can sidestep (a, b) and somewhat mitigate (c) if you say, assume that everyone is using the highest (or default, or as a customizable) setting on their monitors. You already see this with just about every fancy vim/textmate color scheme, and more relevantly, the Inverse scheme of the Readability bookmarklet.

It's worse than the actions of individual students being dishonest.

The fact that someone can do this, for so many students, in so little time, along with the fact that the students themselves have not been called out for the obvious mismatch between what they write and the signals they send out in real life with other students shows that things are fucked in a strong way; if a particular school and student is named as being part of this, it's not just that the student is called out for not doing the work that represents the degree, but that it serves as strong evidence that the particular degree or school is worthless, and the school's accreditation should be called into question. Higher education has truly gone down the toilet.

Something like this has been sorely needed. I'm wondering if it's possible to generalize this over different OSes, if the code itself is multi-platform, or there is some way to specify hints for it (or should there be). I also go to Stanford so would be easy to discuss this in depth if you want.

Those who keep going on and on about parentheses in Lisp should try Haskell, which is basically* Lisp, except everything has one argument and is left associative. This simple rule removes a TON of parens. Add in the $, . operators and a bunch of other potential parentheses are eliminated.

*Except also that Haskell is typed and does not include code quoting/eval. But that's what Template Haskell is for :)