I truly believe nearly everyone realizes that it is impossible to experience all or nearly all of what is important to cultivate in one lifetime.

Beyond that, perception tends to be affected by one's age. When I was young (e.g., in my 20s), all the possibilities of the world seemed open to me and it was just going to be a question of what I would do first - I put everything else into the category "I'll get to that when I have time." I had done a lot to develop my talents and knowledge base, and in a range of areas to boot. But my reading of the "great works" trailed off following college. Time was too limited to get to most of them. But, some day, yes, I would do so. I had never learned to play an instrument. But, when I had time, I would learn piano. I had limited time to do non-business travel, but some day I would make it up.

Of course, "some day" one day comes and you quickly realize that many unrealized hopes and dreams would never in fact be realized. And that includes becoming cultivated in a range of areas. When this fact first strikes you, it truly is depressing. For me, it was the first time in my life that I started to feel "old" (feeling old is not so much chronological as it is a state of mind). You become overwhelmed with the fact that you will never keep up with all the new trends and you will never have the time to fill all the holes in your knowledge base or to do all the things you dreamed of doing.

In time, though, I came to make peace with this sense of restlessness. Life is too short to do everything but life is more than ample enough to do important things, things that count beyond the mundane routines of daily existence. This life is but a breath or, as my 100-year-old grandmother said shortly before she passed on, everything that she had experienced to that point was "but a blink." When you can get to that stage and say, "no regrets" for a life well-led, you can have peace with your finite capacities and your finite existence in this world. There is much that is beautiful to do in this life. You don't need to do it all. You just need to do it well.

The issue is not single-pass vs multi-pass. It is instead, what constitutes a compilation unit, i.e., a pass over what?

Clojure, like many Lisps before it, does not have a strong notion of a compilation unit. Lisps were designed to receive a set of interactions/forms via a REPL, not to compile files/modules/programs etc. This means you can build up a Lisp program interactively in very small pieces, switching between namespaces as you go, etc. It is a very valuable part of the Lisp programming experience. It implies that you can stream fragments of Lisp programs as small as a single form over sockets, and have them be compiled and evaluated as they arrive. It implies that you can define a macro and immediately have the compiler incorporate it in the compilation of the next form, or evaluate some small section of an otherwise broken file. Etc, etc. That "joke from the 1980's" still has legs, and can enable things large-unit/multi-unit compilers cannot. FWIW, Clojure's compiler is two-pass, but the units are tiny (top-level forms).

What Yegge is really asking for is multi-unit (and larger unit) compilation for circular reference, whereby one unit can refer to another, and vice versa, and the compilation of both units will leave hanging some references that can only be resolved after consideration of the other, and tying things together in a subsequent 'pass'. What would constitute such a unit in Clojure? Should Clojure start requiring files and defining semantics for them? (it does not now)

Forward reference need not require multi-pass nor compilation units. Common Lisp allows references to undeclared and undefined things, and generates runtime errors should they not be defined by then. Clojure could have taken the same approach. The tradeoffs with that are as follows:

1) less help at compilation time 2) interning clashes

While #1 is arguably the fundamental dynamic language tradeoff, there is no doubt that this checking is convenient and useful. Clojure supports 'declare' so you are not forced to define your functions in any particular order.

#2 is the devil in the details. Clojure, like Common Lisp, is designed to be compiled, and does not in general look things up by name at runtime. (You can of course design fast languages that look things up, as do good Smalltalk implementations, but remember these languages focus on dealing with dictionary-carrying objects, Lisps do not). So, both Clojure and CL reify names into things whose addresses can be bound in the compiled code (symbols for CL, vars for Clojure). These reified things are 'interned', such that any reference to the same name refers to the same object, and thus compilation can proceed referring to things whose values are not yet defined.

But, what should happen here, when the compiler has never before seen bar?

    (defn foo [] (bar))

or in CL:

    (defun foo () (bar))

CL happily compiles it, and if bar is never defined, a runtime error will occur. Ok, but, what reified thing (symbol) did it use for bar during compilation? The symbol it interned when the form was read. So, what happens when you get the runtime error and realize that bar is defined in another package you forgot to import. You try to import other-package and, BAM!, another error - conflict, other-package:bar conflicts with read-in-package:bar. Then you go learn about uninterning.

In Clojure, the form doesn't compile, you get a message, and no var is interned for bar. You require other-namespace and continue.

I vastly prefer this experience, and so made these tradeoffs. Many other benefits came about from using a non-interning reader, and interning only on definition/declaration. I'm not inclined to give them up, nor the benefits mentioned earlier, in order to support circular reference.

Rich

If you have a public facing server then this can be had for free:

  ssh -nNT -R 8080:localhost:3000 myserver.com

Et voilà, myserver.com:8080 now points to localhost:3000.

Of course you put it in there!

Try something like "Created X-PHP app in 2001. With one million downloads, X-PHP powers [large_number] sites as tracked by netcraft. (link here)"

You can't leave something like that out, it's an impressive accomplishment and ignoring it due to some PHP sensitivity is a bad idea.

The one and only purpose of a resume is to catch the eye of a reviewer and thus score you an interview. Once they see that you've published a 1M-download app and call you in for an interview then you can tell them what you've learned in the past ten years.

Think of it in terms of conversion rates. Some small percentage of resume readers are going to request an interview. Some smaller percentage of those are going to make an offer. You don't want to self-select your way out of that first pool.

Edit: I have old projects on my github that are ugly too. I put my misgivings in the readme. "This was written 5 years ago, it could stand to be modernized, the interesting parts are here (link)."

When I see new projects and ideas that take off, my response is usually a curmudgeonly observation about how stupid and pointless it is or how it's so obvious and trivial that I can't believe anyone would waste their time making it.

This is not one of those. This is one of those cases where I'm not a bit jealous because something so obvious or inane or dumb took off and became Twitter, but because it's just so damn fantastic. This is one of those things that is so elegant and smart that it makes me feel like a complete idiot.

This is going to do very well.

You are supposed to hate your code.

If you don't hate it, you aren't trying hard enough.

I would not equate hating the code with the code being something to be ashamed of.

I hate every goddamn piece of code I write.