Mizblog

So I’ve been listening to some older Loveline archives, from the Adam Carolla days. There’s a site: http://www.lovelinearchive.com where you can grab many older issues.

I used to think Adam was just a jerk, but he’s actually really funny and has some good insights into the human condition.

Adam Carolla on Religion
Adam Carolla on Society and Drugs

I don’t know, and you don’t either!

I’ve been listening to the Loveline show again lately. I started listening after I got out of the Navy, way back when Ricky Rachtman was the host, but steered clear during the ten year tenure of Adam Carolla (1995-2005). Adam Carolla is a funny guy, but he’s basically a professional asshole. I didn’t enjoy listening to him do Loveline, but now Carolla’s gone and I’m listening and enjoying the show again.

Anyway, if you don’t know about the show and you don’t feel like reading their site, it’s Dr. Drew Pinsky and Ted Stryker who answer radio questions about love, sex, and/or addiction. Drew’s an addiction specialist and Stryker is a radio DJ.

They get a lot of disturbed teens calling in with ridiculous questions. It’s fun to feel superior to the clueless kids and their ignorance.

They also get a lot of calls about relationships, abuse, and addiction. I find it impressive when Drew is able to use his “radar” to ferret out the history of abuse, family drug addiction, etc. behind the superficial problems that motivated the caller to call in. It’s these moments when I feel really amazed at his insight, and I’m trying to learn by listening so that I can recognize this kind of history when I encounter it.

There are also some things where I know that Drew’s advice is misguided and based on current fad literature. I’ll get into details later if I think of them.

I suddenly realized that the Universe is all about Me. That makes me feel incredibly humble. I must be the humblest person in the Universe.

Today another experimental module was deemed “good enough for subjects”. This time we’re teaching the idea of common denominators through the task of dividing up one bar into equal sized parts, then cloning one of the parts a number of times to achieve a desired length. I’m proud of this experiment even though the only part I had in making it was the server, database, and framework for showing the problems and collecting data. Problems were designed by Zipora Roth, and problem presentation was done by Warren Longmire. Credit where credit is due. It’s come together into something quite nice.

My word for the day is shambolic. It means “disorderly or chaotic” and is mainly used in British slang.

I love this word. The conceptual shape of the word and its parts is rich with texture and nuance that most words lack. It feels like there’s so much going on in there. The “sham” prefix makes me think of people deliberately trying to pass off or ignore the “shambles” alluded to by the word’s “shambol”. It’s also very nearly “symbolic”, with the “y” simply swapped out for “ha”, making the sham or shambles a sign of the times.

It’s not often I’m reminded of what wonders language can do, but it’s truly a wonder when a gem like this catches my attention and makes me marvel at the depth and complexity that can be embodied in a single word.

This week I delivered the third of three online learning modules. I built them as I was building the framework that they use, so the process was very dangerous and difficult. Actually, due to the rapid development rate, there are many many known problems with the code, but hey it works and that’s what’s important right now at this moment.

I’ve already started on my next coding project, which is another experiment on how to teach kids to measure things. I think with the new framework available it shouldn’t be much of a problem.

One of the general development problems I keep running into stems from the conflict between creating new code quickly and maintaining older versions of the code. Here’s what happens:

We get a new job that’s a lot like the job we’re working on now, except instead of wanting it to be delivered yesterday, they want it last week. Okay, we’ll have to make quite a few changes to the existing project in order to implement the desired features, but since the existing project doesn’t require those features, and we don’t want to break that project in the process, we create a new copy of everything and add the features to that (just to be safe).

Now while we’re working on this new project, we also fix a bug in code we copied from the original. It’s difficult to realize that we should immediately stop and apply the same fix to the original (and of course test it thoroughly in case it has unintended consequences) so in most cases we don’t apply the change to the original. Later, however, when we’ve delivered the original and someone notices the bug there, we’ll get to go back and fix it there too. Multiply this by several projects and it becomes very tedious.

One way around this is to utilize shared library files. This way, when you fix the library file, everything that uses it benefits from the bug fix. The tradeoff is that if the behavior of the library file changes, all the projects that use it suffer. If different projects implemented different workarounds for that bug, they’ll all need their own individual debugging sessions. Gah! Also tedious!

Another option is to use some kind of source control and try to merge versions. This so-called automated function usually requires at least as much effort as debugging all dependent projects after a library change, because you have to test them anyway, even after you figure out how to incorporate the changes from source control. Also tedious!

I guess what it comes down to is that developing several related projects at the same time is tedious. It involves a balancing act between code sharing and code separation, and it demands testing of every project after every change to library files. This is where automated testing is very beneficial. It lets you spit out a test command and collect results of all your tests. Unfortunately, I haven’t got automated testing down for GUI code. People can come up with so many odd behaviors that I’d never think to write a test for.

Some of my friends and relatives are using a Ghandi quote as their e-mail signature.

Live as if you were to die tomorrow. Learn as if you were to live forever.

Sounds nice doesn’t it? Until you think about it. To me this translates as

Don’t plan for the day after tomorrow, and don’t be in any hurry to learn anything.

I hate that quote. It reminds me of everything I dislike about Taoism and Buddhism. I can’t respect their teachings that promote stupidity.

As the title of this post implies, I’m now coding in Actionscript 2.0. This is the scripting language used by Flash MX 2004 through Flash 8. It’s Macromedia’s attempt to add object-oriented design tools to their scripting language, and I’m appreciating their efforts in this direction. The parts that are wonky for me are the points of interaction between Actionscript and the graphical symbols on the stage. I’ll figure it out though. Just gotta keep tweaking on it.

I’m coding Actionscript because I’m creating a web-based PLM architecture to support this and all our future learning modules. We’re getting a dedicated server this month too, which should help. The server’s problem sequencing procedures can get kind of complicated, and I’d hate to have to rely on a massively shared webserver to support all our projected users.

Today I made the login screen. Again. This time as an object. I’m not sure how to integrate it with the rest of the framework, because as yet the rest of the framework does not exist. I’ll leave that for tomorrow though.