aperiodic

I've never seen it before, but it appears to be inflation notation. It's a subscript on prices, so the year is the original year of the price, and the cost above it is the inflation-adjusted equivalent in present-day dollars.

I've actually been thinking of moving to Atlanta recently. I live in Portland OR right now, so the sprawl of Atlanta scares me, but I've heard there are good walkable pockets of it.

I walk my dog 2 hours a day; are there places where the sidewalk density is high enough and the busy road density low enough that I could do that and have some route optionality so I'm not just doing the same walk all the time?

Send me an email at dlp@aperiodic.org

Yes. I was at Puppet (nee Puppet Labs) for four years, one of the larger Clojure shops to my knowledge (not that I've been keeping close tabs on who's picked it up recently).

I switched jobs and language choice was not my #1 criterion. A very interesting opportunity that aligned well with my values (and paid better to boot), but was in a completely different tech stack (Python DS ecosystem, with some Scala). I love the language, think it's wonderfully concise yet expressive way to think about code, runs on a great platform for the web, and is a great fit for when team size exceeds codebase size (though not so much the other way around). All my fun software projects are still in Clojure or Clojurescript; I just wrote some today to scrape doggy listings.

In my experience -- I was a professional Clojure developer for 6 years (until 2018), and hung out in the #clojure IRC channel on freenode a lot between 2011 and 2014 -- the Clojure community tends to be very experienced. Clojure is not many people's first language, but tends to be a language you find your way to after dissatisfaction with other languages, or exposure to other lisps.

I'm sure you can find crappy or charlatan Clojure devs, but I was generally impressed with the Clojure devs I met in #clojure or at the cons. Overall I found the community to have high levels of both knowledge/experience and patience in explaining things thoroughly and precisely to people who were asking questions.

I played the heck out of Magic in middle school and ended up with a perfect SAT Verbal.

This is just one of the reasons why Limited (building a 40 card deck from only packs that you and your group open) is clearly the best way to play Magic. Another: even though it seems more variance-prone, it's arguable the most skill-testing format in the game.

Somewhat related, Leslie Valiant believes that if evolution performs a random search in genome space, it is computationally impossible for it to have led to the complexity that it's produced in only a few billion years.

He's written a fascinating paper exploring what other algorithms besides random search could perform the computational task required and are also biologically plausible: https://dash.harvard.edu/bitstream/handle/1/2643031/valiant_...

Curiously, the language's features for doing runtime checks as a user--core.spec and pre & post conditions--are both very easy to completely disable for production. I don't know why they're not used in core: probably a combination of the core team's feeling that they don't need them, and not wanting to make the language slower than necessary by default.

In this respect, they share the characteristic of being easy to wholly disable (i.e. prevent them from being compiled at all). With pre & post conditions if the var `clojure.core/assert` is bound to false, then they're elided. The usual pattern is to have them on for testing, and disable when compiling for production.

Well, you can easily do this with a native app that relies on content from your servers (e.g. dropbox).

How do web-apps help lock-in? Because you can force users to update?

It's a great example of worse is better in action: a technically inferior platform winning out because it's better at one or two things that enable virality, which is the only thing that matters when all the money is looking for high growth.

In this case, it's that webapps require zero effort and time from the user to get started with, and allow developers to get the closest to the "write once, run anywhere" dream than anything else (if you're doing a decent responsive design, you can even get a good experience on both desktops and phones with much less effort and no gatekeeping), so the development effort is a lot lower.

These two attributes make it really hard for a native app to compete on growth terms with a webapp, since it has a higher hurdle for users, higher initial development costs to target the same amount of users, and higher iteration costs to ship (and get users to install) a new version. It doesn't matter that it's hilariously inefficient; as long as it's just below the threshold where the user tears their hair out, they're not going to jump ship.

I've had good results with a normal crock pot on the high setting overnight.

It is exactly that: Pluto is a very tiny astronomical object. Galaxies, nebulae, and such are much further away than Pluto, but that is more than made up for by how mind-boggingly large they are. For example, The Andromeda Galaxy is about six full moons wide as viewed from Earth[1].

[1] http://www.slate.com/blogs/bad_astronomy/2014/01/01/moon_and...

More constant tweaking:

x * y * (sin((x+time)/5) * cos((y+time)/5)) * 15 + 3000

http://maxbittker.github.io/Mojulo/#IHggKiB5ICogKHNpbigoeCt0...

You can build hexagons really easily out of equilateral triangles, which seems even purere than squares to me.

The logistics of supplies and rescue are a lot easier, sure, but the two environments have more in common with each other than the rest of the surface of this planet. You already need to live in artificial structures that can take a pounding, grow your own food with little from the environment but sunlight and some raw materials, and you can't survive outside for very long without ample protection. I mean, for a training environment, where else would you go?

Also, if you look at the context of the quote, you can see that they're making an analogy:

  Living there [Mars] is comparable to getting by on Antarctica, and provides 
  similar challenges. However, the South Pole now has a number of very advanced,
  large research stations that boast a great deal of modern facilities that provide 
  a good quality of life. These looked very different 50 years ago. The Mars 
  settlement will develop in the same way.

GPS gives you speed relative to the ground, not speed relative to the air, which is what's important for aerodynamics.

Contrary to popular belief, the reason that spacecraft heat up upon re-entry is gas compression, not friction (remember the ideal gas law, PV = nRT). The gas would still be compressed by the electrostatic barrier, so the heating would still occur.

Only if there's an exploitable bug in the Siri client.

The mother of one of my friends works with the Zooniverse[1] project, a citizen science effort. She was saying that one of their biggest problems is how to distribute their data to the public. I naïvely suggested BitTorrent, figuring the sets were in the 10s of gigabytes at most. She laughed and said that that wasn't a great way to distribute terabytes of data every few weeks.

[1] http://www.zooniverse.org/

The real difficult part of explaining this concept to the layperson is getting them to understand what asymptotic complexity is. The example I always use when I explain this to people with little or no math or computer science background is sorting algorithms, explained using the following example of a deck of cards. Everybody's familiar with a deck of cards, and it doesn't take much more math than the most intuitive bits statistics.

Imagine I give you a deck of perfectly shuffled (i.e. uniformly distributed) cards, and decree that you need to find the ace of spades. What you have to do is go through each card one-by-one, and stop when you've found it. You'll have to look at, on average, 26 cards, since there are 52 cards in the deck, and each card has an equal chance of being the ace of spades. Now, let's say I add another 52 cards, this time with a defaced ace of spades, and wanted you to find the original (non-defaced) ace of spades, which is now just one card out of 104. On average, this'll take 52 cards.

Notice that when I double the amount of cards I gave you, the amount of work (that is, looking at cards) you had to do also doubles, meaning that for N cards, the amount of work is N/2. When the amount of work is directly related to the number of cards, excluding dividing or multiplying by a number that does not depend on the number of cards (in this example, dividing by 2), then we simplify things and say that this process for finding the Ace of Spades takes BigO(N) work to finish.

Now, imagine I give you that same deck, and instead of demanding that you find the ace of spades, I require you to sort it out into suits, with the cards in each suit in increasing order. One way to do this is to keep a separate pile for each suit, with that pile in increasing order. Deciding where to put the first card of each suit is easy, you just make a new pile for it. The later cards are not as easy, since you have to go through the pile and find the right place to put the new card.

Right away you can tell that this sorting takes more work from you than finding the ace of spades does. Instead of just looking at each card to see if it's the ace of spades, you first have to check the suit of the card to determine which pile it should go in. Then, you have to look through that pile for the proper place to insert the card. I won't go into the math, but it turns out the best way to sort a deck of cards into piles of suits[1] like this takes N * lgN work, where lgN is a fancy number that isn't constant, but gets bigger when N gets bigger, unlike the division by 2 in the ace of spades example. That means that sorting cards is harder than finding the ace of spades.

This business of determining how hard tasks like sorting cards are is called "analyzing the complexity" of a task. Except, instead of saying task, computer scientists like to say "function." The question of whether or not P = NP is a question about whether a certain kind of tasks called "deterministic Polynomial" tasks (which are referred to by the P) are as hard as another kind of tasks called "Non-deterministic Polynomial" tasks (referred to by the NP).

I have a second part that tries to explain the difference between determinism and non-determinism using a magic deck of cards where we can always draw the card that we want (the "magic" deck is, of course, merely a "non-deterministic" deck), but I've already spend an hour or so writing this first part up. I can post the second part of the explanation tomorrow, if folks are interested.

[1]: This is meant to be a memory constraint. Obviously, radix sort takes linear time too if the key sizes are constant, but has a memory overhead of N. As far as I'm aware–and please correct me if I'm wrong–the fastest sorting algorithms with constant memory overhead are comparison-based sorting algorithms, which take N lgN time. But, even if I am wrong, it's incidental to the main purpose of the explanation.

Yikes, sorry about that.

These are the things I use daily that I find the most useful:

Lots of nice zero-click goodies:

* StackOverflow integration: https://duckduckgo.com/?q=remove+directory+symlink (can also search directly with !so)

* IP Address: http://duckduckgo.com/?q=ip

* Common symbol tables: http://duckduckgo.com/?q=ascii+table http://duckduckgo.com/?q=html+entities

* Wolfram Alpha integration: https://duckduckgo.com/?q=d%28cos%28x^2%29%2F%28e^x%29%29+dx

Disambiguation (great for software with a common word/term as a name), e.g. homebrew: https://duckduckgo.com/?q=homebrew

Favicons in the results. This lets me easily focus in on the sites that I think will be most useful.

Direct search of many programming references with bang-syntax:

* Ruby: http://duckduckgo.com/?q=!ruby+IO

* JQuery: http://duckduckgo.com/?q=!jquery+fadeIn

* Clojure: http://duckduckgo.com/?q=!clojure+deref

There are many more goodies I keep discovering (one nice surprise the other day was that searching for "Community" (a TV show) gave me the air date of the next episode). The best feature of DDG is the extensive integration with domain-specific information sources or search tools that often give me the information I'm looking for with no clicks at all.

These are the things I use daily that I find the most useful:

Lots of nice zero-click goodies: * StackOverflow integration: https://duckduckgo.com/?q=remove+directory+symlink (can also search directly with !so) * IP Address: http://duckduckgo.com/?q=ip * Common symbol tables: http://duckduckgo.com/?q=ascii+table http://duckduckgo.com/?q=html+entities * Wolfram Alpha integration: https://duckduckgo.com/?q=d%28cos%28x^2%29%2F%28e^x%29%29+dx

Disambiguation (great for software with a common word/term as a name), e.g. homebrew: https://duckduckgo.com/?q=homebrew

Favicons in the results. This lets me easily focus in on the sites that I think will be most useful.

Direct search of many programming references with bang-syntax: * Ruby: http://duckduckgo.com/?q=!ruby+IO * JQuery: http://duckduckgo.com/?q=!jquery+fadeIn * Clojure: http://duckduckgo.com/?q=!clojure+deref

There are many more goodies I keep discovering (one nice surprise the other day was that searching for "Community" (a TV show) gave me the air date of the next episode). The best feature of DDG is the extensive integration with domain-specific information sources or search tools that often give me the information I'm looking for with no clicks at all.

Braid is in my top three alongside Ico/Shadow of the Colossus and Civilization IV.

People might have that misconception due to hearing about the Apollo flight and guidance computers, which were pretty janky. They had a really difficult to use interface, and used core-rope memory[1] that was woven together by old ladies.

[1] http://en.wikipedia.org/wiki/Core_rope_memory

HBase. We always want moar data.

I agree. It makes web browsing a Sisyphean task, and I always feel on-edge when I'm reading such a page.

I hope they borrow ambient occlusion. It makes it possible to see the edge of a voxel that's in front of an identically colored voxel, and makes the whole game much easier on the eyes.