Delphi at 21, an era

Today marks an interesting day. As the title suggests, today is year 21 since the public announcement of Delphi. At the Software Development West conference in San Francisco, California, I remember sitting in the audience as I watched my colleague, Anders Hejlsberg, demonstrate the new Object Pascal based development tool.

Baking an Object Pascal and Raspberry Pie for the Holidays.

If you've not been living under a rock over the last couple of years, I'm certain you've noticed the recent release of the new Raspberry Pi 2 Model B. Packed in this little not-much-bigger-than-a-playing-card form factor is a quad-core ARM Cortex A7 along with 1GB of RAM. It also sports HDMI video/audio, Ethernet, 4-USB ports and a programmable parallel port for peripheral interfacing. Booting several versions of Linux is a snap... but what about using your favorite language and mine, Object Pascal to target this device?

The Chronograph - Part 5

When developing the Ballistic Chronograph, I decided that I needed a way to have, effectively, a command-prompt. I also wanted to have a way to display text in an auto-scrolling view. It would be used similar to Object Pascal' Writeln, C's printf or C#'s Console.WriteLine. The Arduino libraries already have an abstract class for writing text, Print. If you've done any Arduino programming, you've already used this class indirectly via the HardwareSerial class.

Mentors and inspiration

Recently I've had the pleasure of reconnecting with a past colleague. Chuck Jazdzewski was the man instrumental in my coming to Borland to join the Turbo Pascal team. I count him as one of my professional mentors. While I also worked closely with Anders Hejlsberg, it was with Chuck that I worked with on a more day-to-day basis.

The Chronograph - Part 4

The touch panel and touch keyboard were an interesting challenge. I picked this one up mainly because the price was well into the "impulse buy" range. I didn't really have a plan for it, but figured it would be interesting to play with. After a little bit of Google-fu, I found that the 4-wire resistive touch panels were rather common, and best of all, there is an Arduino library for it.  I also picked up the display because HSC claimed to have data on it. It turned out that used the relatively common T6963C interface. There is an Arduino library for that as well.

Cyborging a Cheap Laminator

I decided to take a detour from covering the Ballistic Chronograph and cover some tooling I use for creating my own custom Printed Circuit boards. Having the ability to go from thought, to design, to a working device, gadget or tool is what makes doing hardware these days so fun. In the in the span of a long, lazy Saturday or Sunday, I can build a project that would have taken several weeks or would not be nearly as clean and well packaged.

The Chronograph - Part 3

Now I'm going to turn my attention to the software for the stand-alone controller shown in the previous post.

Before I ever started working on the UI for the device, the first order of business was to get the code needed to actually perform it's primary function written.

The Chronograph - Part 2

In the last post I showed the electronics behind the ballistic chronograph sensor array, or using chronograph terminology, the "screens". The frame for the screens was built from 1"x.5" extruded aluminum U-channel, .5"x.5" aluminum angle, and 3/16" steel rods for the uprights. Various bits of hardware and some .25"x1" steel spacers from my parts bin, drilled out on one end to 3/16" and tapped to 6-32 on the other. The cross pieces at the top which house the sensors are actually plastic U-Channel surface wiring conduit snap covers.

Now I'll cover initial stand-alone controller I built. This part of the project evolved as I was building it. It started with a trip to the (sort of) local surplus electronics store, HSC Electronic Supply.

The Chronograph - Part 1

As mentioned in this post and teased in this one, one of the things I was going to write about was the construction of a ballistic chronograph. The intent of this post is to outline it's construction and my approach to building it. It's intended use and all the information surround that is beyond the scope of this post.

Strings with a reference count > 1 are immutable

And have always been.

Let me explain. Assigning to a string variable from another has always been merely copying of the reference along with a bit of reference count management.

var
  A, B: string;
begin
  A := 'a string';
  B := A;
  // string instance reference count = 2
end;