Jes' Codex

Don't use the stock ruby on Mac OS X

Thu, 07 Feb 2013 18:23:00 -0500

Math doesn’t work correctly:

> 212227119877294391 * 86400

=> 359548130941076096

On non-broken rubies:

> 212227119877294391 * 86400

=> 18336423157398235382400

(This has something to do with Fixnums that are larger than 32 bits failing to jump to Bignums correctly. I do not know whether it affects other 64bit versions of ruby)

wooo

Fri, 10 Feb 2012 19:27:45 -0500

wooo

clojure first impression

Fri, 18 Nov 2011 17:24:00 -0500

I realized that I’ll never be able to finish inventing a programming language if I don’t learn a LISP first.

So I’ve been playing with Project Euler with a Clojure repl, and … well, it’s not ruby and it’s not Haskell.

But it has a lot of lazy data structures, so I decided to pretend I was writing Haskell anyway and see what happens.

Here’s a Haskell-ish way to generate the fibonacci numbers:

let fib = 1 : 1 : (map (uncurry (+)) (zip (drop 1 fib) fib))

So I decided to port it directly to Clojure. It wouldn’t be possible to do in a language that didn’t have lazy sequences, but I was able to do it in Clojure pretty straightforwardly. Here’s a before-and-after, so you can see how the two definitions relate:

 let  fib    =            1:1 : (map (uncurry      (+)) ( zip                     (drop 1  fib )  fib    ) )
(defn fib [] ( lazy-cat [ 1 1 ] (map (partial apply + ) ( partition 2 (interleave (drop 1 (fib)) (fib) ) ) ) ) )

Gosh, you know, after a while you don’t even see those parentheses.

Let’s see how it works!

Here’s Haskell, for reference:

Prelude> take 30 fib [1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040]

And the Clojure:

user=> (take 30 (fib)) java.lang.OutOfMemoryError: Java heap space (1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393

Well, there you have it.

In which I brainstorm about my first 3D fabbing project

Wed, 27 Apr 2011 02:25:00 -0400

OK, so (for @keystricken’s birthday, [hi, Mon!]) I made a thing (with the help of Shapeways’s Selective Laser Sintering machine)

Which is really just a physical projection of a 3D model I made in CAD:

which was really challenging since I had never really used 3D CAD before at all.

after some flailing about, I came up with a process that looked like this:

Draw something on paper
Scan it in
Use The GIMP’s filters and levels a to turn it into a monochrome (like seriously just black and white, not greyscale) image.
Use Inkscape’s “Trace Bitmap” command to turn the drawings into SVG vector graphics
Import the SVG into FreeCAD “as geometry”
Notice that FreeCAD has mysteriously failed to correctly understand some of the shapes
curse, reopen the SVG in Inkscape, stare at the control points of the paths until I notice that there’s two points on the same pixel (don’t ask me how I can see that), delete one, and save again
Import the SVG into FreeCAD “as geometry”
Extrude the geometry into solids
Notice that FreeCAD has failed to understand that white shapes inside of black shapes are actually “holes”
Use the FreeCAD “Boolean Difference” function to generate new solids that are black shapes with the white shapes subtracted … one pair at a time.
Get confused as hell, and try to backtrack even though “Undo” always seems to be disabled
Cut and paste these solids into the main document
Using my high-school algebra, figure out what angle to rotate the solids to
Notice that every pasted object seems to have a new and different understanding of where the point 0,0,0 is, so that math on the coordinates is meaningless.
Try to use the mouse to move a shape: either mysteriously fling an object way, way outside the visible scope of the document, or accidentally hit “ESC” while dragging the object (which is not ‘cancel’ like my muscle memory suggests, but rather “please crash the program”)
Give up on the mouse and painstakingly, manually move each object into an X/Y/Z coordinate triple using the numeric entry boxes that puts it into a place that doesn’t look completely wrong.
(Eventually) export the CAD model as VRML
Try to open the VRML file in Meshworks
Meshwork says it’s not VRML! Run `file` on the file
Realize that FreeCAD helpfully gzips files, sometimes, without warning.
gunzip the file
Open the VRML file in Meshworks
drag it around in Meshworks, and marvel at how it’s both easier to manipulate and harder to see details on, compared to FreeCAD
Export the model to STL
Upload the STL file to Shapeways
Wait for an automated email
Holy crap it worked.
Give Shapeways some money
Wait a couple weeks

I think I can probably do better in the future. It seems like it should be possible to make a toolchain that does (image)->Trace->Extrude->Rotate->Translate->Export without human intervention.

If I had that, I’d actually work on writing a program that solved the interesting parts of the sundial (most of which I solved on paper for this prototype)

Solar noon is always north/up, but what clock time that is locally depends on how far east or west you are from the central meridian of your time zone. The clock dial is rotated by a number of degrees that’s your time zone’s central longitude minus your actual longitude.
In order to have evenly spaced shadows for each hour (see Equatorial Sundial), the dial should be inclined to an angle that’s 90 degrees minus your longitude. That means that your lower gnomon (which doubles as the support) should be at a length that can be calculated using trigonometry (uh, the cotangent of your latitude times the radius of the dial, I think)
The top dial is your “summer” dial and the lower dial is your “winter” dial. A nice cheat is to have the top dial already offset by 15 degrees so that it is set to Daylight Savings Time
The lower dial runs counter-clockwise. In this prototype, I cheated and just mirrored the lower dial. Mirrored Roman Numerals are actually sort of evil, though, since IV becomes VI, etc.

A* is easy.

Mon, 28 Mar 2011 14:53:00 -0400

I’ve been trying to learn some old-school algorithms; the sort of things that CS people study but rarely come up at programming gigs.

The thing is, descriptions of algorithms online tend to suck. and open source implementations of textbook algorithms tend to suck.

So, I’m going to try to improve the situation. So, here’s my first attempt. A* algorithm in simple readable ruby: https://github.com/jes5199/astar/blob/master/astar.rb

ruby String += considered harmful

Tue, 08 Feb 2011 13:53:00 -0500

In real code, we found a very, very slow loop. Changing two characters:

+= is about 100 seconds.
<< is around 1/3 of a second.

Using += on a string creates a copy and then discards the original, while << allows the ruby interpreter to intelligently resize the buffer.

The only gotcha is that << will mutate your string object, which means that it’s not safe to use on a method’s parameters. #dup those strings, if you need to append to them.

"organizations which design systems are constrained to produce designs which are copies of the..."

Thu, 23 Dec 2010 15:08:52 -0500

“organizations which design systems are constrained to produce designs which are copies of the communication structures of these organizations.”

- http://en.wikipedia.org/wiki/Conway%27s_Law

Full_disclosure#History

Thu, 25 Nov 2010 18:57:00 -0500

Rogues are very keen in their profession, and know already much more than we can teach them respecting their several kinds of roguery.

I love everything about this internet artifact I’ve found: http://en.wikipedia.org/wiki/Full_disclosure#History . Actually, I want you to have today’s snapshot of the wikipedia article - I suspect that eventually this page will get cleaned up into an encyclopedia article, and it’s just too nice as work of (oh, I don’t know) postmodern literature? cyberspace effluvia? bird cage lining?

re-open source development

Tue, 14 Sep 2010 17:51:18 -0400

————— Forwarded message —————
From: Markus Roberts <markus@puppetlabs.com>
Date: Tue, Sep 14, 2010 at 1:57 PM
Subject: [Puppet-dev] Oops
To: puppet-dev <puppet-dev@googlegroups.com>

Funny story: as the number of developers working on Puppet and related projects at PuppetLabs has increased, the average distance between them has dropped geometrically*, to the point that if we want to discuss something we’re working on with someone, we can (in many cases literally) reach out and tap a fellow developer on the shoulder. This is great for us but it has had an unfortunate unintended consequence: we’ve been doing more and more face-to-face discussions and less and less on this list.

Oops.

This wasn’t intentional and (though it seems blindingly obvious in hindsight) wasn’t expected either. It was, as one five year old put it, a blundersight.

So we’re going to try something we hope will fix things; office chat is still going to go on as normal — we’ll spare you our debates about whether we should try having lunch at the place with the cult videos on all the TVs again or who’s going to show the new developer the ropes — but if anyone starts to have a substantive discussion about Puppet & friends we’ll cut them off and tell them to tell it to the list.

That means that when we’re kicking around ideas you’ll get to see them and put in your two cents worth on equal footing with the developers in the office (since we really do want your input). It also means that you’ll get to see some ideas that never go anywhere, and crazy things that are (mercifully) shot down in their first few hours. But then you’ll also get to see the direction of our thinking long before some of it results in a line of code, and help us shape it before anything is settled.

Hopefully, it’ll be just like the old days.

— PuppetLab Developer Team:

    Luke Kanies
    Markus Roberts
    Rein Henrichs
    Jesse Wolfe
    Igal Koshevoy
    Matt Robinson
    Nick Lewis
    Paul Berry
    Jacob Helwig

* Actually, it’s probably something like k*(sqrt(s^2/n)-r) for n developers of mean radius r in a s x s office, with k some constant around 3.

ICFP composability

Sun, 04 Jul 2010 15:06:11 -0400

I participated in the 2010 ICFP programming contest a couple weeks ago, and my team (“vorpal”) did the best of any team I’ve been on yet: 16th place.

While I’m waiting for teammate Paul Berry to write a detailed retelling of our progress, it occurred to me that I want to share the most elegant function I’ve written in a long time:

type Fuel = [[[Integer]]]

parseFuel :: String -> (Fuel, String) parseFuel = parseTritList $ parseTritList $ parseTritList $ parseIntSchemeTwo

where I was taking a string of trinary digits and creating a “Fuel”, which turned out to be, in the context of the puzzle, a list of lists of lists of integers.

It helps that the ICFP’s serialization format was elegantly recursive, but I can’t help but have the feeling that Haskell functions are composable in a way that other languages aren’t. Which is frustrating, because generally I don’t want to be writing Haskell, there’s just occasional moments like this where it’s a perfect fit.

In traditional haskell style, I’ll give you the type signature of the component functions, and leave the implementation as an exercise for the reader:

parseIntSchemeTwo :: String -> (Integer, String) parseTritList :: (String -> (a, String)) -> String -> ([a], String)

make vim stupider

Tue, 29 Jun 2010 17:52:00 -0400

I get frustrated when vim is too smart, especially when it reindents things without me asking.

This is a minimal, dumb indent system that I might be happy with. We’ll see.

function! SimpleIndent()
    return indent(prevnonblank(v:lnum-1))
endfunction

function! MyO()
    let line = line(".")
    let i = indent(nextnonblank(line))
    call append(line-1, repeat(" ", i))
    call cursor(line, i) 
endfunction

map O :call MyO()<CR>a

filetype indent off
set indentexpr=SimpleIndent()

I always forget to add the "sign-off" line to my git commits

Mon, 17 May 2010 19:11:09 -0400

export EDITOR=cat

while git rebase —continue ; do git commit —amend -s ; done

git-git

Fri, 09 Apr 2010 13:12:10 -0400

I’ve just created a new command for git, called git. It only does one thing: it calls git.

So, if you need to fetch changes, instead of typing:

git fetch

Now you can type:

git git fetch

It even works recursively:

git git git git git git git git git fetch

git-git is available on my github at http://github.com/jes5199/git-git

Does Google Make Us Stupid?

Mon, 22 Feb 2010 16:38:44 -0500

No.

(observation)

Wed, 10 Feb 2010 13:49:00 -0500

Sysadmins and programmers have less in common than I realized.

"So we’ve already reduced the code to the two hardest problems left in computer science: naming..."

Tue, 02 Feb 2010 15:41:15 -0500

“So we’ve already reduced the code to the two hardest problems left in computer science: naming conventions and cache invalidation”

uploading to flickr with ruby

Tue, 26 Jan 2010 16:44:24 -0500

there’s been some serious bit rot in the flickr API libs for ruby.
flickr is still suggesting this list of broken, abandoned libraries:

I found some random old blog posts about flickr_fu, and it seemed more OK but still unfinished, and still abandoned.

But I’ve found that some good people have forked the project on github, and they have a version that’s in good shape: http://github.com/seboslaw/flickr_fu is the version that seems freshest today, but there’s several other active branches in the network (I can’t tell to what degree they’re collaborating)

github means opensource sucks less.

on Parsing Expression Grammars

Sat, 09 Jan 2010 20:27:00 -0500

Co-worker Markus Roberts wrote:

PEGs are, to my way of thinking, a beautiful sweet spot in grammar space, a worthy peer of limited-lookahead and regular expressions, but like these they cover a specific range of the problem space very well, if you take them on their own terms, and will fight you every step of the way if you don’t. Trying to use a regular expression as if it was a broken way of writing context free grammars, or using BNF to write a regular expression would get you into the same sort of problems.

Well, I’m on the bandwagon for this way of thinking; watching the glowing community response to PEGs in both the functional-programming and the post-smalltalk camps has convinced me that it’s clearly filling a need.
One one hand, it’s pretty clear that I, personally, haven’t quite gotten a handle on what the right way to use this tool is, yet. For example: the very notion of replacing our lexer+RACC with Treetop assumes that it’s a drop-in replacement for a lexer+parser.
On the other hand, even without really understanding what I was doing, I’ve been able to make the PEG do what I wanted (and parse almost all of the puppet language) without bothering to actually learn the idioms or the theory*, and the failure modes generally haven’t been very mysterious. (* for example, I’m extremely confused about when it backtracks and when it doesn’t, but that hasn’t stopped me)
On the third hand, every PEG system I see implements almost exactly the same functionality. That suggests to me that there hasn’t been much evolution in the design; there may be still be easy hacks that dramatically improve usability. I want to try to think of these while I’m still a naive user; once I understand the nuances, I might stop being aware of the pain points.