Most of us know who Chucky is. You know, the Good Guy doll possessed by Charles Lee Ray, the Lakeshore Strangler.
We have met Chucky’s bride in the movies. While out searching for antiques with my wife, I met his sister.
Yeah. That is some seriously creepy stuff. Let’s zoom in for a closer look, shall we?
Younger sister, but I definitely see the family resemblance. I, for one, will be sleeping with one eye open from now on…
Not long ago, someone very close to me recently informed me that they were becoming a vegetarian. Curious, I asked, why? I was sat down and patiently lectured that she recently did some reading and discovered that vegetarians live longer healthier lives. Furthermore, since we were not meant to eat meat, she would march forth with resolve and refrain from taking the lives of animals for future nourishment.
The very next day, we decided to go out to one of our favorite restaurant for lunch. Being an Indian restaurant, they had an excellent selection of both meat and vegetarian dishes. My new-found-vegetarian wife’s favorite dish, butter chicken, appeared to be on the buffet that day. As we approached the counter, I saw her resolve sap away as she noticed the presence of the tasty looking dead chicken pieces awash in sweet buttery tomato sauce. Grabbing a plate, she explained to me that she would start being a vegetarian “tomorrow” and that she would be having the tasty butter chicken.
As she tasted the first piece of “chicken”, I noticed an expression forming across her face. It looked something like this:
As it turned out, the “chicken” was not really chicken at all. The sign was wrong and swiftly corrected after we inquired about it. Apparently, the “chicken” was really paneer - good, but something of an acquired taste and certainly a shock to ones system when one was expecting an entirely different texture. So, as we both learned that day, “comeuppance” taste much like Matar Paneer.
If you are curious, my wife took that event as a sign, and now, a month later, is still solidly vegetarian.
Back in my day, we used to have to walk to school. In the snow. Uphill. Both ways. And we liked it!
Okay fine, I took a school bus just like you. But, back in my day, we would sometimes see these dreaded words when coding/debugging in C or C++:
Segmentation fault (core dumped)
#
At that point, the feeling of dread sets in. Its obvious to you, and anyone shoulder surfing, that you were not careful with your memory allocation. To boot, if your application was any more complicated than say, “Hello World”, you would be faced with the task of firing up GDB, loading the core file, and tracking down exactly where you went wrong. While being able to do this is indespensible, I have always found prevention to be better than the cure.
While working on my new project, I wanted to know how I was doing with memory allocation. Enter Valgrind:
Valgrind is useful to help you find memory leaks and identifiying when you are accessing memory that has not been allocated. Additionally, it will find incorrect uses of the free/delete operators. Valgrind does this by running your program in a simulated, managed environment complete with a simulated CPU. Effectively, while your program is running under Valgrind, it is being treated as if it were Java byte code.
To use Valgrind, first modify your make file to use the -g and -O0 options. This will turn on debugging information (so you get line numbers) and insures that the compiler is not running any optimizations (which is the default mode). Keep in mind that your program will run many orders of magnitude slower when running under Valgrind.
Once that is done, simply run your program like this:
valgrind --leak-check=yes myprog arg1 arg2
To find out more about interpreting the error messages you get back, look here.
Not to show my age, but my college started us out programming in C, not Java. After a few classes of that, we were allowed to take a class called Object Oriented Paradigm, which was really shorthand for Booch’s notation and C++. My first job out of college involved C to a degree and then I spent 4 more years doing C and C++. All the while, I managed to keep a small CircleMUD code base (written in C) going in my spare time. All in all, I loved it. However, there were problems. At the time, I was building ground control software using the Motif toolkit and Roguewave libraries. The requirements for the software we were building often necessitated sophisticated controls. Motif was many things, sophisticated (in modern 2001 terms) was not one of them. We were spending the better part of our development time on trying to compensate for sub-par libraries.
At that point in time, Java had really just started taking off. I did some research and wrote some prototype user interfaces (using AWT at first and later Swing). Selling an entity that is not accustomed to change on rewriting the ground control software for an entire installation was largely an uphill battle, but one that we won. We were able to show (with solid metrics) that developers would be more productive using Java for non-real time systems and be capable of building more sophisticated interfaces and applications in less time. It was a great success that came with a free side of portability.
As my career progressed, I found myself working on enterprise scale web applications. Specifically, I was usually working on the server code, but periodically ventured into the client code as well. The client code we were writing was using the Struts framework. For the life of me, it felt like everything I did required me to do something to make Struts happy. Everything seemed like a chore - the framework could not get out of its own way. I opted to look elsewhere and found Ruby and Rails. The Ruby language is elegant, easy to work with, and has an amazingly complete library at its disposal. The Rails framework makes development of web applications almost trivial (well, as trivial as it can be).
I woke up the other morning with a certain irrational desire. For some strange reason, I find myself longing to dabble in the dark arts of C and C++ again. I miss screwing with pointers and memory allocation. I miss compiling. Not generating byte code, but real honest to goodness compiling. I did some looking around and re-experimenting with distro’s and discovered that openSUSE 11.1 and KDE 4.1 is hot! Really hot! Dig this:
Hot, right?!?
I spent some time this weekend dusting off my tomes on C, C++, sockets, semaphores, and shared memory. Over the next few months, I am going to spend some time looking at the KDE libraries and will hopefully love what I find 
Snow still coming down. Starting to worry. May not be able to find my car…
On the bright side, I just wrapped up a new release of Jarhunt! The new version (1.0.4) includes indexes to improve search speed as well as some cleanup of the views and controllers to get rid of the last stragglers of redundant code. While I was at it, I cataloged a LOT more jar files for the reference implemtation. All in all, Jarhunt.com now has 5915 classes cataloged (most of the Apache commons, logging, and XML stuff).
Also just in from the”way too much time on my hands department“: My Powerbook G4 is now nicely running Debian Etch with the Xfce desktop envrionment.
I hope tomorrow will bring a nice mix between a start to a new project, exercise, and the Sins of a Solar Empire marathon . We’ll see how that goes.
Power Status: So far, so good. National Grid has managed to keep power supplied to our appartment desipte a major winter storm. Its nice to see them bucking the trend.
Slackfest 2008 (only slightly dampened by a power outage) officially started yesterday! I have a four day weekend during which I will do nothing but “man/geek” things. I started out the festivities by some copious online gaming (World of Warcraft) with Luke. Unfortunately, National Grid put the kibosh on that shortly after lunch. You’d think that as a power company, that they would be slightly better at their job. Apparently, they suck at it.
On the agenda of things to do:
First things first though… Living in New England, we are in for a few days of nasty snow storms this weekend. I’ll need some food and will not necessarily want to leave the house to get it. To deal with this, I made enough stuffed peppers to tide us over for the better part of the weekend.
If you want to follow along at home, you’ll need the following ingredients:
Alrighty then, a look at the raw ingredients:
Step 1: Cook brown rice (2 cups of water, bring to a boil for 10 minutes, set to low, cover and simmer for 30ish minutes)
Step 2: Chop onions into small pieces, combine with garlic, olive oil, chili powder, Scotch (fracking hot) Bonnet peppers, and 1/2 of the Italian seasoning. Simmer until onions start to clear.
When you start, it’ll look like this:
When you are finished, you may have something like this:
Step 3: While the onions are cooking, wash and de-cap the bell peppers. Place them in a cooking tray so that they look something like this:
Step 4: Combine meat, crushed red pepper, cooked onion mix, rice, cheese, salt, tomato sauce, remaining Italian seasoning, eggs, and breadcrumbs into a large container. Mix vigorously.
Step 5: Insert goop into peppers.
Step 6: Put into preheated oven at 365. Go run Wailing Caverns or otherwise keep yourself busy for an hour and 10 minutes.
Step 7: Extract from oven, let cool, and eat.
Well, that’s it for now. I’ll post again with my progress on other things later tonight.
Ok, this is it. Really. I changed again because I got tired of maintaining the old blog manually and I was not writing as much as I wanted to because of the overhead involved.
Since my last post (in the old blog), I have done several iterations of the Jarhunt code base. Mostly, I have been cleaning up ugly Ruby code and refactoring, but I have also updated the look and feel and added file meta data for each class.
Still to come:
You can grab the new stuff from SourceForge here.