I love time-wasting hard-to-learn idiosyncrasies. I use the dvorak keyboard, I run in sandals I make myself, I run my own mail server (surely the stupidest of my habits).
About two years ago I “invented” decimal time. Which is to say: I did in fact think of it myself. Unfortunately, there’s a bit of prior art here, going back to the French Revolution.
Short version: Our current day has 86,400 seconds in it. This is not really very far from 100,000. So… what if we just designated a decimal second as being 1/100,000 of a day? then we could have all of our hours and minutes be decimal divisions. More specifically: the day is divided into 10 decimal hours, each hour into 100 decimal minutes, and each minute into 100 decimal seconds. Works great! The decimal hours are quite long, but the decimal minutes are pretty close to our existing ones.
Granite Mon 2013 is in the books. Well, in some books. This was the 19th running of the … well, of the Long Island Challenge part of the Granite Mon. This year it was organized by Alice Clements, and enjoyed by many.
We arose at an absurdly early hour on August 17th, and met at the KYC at 5:00 AM. Miraculously, we had plenty of chase boats, despite a few late cancellations. We counted seven swimmers and eight chase boats, if I recall correctly, so we packed kayaks into the motorboats and headed over.
It was a really lovely morning:
Here we are after we finished:
From left to right, in this picture:
Also swimming was Matt, whose last name I can’t remember and who is cut out of the picture. That’s really too bad, and if anyone can give me a picture, I’ll stick it in here.
Being on sabbatical has given me a bit of experience with other systems and languages. Also, my kids are now old enough to “mess around” with programming. Learning from both of these, I’d like to hazard a bit of HtDP heresy: students should learn for i = 1 to 10 before they learn
To many of you, this may seem obvious. I’m not writing to you. Or maybe you folks can just read along and nod sagely.
HtDP takes this small and very lovely thing—recursive traversals over inductively defined data—and shows how it covers a huge piece of real estate. Really, if students could just understand how to write this class of programs effectively, they would have a vastly easier time with much of the rest of their programming careers, to say nothing of the remainder of their undergraduate tenure. Throw a few twists in there—a bit of mutation for efficiency, some memoization, some dynamic programming—and you’re pretty much done with the programming part of your first four years.
The sad thing is that many, many students make it through an entire four-year curriculum without ever really figuring out how to write a simple recursive traversal of an inductively defined data structure. This makes professors sad.
Among the Very Simple applications of this nice idea is that of “indexes.” That is, the natural numbers can be regarded as an inductively defined set, where a natural number is either 0 or the successor of a natural number. This allows you to regard any kind of indexing loop as simply a special case of … a recursive traversal of an inductively defined data structure.
So here’s the problem: in September, you face a bunch of bright-eyed, enthusiastic, deeply forgiving first-year college students. And you give them the recursive traversal of the inductively defined data structure. A very small number of them get it, and they’re off to the races. The rest of them struggle, and struggle, and finally get their teammates to help them write the code, and really wish they’d taken some other class.
NB: the rest of this makes less sense… even to me. Not finished.
The notion of repeated action is a visceral and easily-understood one. Here’s what I mean. “A human can multiply a pair of 32-bit integers in about a minute. A computer can multiply 32-bit integers at a rate of several billion per second, or about a hundred billion times as fast as a person.” That’s an easily-understood claim: we understand what it means to the same thing a whole bunch of times really fast.
So, when I write
for i=[1..100] multiply_two_numbers();
It’s pretty easy to understand that I’m doing something one hundred times.
To be honest, though, I’m probably flattering myself if I think that this blog post is being read by anyone who doesn’t already know lots about Rust.
One of the key requirements of a language like Rust is that it be embeddable; that is, it should be possible to call Rust code from another language just as it’s possible to call C code from another language.
This is now possible.
To illustrate this, Brian Anderson posted a lovely example of embedding Rust in Ruby. But of course, embedding Rust in Ruby is pretty much exactly the same as embedding Rust in any other language.
So, without further ado, here’s the setup. You just happen to have a small web app written in Racket that performs a Gaussian Blur. You decide to optimize the performance by porting your code to Rust. Then you want to plug your Rust code into your Racket application. Done! Here’s the github repo that contains all of the code.
Let’s see that again in slow motion.
First, here’s the gaussian blur function, written in Racket. We’re going to stick with a grayscale image. It works fine in color, but the code is just that much harder to read.
Pretty similar. Of course, it uses curly braces, so it runs about three times faster…
So: what kind of glue code is necessary to link the Rust code to the Racket code? Not a lot. On the Rust side, we need to create a pointer to the C data, then copy the result back into the source buffer when we’re done with the blur:
As I write this, it’s Monday, August 6th. Charlotte Clews is organizing this year, and it appears that there will be two events that include the swim; the Maine Mountain Challenge, and the Granite Mon. Yesterday was the first swim. Here’s the picture:
From left, the swimmers:
first-time-swimmer Pat Starkey, and
The water was extremely warm: Global Warming will kill millions of people, but it made Sunday morning easier. I think it was at or above 70 degrees. High tide wasn’t until 2:00 PM, so we started quite late. We met at the KYC at 9:30, and I don’t think we started swimming until about 11:00. We all arrived at about the same time; I got in at an hour and 28 minutes, and I think we were all in before 1:38.
There may have been a ride to Cadillac and a hike up it, but I’ll have to wait until I hear more to write about that.