John Cromartie's Tumblr

iTunes 11 creates UI color scheme from album art

Thu, 06 Dec 2012 08:18:00 -0500

This is a really awesome touch in iTunes 11. The effect was so seamless and well-done that it took me this long to notice.

Why I'm not Ditching Instapaper for Pocket

Thu, 04 Oct 2012 16:19:49 -0400

I’ve been using Instapaper since 2010. While I really like the service, I’ve always kept and eye out for worthy replacements.

Pocket is Read It Later after a bit of a rebirth, and is undeniably the sexiest of the boomarklet-based reader apps, with a slick iOS app and a great web interface.

When you sign up for Pocket you get all of the features it has to offer, presumably forever. That sounds great, right?

But that’s actually the biggest thing keeping me from Pocket.

Instapaper is supported by paid users, while Pocket is VC-backed. This means that, purely by definition, Pocket will only be around as long as someone other than users thinks it’s a good idea.

Marco could pull the plug on Instapaper for any reason, but at least he has an actual economic incentive to continue the service (for current and subscriber users) and to improve it (to woo future users).

A Poem for LISPers

Tue, 25 Sep 2012 10:52:41 -0400

MUCH madness is divinest sense
To a discerning eye;
Much sense the starkest madness.
’T is the majority
In this, as all, prevails.
Assent, and you are sane;
Demur,—you ’re straightway dangerous,
And handled with a chain.

By Emily Dickinson.

What's so bad about prefix notation?

Mon, 10 Sep 2012 21:33:00 -0400

One of the common complaints about Lisp is that it forces you to use prefix notation for mathematical expressions. This is a fair complaint, since it’s a pretty big departure from what we learned in Algebra class.

But, exactly how bad is prefix notation, after all? Let’s start with an example:

5 + 6 * 7

When you read this, in English, as “five plus six times seven”, you know exactly what it means assuming you understand the order of operations. It’s totally clear to anybody familiar with basic math.

The equivalent in Lisp would be:

(+ 5 (* 6 7))

If you try to read this like the above infix expression, you get “plus five times six seven”, which doesn’t make much sense. Maybe we can improve on this by changing our reading.

What if, instead, we read it as “the sum of five, and the product of six and seven”. This is more verbose than the simple left-to-right infix reading, but it’s also unambiguous.

Now, let’s say we have a few more symbols in our expression, and we’re using more operations:

(x + y + z + 1) / (b * c * 20)

This is a bit of a tangle compared to our simple expression, but looks a lot like the math you might find in graphics or game code. It’s not bad at all, but I’ll leave the “English” version as an exercise to the reader.

Now Lisp:

(/ (+ x y z 1)
   (* b c 20))

Here, we see that the “operators” in Lisp are actually variadic functions, and eliminate a bunch of infix operators. I’d say this is a win for clarity.

Logic

And what about logic? Most programmers are used to reading logical expression much like algebraic expressions:

if (x < 10 || y > 20) ...

“If x less-than ten, or y greater-than twenty” is nice and clear. The Lisp version doesn’t fare so well:

(or (< x 10) (> y 20))

“Or less-than x ten, greater-than y twenty”.

OK. That sucks.

But what if we alias some of these functions, and rewrite it as:

(either? (ascending? x 10) (descending? y 20))

By phrasing it in the form of predicates, it becomes a bit clearer (I am not suggesting anybody start writing things with aliases like this… it’s just for our example). And, in fact, it might give a hint as the variadic nature of < and > in Lisp. Let’s look at a larger Boolean expression from a curly-brace language:

if (0 < x && x < 10 && 10 < y && y < 20) ...

This expression is already as nicely arranged as it can be, in number-line order. But I wouldn’t recommend trying to read this out (“if zero is less than x, and x is less than ten, and …”). However, in Lisp we can just say:

(< 0 x 10 y 20)

Or, “are zero, x, ten, y, and twenty in ascending order?”. That is much better, and suddenly our code is that much closer to the number line style that infix Boolean expressions strive for.

Is This Just For Lisp?

Of course not! If you are in a language with varargs you can create static methods/functions to implement all of these things. And perhaps you will go ahead and do that now, if these examples have piqued your interest.

But What if We Could Keep Infix After All?

Now, of course, Lisp is nothing if not putty in the hands of programmers. If you find that something fundamental is missing, or you’re inventing something for the first time, then you can just extend the language to do whatever you want.

It turns out that infix notation is just a library in Lisp. Compare this to adding prefix notation to C#, or adding postfix notation to Java.

bcrypt is Not the Answer

Fri, 08 Jun 2012 09:58:00 -0400

bcrypt and other adaptive hash algoritms are a good idea. It’s comforting to know that your password hash time can be scaled up as computing power available for brute force cracking increases.

However, this is an arms race. It’s reasonable to assume that the power available to crack passwords will increase faster than the power available to initially hash passwords. It’s better to just avoid this race if possible.

If bcrypt is widely adopted, and services fail to update bcrypt parameters, then in 10 years those who are still using 2012-CPU-speed-based recommendations will be in exactly the same place as those who use plain SHA1 today: subject to brute force cracking relatively quickly.

What we need is a hashing algorithm that takes 1 second to compute on 2012 hardware, and 1 second on 2022 hardware. The algorithm should be dependent on time passing, rather than time spent computing.

If we could decouple password hash strength from computing power, and instead make it temporally bound, then we’d achieve real password hash security.

There are probably not a lot of good ways to do this, and I’ll leave the details up to people who are way smarter than me. But it seems to me that this is a way to avoid a brute-force-cracking arms race and a colossal waste of computing power in the future.

jQuery plugin for XML namespaces

Thu, 31 May 2012 16:19:32 -0400

If you’ve ever tried parsing RSS or other XML content using jQuery, you know that it’s impossible to select elements with a specific namespace. On top of jQuery’s own selector engine, the browser’s own selector engine is broken in certain cases, too! So, I rolled a quick solution for this in the form of a plugin: $.fn.findNS.

This lets you find, for instance, a <media:description> element, like this:

$(item).findNS("media", "description")

You can find the code in this gist.

Memoized Blocks in Smalltalk

Tue, 15 May 2012 22:17:00 -0400

I came across this post on memoization in Smalltalk by way of James Rober’s blog, but it was lacking in actual code!

So, without delay, I fired up Pharo and whipped up an implementation.

It’s very simple, in typical Smalltalk fashion. It’s just a method of BlockClosure:

memoized
    "returns memoized version of an unary function"
    | cache |
    cache := Dictionary new.
    ^ [ :x | cache at: x ifAbsentPut: [ self value: x ] ]

And it’s used like this:

#(1 2 3 1 2 3) collect: [:x | Transcript show: x asString; cr. x + 1] memoized.

That will only display “1 2 3” once in the Transcript, thanks to memoization, and returns the correct result.

What kind of idiot...

Thu, 19 Apr 2012 20:56:00 -0400

…accidentally buys DDR3-1066 (PC3-8500) when he meant to buy PC3-10600 (DDR3-1333)!?

This is why I am not a “hardware guy”. I have no patience for figuring out some rather obtuse and arcane combinations of numbers and letters that mean the difference between a computer working correctly or not working at all. Oh wait. That sounds like code.

Yahoo! Goes Nuclear

Tue, 13 Mar 2012 13:08:00 -0400

Well, we can say without a doubt that Yahoo! is done now. They are resorting to leveraging patents like this:

This is what anybody developing an ad display system would do. How could any moderately serious site not order ads by their click-through rate or price-per-click? That would be silly to omit, and it’s completely obvious to anybody who has spent any time on the Internet.

What Happened to TileStack?

Mon, 27 Feb 2012 18:00:05 -0500

Every once in a while, a blog post or some article will ignite a HyperCard nostalgia trip among the programming community. Everybody remembers how awesome it was, what was possible with it, and how Apple pulled the plug. Then people start prognosticating on how to build a new and more modern HyperCard, that would be like the original but even more awesome, with features X, Y, and Z, and everybody would love it and be transported back to that magical time again.

Well, I never used TileStack, but it’s gone now. It looks like they tried earnestly to pull it off. Only an insider could offer the real story on why they shut down.

Based on YouTube videos, it looks like TileStack tried to implement HyperCard’s vocabulary of stacks, cards, buttons, fields, scripts, handlers, and functions. They even implemented the HyperTalk programming language, and could even import actual HyperCard stacks.

At the same time, the UI lacks the stripped-down elegance of the original HyperCard, where viewing a card is a no-frills affair, and the card is presented by itself with no fanfare. Editing the card means opening a menu (optionally tearing off a tool palette) and descending, hierarchically, into different levels of detail for the selected element. You go from the card itself, to a button or field’s properties, to the script

TileStack appears to have taken the smartly modal/hierarchical interface of HyperCard and “flattened” it, enshrining modelessness. In HyperCard you open an object’s Info dialog to edit it. In TileStack you simply focus it and use the large dynamic toolbar area above the stack. It is a staggering array of options, where everything is visible all the time, but only a few options are actually available.

Just some thoughts.

This is happening.

Mon, 27 Feb 2012 16:20:00 -0500

This is happening.

Oops! I don't care!

Sat, 25 Feb 2012 18:09:00 -0500

I’ve left a half-finished pre-alpha thingamajig running at http://smarterseating.com for about 6 months now. It’s actually been running in a Clojure REPL in a SSH session since I first started it. That’s a nice testament to how long a Clojure web app can run, but it’s not the point.

It started when a friend wanted to solve this problem for his wife (a school teacher) and I came up with a solution. I thought I’d throw something out there that just worked, and that this would be some kind of magic kick in the entrepreneurial pants, and I would turn it into something that made money. I thought it would be useful for people who need to seat classrooms, wedding receptions, and other things.

But the thing is, I just don’t care. I don’t have any need for it. I don’t think it’s going to make the world a better place. I don’t have intimate domain knowledge here. The market is probably small.

So, yeah. Don’t do that.

I can see two reasons why I would build something I don’t care about:

Someone is paying me lots of money for it.
Someone will pay me lots of money for it.

So I’ll be recycling this Linode box for some other projects.

Why do remote controls still exist?

Fri, 24 Feb 2012 17:00:35 -0500

The post TV Is Broken reminded me of something that I’ve been thinking about for a while. It’s only tangential to the problem of content on TV.

I don’t buy a lot of consumer electronics, but it so happens that I have six devices that can comfortably browse the web from my couch. They are usually within reach when I’m operating the TV or its cohorts (a receiver/amplifier and a PlayStation 3). Many of the things connected to my TV, including the TV itself, are connected to my home network.

So, why do we still have remote controls? Why can’t I control my interconnected devices with a web interface which advertises itself on my WiFi network (via Bonjour, for example), which my iPad can pick up and browse?

Why can’t I coordinate my media sources and my output options from one device without insane ugly hacks (I’m looking at you, Logitech Harmony)?

There’s probably a big opportunity licensing and implementing something like this for TV and set-top/DVR/game devices.

On to level 4!

Fri, 24 Feb 2012 10:56:04 -0500

I have to say I’m a little bit proud of myself for figuring out level 3 on Stripe’s Capture the Flag challenge.

Good luck to everybody out there trying this, too.

Struggles and Success With Cygwin

Sat, 28 Jan 2012 21:50:04 -0500

While PowerShell is a great thing for Windows management, it still has a long way to go to catch up with the sheer flexibility of Bash and the staggering array of tools centered around manipulating simple streams of text.

This post on StackOverflow contains a few great bits from different perspectives: even from the creator of PowerShell itself.

I just wanted to share some of the problems that came up with my attempts to integrate various open-source tools into our Windows-based development environment. Finally I’ll share some tips/observations that led to an enjoyable environment.

Problems

Permissions

Easily the most frustrating part of Cygwin is when it attempts to imitate POSIX permissions on NTFS volumes by manipulating the ACLs. Frankly, Cygwin does a terrible job at this. It only serves to cause massive headaches.

TURN THIS OFF before you do anything else in Cygwin.

You can avoid permissions issues by setting up your NTFS mount points with the “noacl” option. This is easily accomplished by configuring them in fstab with the “noacl” option, like so:

none            /cygdrive       cygdrive        binary,posix=0,user,noacl       0       0

This line will cause Cygwin to simply leave the default Windows permissions alone. They are good enough in 99% of cases, and I’ve found that they are better than what Cygwin does to permissions (it’s not pretty) in nearly 100% of cases.

Forking

This is a problem that can be harder to work around, due to the fact that Windows doesn’t allow easy forking of processes. Cygwin’s version is very slow (by necessity). The maximum forking performance of Cygwin is about 2% of my comparable Mac OS X machine’s speed when executing Bash commands in a loop. Here’s a useful mini-benchmark to see for yourself:

while true; do date; done | uniq -c

One way around this limitation is to use a programming language like Perl or Ruby for scripts that need to iterate over large numbers of files, etc.. Ruby has a very handy standard library with good file handling utilities.

Rebasing

Sometimes, after an update, Cygwin programs are not linked correctly anymore. This is solved with a rebase. This operation will update your Cygwin binaries/libraries to be able to find the right functions in linked libraries (like the all-important cygwin.dll).

Background Tasks

The cygrunsrv tool lets you install any cygwin program (script or .exe) as a Windows service. This is a godsend, as you can easily get useful servers like rsyncd, git --daemon, simple Ruby web servers, or any other background task up and running with little trouble.

Ruby

Arguably the best part of Ruby is the RubyGems packaging system. Many of the best gems, however, require native extensions to be built. While some gems have pre-built Windows binaries, many do not. Cygwin makes this easy by making GCC and many of the dependent libraries available. I’ve never run into a gem that couldn’t be built under Cygwin with anything more than grabbing the right libraries through the package manager.

Jenkins, Cygwin, Windows 7, and permissions

Wed, 21 Dec 2011 11:26:00 -0500

Cygwin is a godsend for controlling your workflow and putting together the sort of tools that keep devops humming along. And Jenkins is a great freeform build tool for managing pretty much any software CI/build process.

But Cygwin and Windows permissions don’t always play nicely, especially when you add intermediary processes like Jenkins to the mix. My build scripts were copying various folders into the Jenkins workspace, among other things. However, the files and directories ended up having all sorts of nasty permissions issues. Certain users (like the ASP.NET app pool identity) could not read files, and overall things looked pretty weird.

So, Icacls to the rescue! Right?

icacls the-dir /reset /T /C /Q
... <snip 5000 lines of Access Denied errors>

I was getting “Access Denied” errors on every file in the directory, even when I made sure to run cmd.exe as Administrator. Icacls was not working to take ownership either, so I tried Takeown. It worked to take ownership where Icacls did not.

takeown /F the-dir /R
icacls the-dir /reset /T /C /Q

All is well now. I hope this might help someone with the same issues.

Things you can't do in Visual Studio

Tue, 20 Dec 2011 13:30:00 -0500

Here’s something you can’t do in Visual Studio: be editing code in one half of a split window, and be having a conversation with the language/framework author in another, with only a few keystrokes, and with the full facilities of the editor at your disposal. Thanks, Emacs. You made my day.

Is Zach Holman trolling us?

Tue, 15 Nov 2011 17:31:00 -0500

spark is over 400 points on HN right now.

Initially, the script didn’t work on OS X. Now I’m not sure what it does work on, but it barely works on my OS X terminal, and it definitely doesn’t work in Cygwin.

It takes a comma-separated list, instead of a standard argument list. So you have to use tr "\n" "," instead of just simple substitution or xargs.

It doesn’t even handle the examples in the README. The earthquake data is made up of floating point numbers, and so you not only lose a good deal of information, but the latest script flat-out chokes on it.

And then there’s the speed. Somehow it’s taking over 2 minutes to run the (incorrect) earthquake sparkline.

Now compare that to a 4-line Ruby version that works correctly, handles positive and negative decimal numbers, works the same anywhere that Ruby runs, and runs hundreds of times faster (and this is Ruby here), and holman tells me “Ruby is for chumps”?

Is he trolling?

R.I.P. John McCarthy

Mon, 24 Oct 2011 20:23:00 -0400

The third major computing figure to die in a month! They say famous people die in threes.

Anyway, I owe my career in software to John McCarthy. My first introduction to programming was through the Apple Logo programming environment in elementary school.

Fast forward many years later, after stumbling along in BASIC, PHP, Java, C#, Ruby, and others. I rediscovered Lisp through Scheme (and The Little Schemer) and Clojure. Little did I realize that Logo was actually a Lisp dialect all along, and while it was the first Lisp REPL I would use, it would certainly not be the last! This return to “the programmable programming language” would dramatically reshape the way I think about programming.

Thanks to John McCarthy for his tremendous contributions to the programming world.

Poor Man's Tuples in Clojure

Fri, 21 Oct 2011 01:10:00 -0400

Hiredman is working on a nice implementation of tuples in Clojure. But, just for fun, I wanted to whip up the absolute minimum viable O(1) tuple possible.

The result is this macro:

(defmacro tuple
  [& xs]
  `(fn [idx#] (case idx# ~@(mapcat list (range (count xs)) xs))))

Try that in Ruby or C# ;)

So, (tuple "foo" 5 :bar) returns a function that takes an index and returns the value at that index in the arguments to tuple, i.e. ((tuple "foo" 5 :bar) 1) returns 5.

The macro compiles to a case form which dispatches in constant time, although it’s not as fast as Hiredman’s implementation, or even Clojure’s native vector.