So much for science, and how helpful it can be in these times of environmental calamities. Chernobyl is still hotter than a Hiroshima baby carriage. Our underarm deoderants have eaten holes in the ozone layer.
And just get a load of this: My big brother Bernie, who can’t draw for sour apples, and who at his most objectionable used to say he didn’t like paintings because they didn’t do anything, just hung there year after year, has this summer become an artist!
I shit you not! This Ph.D. physical chemist from MIT is now the poor man’s Jackson Pollock! He squoozles glurp of various colors and consistencies between two flat sheets of impermiable materials, such as windowpanes or bathroom tiles. The pulls them apart, et voila! This has nothing to do with his cancer. He didn’t know he had it yet, and the malignancy was in his lungs and not in his brain in any case. He was just farting around one day, a semi-retired old geezer without a wife to ask him what in the name of God he thought he was doing, et voila! Better late than never, that’s all I can say.
So he sent me some black-and-white Xeroxes of his squiggle miniatures, mostly dendritic forms, maybe trees or shrubs, maybe mushrooms o umbrellas full of holes, but really quite interesting. Like my ballroom dancing, they were acceptable. He has since sent me multicolored originals, which I like a lot.

The message he sent me along with the Xeroxes, though, wasn’t about unexpected happiness. It was an unreconstructed technocrat’s challenge to the artsy-fartsy, of which I was a prime exemplar. “Is this art or not?” he asked. He couldn’t have put that question so jeeringly fifty years ago, of course, before the founding of the first wholly American school of painting, Abstract Expressionism, and the deification in particular of Jack the Dripper, Jackson Pollock, who also couldn’t draw for sour apples.
Bernie said, too, that a very interesting scientific phenomenon was involved, having to do, he left me to guess, with how different glurps behave when squoozled this way and that, with nowhere to go but up or down or sideways. If the artsy-fartsy world had no use for his pictures, he seemed to imply, his pictures could still point the way to better lubricants or suntan lotions, or who knows what? The all-new Preparation-H!
He would not sign his pictures, he said, or admit publicly that he had made them, or describe how they were made. He plainly expected puffed-up critics to sweat bullets and excrete sizable chunks of masonry when trying to answer his cunningly innocent question: “Art or not?”

I was pleased to reply with an epistle which was frankly vengeful, since he and Father had screwed me out of a liberal arts college education: “Dear Brother: This is almost like telling you about the birds and the bees,” I began. “There are many good people who are beneficially stimulated by some, but not all, manmade arrangements of colors and shapes on flat surfaces, essentially nonsense.
“You yourself are gratified by some music, arrangements of noises, and again essentially nonsense. If I were to kick a bucket down the cellar stairs, and then say to you that the racket I had made was philosophically on par with The Magin Flute, this would not be the beginning of a long and upsetting debate. An utterly satisfactory and complete response on your part would be, ‘I like what Mozart did, and I hate what the bucket did.’
“Contemplating a purpoted work of art is a social activity. Either you have a rewarding time, or your don’t. You don’t have to say why afterward. You don’t have to say anything.
“You are a justly revered experimentalist, dear brother. If you really want to know whether your pictures are, as you say, ‘art or not,’ you must display them in a public place somewhere, and see if strangers like to look at them. That is the way the game is played. Let me know what happens.”

I went on: “People capable of liking some paintings or prints or whatever can rarely do so without knowing something about the artist. Again, the situation is social rather than scientific. Any work of art is half of a conversation between two human beings, and it helps a lot to know who is talking at you. Does he or she have a reputation for seriousness, for religiosity, for suffering, for concupiscence, for rebellion, for sincerity, for jokes?
“There are virtually no respected paintings made by persons about whom we know zilch. We can even surmise quite a bit about the lives of whoever did the paintings in the caverns underneath Lascaux, France.
“I dare to suggest that no picture can attract serious attention without a particular sort of human being attached to it in the viewer’s mind. If you are unwilling to claim credit for your pictures, and to say why you hoped others might find them worth examining, there goes the ball game.
“Pictures are famous for their humanness, and no for their pictureness.”

I went on: “There is also the matter of craftsmanship. Real picture-lovers like to play along, so to speak, to look closely at the surfaces, to see how the illusion was created. If you are unwilling to say how you made your pictures, there goes the ball game a second time.
“Good luck, and love as always,” I wrote. And I signed my name.

(From Vonnegut’s 1997 novel “Timequake,” which I kinda liked, even though it was kindof all over the place, because it occasionally contained some really good stuff like this. Please don’t sue me, owners of Vonnegut’s rights. Just trying to make conversation.)

This little bit does a fairly tidy job of responding to the volumes of stuff that has been written trying to pin down really specific definitions of what this crazy thing called art is. Coming from a technical background (with a little artistic goodness thrown in), my inclination was to try to come up with a really nice reductive definition of art (of course ignoring the social conversation going on). But good ol’ Kurt does a good job of making sense, as always.

You tell ‘em, McGoohan.

To refresh your memory, the FishApp keeps track of water changes, and gives you a graph showing weighted-age values for the water in your fish tank.  This requires you to pay attention while you’re doing the water change, and to log in to the website and report how much water you changed when.  Well, I want to have the FishApp sense, measure, and publish water changes for me.  To those ends, I designed a system that can measure the water level in the tank over time, report it to a computer, figure out when and how much water was changed, and report that back to the main fishapp web application.  The measurement is done using a Ping))) ultrasonic rangefinder, and data from that (and other sensors) is fed into a computer.

But just how is the computer supposed to figure out when a water change happened?  It’s input is just a string of numbers, and it’s gotta be smart enough to filter out random noise from tank cleanings, frisky fish, the water filter starting and stopping for one reason or another, or any of a hundred other situations.  What to do?

If you’ve read the last post about the FishApp, you know where to start – smooth out the data.  To recap, I have the sensor set to read the water level every half-second, and report it to the computer.  The raw data is pretty noisy:

but if we make new data points from the median of  every 20 samples, things smooth out pretty quickly:

The system should be able to handle this muuuch easier.

The algorithm works by keeping a queue of recent (smoothed) samples.  By comparing the oldest sample with the newest sample, you can get a “slope” value.   On the graph above, for example, it doesn’t take very many samples until the oldest will be just over 600 but the most recent will be around 800 or so, and you’ll have a large positive slope.  Once the algorithm sees this large positive slope (above a certain trigger value), it knows that a water change is beginning, and notes the water level beforehand.  At some point in the process of a water change, I start filing the tank up again, and we see a large negative slope (around 55-60 on the graph above).  The algorithm notes the capitulation and the minimum water level.  If the absolute value of the slope stays low enough for long enough, the algorithm detects a steady state, and calls it the end of the water change.  The “steps” you see on the graph are because I do my water changes bucket-by-bucket, but because the algorithm is using a slope from a queue maybe 10 samples long, it already does a pretty good job of smoothing these steps out, and not getting too confused.

After running the algorithm against the data above, it worked flawlessly.  Take a look at this graph:

The gray lines are where the important steps in the process were detected.  For example, the first gray line @ x=10 is where the algorithm first noticed we were emptying water out of the tank.  It looks late – and it is, but that’s merely a consequence of using a queue of 10 samples to generate the slope.  The actual “before” water level value it uses is not the one at the gray line, but the minimum one in the queue – which is correct (enough for rock and roll).  Then, at x=54, the algorithm detected a large negative slope and decided that we were filling the tank up again.  It started looking for the start of a steady state, which it found at x=121, and it stayed steady long enough that at x=150, the algorithm wrapped up and decided that we’ve done a water change.  NIFTY!

If you think about what is going on here, it’s really calculus, under the covers.  The slope value is the derivative of the function, and we look for the points that derivative changes sign.  But the function we’re using isn’t perfect, and isn’t continuous, and so we’ve got to build in a little extra wonkitude-resistance.  The algorithm has inputs for the size of the queue, the trigger value for large positive/negative slopes, a tolerance value to ignore noise during steady states, and the number of samples to go during a steady state before deciding we’re really done with the water change – so in theory, this algorithm could be adapted and tuned for a wide range of input sources with little-to-no modification.

Right now, the algorithm is coded in python, but I think it might even be possible to do the crunching on the Arduino.  If I did that and wired the Arduino up to an ethernet shield, I could ALMOST eliminate the computer altogether.  I still need the computer to run the webcam, however, so there’s no point in trying to run this code on the chip or anything like that.  But I think it would be possible in theory, if you don’t want the cam server running.

The watch is a  Seiko affectionately called the “Orange Monster.”  It’s a huge, loud, fun, heavy watch – and it makes me quite happy.  I also made and put up a giant X-Files “I Want To Believe” poster.  There are several different images for this poster floating around on the net, and much to my chagrin, it turns out it’s NOT the one that I see behind Mulder’s desk in the series.  Ah, well.

The host computer gets this stream of numbers, and has to have some way of determining when I’ve done a water change, and how much water I’ve changed. I got the feeling that random variation (noise) in the data from the sensor could throw off whatever method I use to compute all of this, so I needed to figure out exactly what the data looks like coming in to the computer, preferably saving it so I can test my algorithms against it without having to do a water change after each revision – that would be a heck of a lot worse than just waiting for the code to recompile.

So I fired up Arduino and Python did a water change, saving the raw data from the Ping))) sensor to a file. Without further ado, this is what a water change looks like to a computer:

Pretty cool, huh?  When I do a water change, I siphon water out of the tank into a 3 gallon bucket, and empty it a bucket at a time, until I’ve taken out as much as I like, and then I re-fill the think 3 gallons at a time.  You end up with the very visible “steps” on the graph.  While the data looks mostly consistent, you can see some wonkiness in some of the steps – which almost looks like thick lines.  The sensor isn’t quite reading the distance regularly in this case.  This looks to me like the kind of data which could really throw of my detection algorithm.  So I had the bright idea of taking a median of 5 samples for each data point and using that series for detection.  Here’s what a median-of-five graph looks like:

Median of Five Graph

You should notice two things: 1) there are fewer datapoints by an order of five, because of the median, and 2) the curve is smoother.  I could prove this by computing the standard deviation on some of those trouble spots from above, but I don’t think it’s necessary: it’s plain to see when graphed.  The data could still be better though – look at the jaggies around 100.  We’ve got plenty of data, so we should be able to create a very smooth line and still have enough resolution to see each step, etc.

I’ll spare you all the gory details, but suffice it to say that the larger the median used, the better.  A median of 10 was better, but still not good.  A median of 15 was nearly perfect, but there was still just a little weirdness.  A median of 20 was perfect:

Median of 20 graph

That’s more like it.  We’ve still got enough data there to see the water change in detail, but smoothed out all the ugliness that could throw off the computer.  Cool stuff.

More details on the detection algorithm’s implementation to follow.  Charts generated with my new favorite tool, Python.

Water age & nitrate levels over time

This chart shows the average age (in days) of the water in my tank compared with the levels of Nitrate I measure using an aquarium test kit.  I compute the water age using information I record about water changes I do to my tank (a more detailed explanation can be found in the original FishApp post), and Nitrate is a mildly-bad chemical the can build up in your tank over time.  It’s the end-product of the Nitrogen Cycle in most fish tanks, and can only be removed by water changes or chemical absorption (which some plants and special filter media can do).

At least that’s the theory.  What this chart is showing me is that the theory seems to actually work out in practice, and that my tests are precise enough to actually be useful – always a good thing.  Even though I only have five data points for the nitrate series (because I don’t always test as much as I should), it is easy to see the nitrate curve following the water age curve.  They actually track pretty well, I think. You can see an ugly spike in the water age when I wasn’t paying enough attention to the tank, and the resulting high nitrate levels, which backed down after a series of regular water changes.  When the water age started creeping back up again, so did Nitrate levels, and then both went down again after we moved from Tennessee to North Carolina (and changed out about 2/3 of the tank water for fresh in the process).  Very cool.

Since nitrate is the last state that fish poo reaches in the nitrogen cycle, it would not surprise me if there were a delay between water age and its effects on nitrate levels.  I don’t really have the data to support that right now, but I will try to be more diligent in my testing, and perhaps we can figure that out soon.

If there are any aquarium owners out there who are interested in the FishApp, you can sign up free and track your own fish tank in a similar fashion.  Here’s a link to sign up.

Possessing any of these attributes in isolation is not so bad of a thing.  But when all of them combine into one person, well…  You end up with some really oddball (yet fun) projects.

Bearing all that in mind, I’d like to tell you about a project I’m in the middle of right now – the FishApp.  FishApp started out as a PHP/MySQL web application that I created to help keep track of the water quality in my fish tank, and to view changes in water parameters over time (to identify trends and causal relationships, for example).  That didn’t sound like such a difficult project…

FishApp Screenshot

This is where things started getting out of hand (in a good way).  I decided that there may be other fish nerds on the internet who may want to use the service, so I added multi-user capability to the FishApp.  Which meant I had to make everything more user-friendly and build out the Admin area a little btter.  I had to give users the option to upload a fish tank picture (and resize it for them, etc).  And what if they had multiple tanks?  And so on.  All of those features are currently built into the fishapp.  We’ll see if anyone decides to use it or not!

There’s nothing too crazy going on in the FishApp code.  The graphs are generated by Flot (using a custom PHP wrapper I wrote and dubbed “phlot”).  There’s jQuery and the jQuery UI tools all over the admin area, and of course a rather simple MySQL database in the back.

There were a few technical challenges to address, however.  The last graph on the page displays the average “age” of the water in your fish tank.  It is a good idea to periodically change out some of the water in the fish tank for fresh water (to reduce things like Nitrates and accumulated minerals).  This reduces the weighted average age of the water in your fish tank.  This is my favorite feature, as it adds a visual display to an important piece of information that is normally invisible.

I also wanted the app  to send reminders to do maintenance tasks now and then.  However, if you have a large fish tank, you may only do a water change once a month, but if you have a small tank, you may want to do it every week.  I needed to give the users the opportunity to decided their own parameters for alerts.  In addition, I wanted users to be able to get an alert when their tank’s water age reached a certain number of days.  The SQL code necessary to aggregate across all the different maintenance types and tanks and users became quite large, however well-placed database indexes keep things running smoothly.

If you haven’t nodded off yet, you might be thinking that I’ve just about pushed this idea as far as it can go.  You would be mistaken.

Sometime in the middle of the project, I discovered this awesome open-source hardware/software microcontroller project called Arduino.  The Arduino project does what frustrated software engineers have longed to do since they days they first fired up QBasic on their friends’ computers – interface with the REAL WORLD.  Easily.  You can program the Arduino using a comfortable C-like language in its easy-to-use development environment.  It can read sensor values, move servos, control motors, light LEDs, make sounds, etc.  Anything you can wire up to it, you can use (basically).  People were doing cool stuff like improving their espresso machines, building real-life pong interfaces, tweeting their energy usage, and the like.  So naturally I decided my fish tank had to be web-enabled.

I am still in the middle of this section of the project, but here are some ideas of what I plan on doing with the FishApp:

• Use an ultrasonic distance sensor & some code to determine when I have just done a water change, and automatically post JSON data to the FishApp’s API.  No more forgetting to put water changes into the app.
• Monitor the tank’s temperature over time using a neat little National Semiconductor chip.  I should be able to detect and diagnose any big swings in temperature in real time.
• Control some LED moonlights for my tank, both on a programmed schedule, and using an infrared remote control.
• Allow web users to feed my fish a special treat (once a day) by pushing a button on the web page.  AJAX + Arduino + Servos for the win!
• Set up a FishCam – a webcam to view the action in the tank.
• Every now and then, tweet what is going on in the fish tank.
• Buy a PH probe and graph real-time PH values (especially important if I decide to do some CO2 injection in the tank at some point).
• Build a turbidity meter to measure the water clarity (following instructions from an awesome Forrest Mims electronics book).

As you can see, the list goes on and one.  The first few features are already in development, the rest may follow afterward.

As I said, the FishApp is not finished.  It is not very polished currently, and not really ready for prime-time.  I just wanted to post this blog to give a sneak-peak of what’s in the works.  Now go check it out!

Behringer BCF2000s in the studio

I scored these two as scratch and dent deals on MusiciansFriend.com for $161 each (including shipping, no tax).  I was worried that they wouldn’t play nicely with ProTools, but it turns out that they do a great job working with the software.  Expect a forthcoming full review, but for now, I’ll just say that I really, REALLY like faders.

Also, I was not able to find anywhere on the internet that could confirm if you could use multiple units at the same time with Pro Tools.  Well, I’m here to tell you that you can.  I probably could have hooked up a THIRD one of these if I wanted to.  You just set up each one in the Setup->Peripherals menu in Pro Tools (use the baby HUI emulation) and they work like a charm.  Shifting through the banks works as expected and everything.  Spiffy.  This should make my mixes better.

I think a lot of people don’t put nearly enough thought into how they use a computer before they purchase one.  This is especially true of laptops, since the ways people use them are (or at least potentially are) so varried and different.  They just buy something kinda flashy looking that is big and relatively powerful, because they want the kitchen sink.  The Swiss Army Laptop, as it were.  Of course, doing all things equally well sometimes means doing all things equally poorly.

Having been with my current ‘top for nearly 8 years now (and not being a very “typical” computer user), I have a pretty good idea of how I use computers.  Specifically, I like to take them places.  I crave long battery life.  I have a high-powered desktop to handle the really crazy stuff.  I have been doing a lot of web development rather than Win32 stuff.  I also have recently been very interested in microcontroller programming on platforms like the Arduino.  I don’t use MS Office much, and think I could get by pretty well with the Google Gears versions of Google Docs in many cases.

The particular netbook I’m interested in has a ridiculous battery life.  They claim up to 9.5 hours, but I’ve seen people citing real-world usage of around 6-8 hours, which is very impressive.  It’s sufficiently light and you don’t have to carry around a bunch of crap to make it work. (Don’t be fooled into thinking that all netbooks have great battery life.  Many are terrible.  I personally think the lackluster battery life of most netbooks defeats their purposes.)  The web dev work that I’d be doing on it is (for the most part) scripting languages and light database stuff (LAMP), which this unit could handle as a development machine.  Any ASP.NET or C#  development would primarily be off this computer, but I’ll probably do some basic edits to some stuff on this machine anyway in a generic text editor (it is occasionally handy to not have to rely on the Wizzards for everything).

I once heard somebody say that the easiest way to drastically improve the quality of your photographs was to carry a camera around with you everywhere.  The quality doesn’t matter; you’ll get better shots if you’re the only guy around with a camera when something cool happens.  The same principle applies here for computers, too.  I plan on making a rugedized & modularized Arduino to go with the netbook to carry around so that virtually anywhere I am, I can do really cool computing and interface with the “real world” in literally a few minutes.  That’s roughly equivalent to a super-nerdy MacGyver.  And that’s what I want.

Plus, I’m going to be building a powerhouse beast of a recording/programming machine for home soon anyway.

P.S. I don’t have a data plan for my phone, and probably won’t get one for a while at least.  So I will have to rely on WiFi for my internet connectivity in the short term.  Ergo, no service charge.  But that’s okay, I can do what I need to offline in many cases.