So, it’s been over a month since I last posted, but things have got busy. Here’s what I’ve been up to:

• preDevCamp has bloomed! We’re still waiting on Palm/Sprint to announce a launch date, but I did get my hands on a copy of the SDK and am looking forward to playing with it.
• I got involved in an organization called Linux Against Poverty. That’s all I’m saying for now, but watch this space for more details
• I launched nerdnite Austin with JC. I also revamped the nerdnite website which went live last weekend.
• I’m moving house. Closing this Monday. Yikes!

Consider this my return post. I’ll be posting more often once things have been sorted with the house… see you soon!

Update
(Thanks to my sister for the prodding!)

I have spent a fair amount of time setting up the hosting for my sister’s site: http://purplestarconsulting.com. If you’re an Atlanta based small business and need assistance with marketing and web presence, go check her out!

I saw @mhat‘s tweet today about ‘What language should I learn‘  and it got me thinking about the times I’ve asked that question and how I might answer it. So, @mhat, I’m taking your tweet to be a challenge to write an unbiased and ‘unwrong’ post. To do this, I’m going to give you a history of the languages I have learned.

The early years

As I wrote in my first post, I started at a tender age, on a ZX Spectrum. The Spectrum came with a dialect of BASIC, called ‘Sinclair Basic’. Like all BASIC derivatives, it’s a high level language, however unlike modern flavours of BASIC, it was untyped and unstructured. Lines of code were entered with the line number provided explicitly. There was no variable scoping and subroutines were implemented as a special ‘GOTO’ called ‘GOSUB’ which allowed you to ‘RETURN’ to the next line. However, since there was no variable scoping, recursion was impossible.

That said, I was 5 at the time, I wasn’t too worried about recursion at the time. My programming was limited to copying code out of books containing page after page of ZX Spectrum programs. My brother and I would diligently type these out, then play the game for a while and then start playing with the code to see what changes we could make. This process was about as successful as genetic mutation. More often than not, our change would kill the program, but sometimes it would lead to great stuff.

As we got older, our 48K Spectrum was replaced with a 128K Spectrum. Along with the extra memory, came an update to BASIC to include keywords that allowed direct access to the MIDI chip. I continued to mess around with BASIC, making programs that would play both hands of a piano score, as well as simple games.

The IBM PC arrives

My first experience with an IBM PC was the 286. I migrated from Sinclair BASIC to GW-BASIC. At this point, I was writing programs from scratch, including a text adventure called ‘Loup-Garou Chateau’. Tragically, this game has been lost from prosperity, but it was my first foray into actually designing a program before coding it. I chose GW-BASIC, simply because I was very familiar with BASIC and it made for the simplest transition.

As the years passed, I would inherit my dad’s old computers, moving up through the 386 to the 486. At this point, I got my hands on Visual Basic. Again, this transition was driven by the ease of transition from what I knew to something new. This was my first experience with a proper development IDE, as well as my first experience with creating GUIs. Beyond that, it wasn’t a great step forward to me… that would come during university.

Coding gets hardcore

I never studied computing at university; I was a physics student. However, the course I took, included some small computing components. For one lab rotation, we learned how to use computers for physical analysis. This was back in 2000 and they had us coding with Pascal. At the same time, I was playing with C at the suggestion of my dad. For the first time, I was learning about functions and variable typing. In addition, I was programming with the intention to solve problems that were being presented to me, instead of just ‘playing’ with a language and seeing what it could do. When you have an externally provided problem to solve, you’re forced to learn how to use new facets of the language. If you’re just playing around, you can be limited to seeing what you can do with the parts of the language you understand.

While at university, I also participated in an Electronics lab which involved learning about the 8086 processor. We had an experimental board which allowed us to commit opcodes to a region of memory and then execute them. As part of the practical, we actually had to wire up the SUB instruction, by running the clock signal through the appropriate logic gates and to the appropriate ALU pins. This was my first experience with the lowest level of programming.

In the summer between my second and third years, I spent four weeks working for Milford Instruments. While there, I developed a DMX-512 Transceiver Controller. I was working with the SX-Chip from Parallax and learned how to write assembler, how to work with interrupt handlers and how to get microcontrollers to talk to other microchips. For 4 weeks, I worked on the firmware and the hardware and really learned what programming was all about…

Coding starts to bring in money

My month at Milford Instruments made me realise what I wanted to do with my time; I wanted to get into development professionally. It was an obvious choice to apply to IBM and I started working at their Hursley Development Lab, one weeks after school ended. They had me working on a protocol converter, (this time, a SCSI-SSA converter) and, as before, it was coded in assembler.

After a couple of years working on this, I moved to work on one of their Storage RAID controllers. This time I was coding in C, the first time I had done so, professionally. However, alongside all this production code, I was steadily learning how to write Perl and Korn Shell scripts for developing test rigs. I was also teaching myself how to code for the web. I’d done some basic page development while at university, but I was beginning to learn about dynamic pages and DOM manipulation.

My next move got me into support and I started writing a web-based support tool. It uses Perl and MySQL in the back-end and HTML and Javascript in the front-end.

The main thing I got from the IBM Development Lab was the chance to be surrounded by people writing a wide variety of code to solve a wide variety of problems and be exposed to what other people were doing with languages that I both knew and that I had never heard of. I learned that there is really no such thing as the one perfect language, rather the best language for the job in hand.

What’s the point of all this?

So, what’s the point of this post? Is it possible to write a post about “Which language should I use” that is not biased and has some value? I hope so. Here’s what I feel I’ve learned over the years.

People write code for a wide variety of reasons. The language that they code in is also determined by a multitude of factors. More often than not, we don’t have a truly free hand when it comes to choosing the language we’re coding in. However, looking back, I believe I see some benefits in the track I took.

• Learning C allows you to truly understand what higher level languages such as Perl or Java are doing with objects and references. Although people get scared off by pointers, if you don’t understand the concept, then you’re going to struggle with the idea of references. Since all languages have variables, if you can get those nailed and totally understood, you’re going to be in good stead when you move to a language which brings new data types
• Learning Assembler allows you to truly understand what C is doing with pointers. Assembler has a tiny command set and you have to tell it to do every last thing. It’s a struggle, but once you’ve got assembler in your tool belt you’re in good shape. You may never go back to it, but the lessons you learn from it can be applied all the way up the language stack
• Learning a wide variety of languages allows you to truly understand the patterns of development that are language-independent and stops you falling into the trap of becoming a language bigot. There’s nothing wrong with having a favourite language, but saying that one language is categorically better than another because of the presence of a specific feature is like praising Inuit for its wide variety of words for snow. That’s fine if you’re describing snow, but not much use if you want to discuss the surfing conditions in Hawaii.
• Learning a language is a lot easier if you’re trying to solve a specific problem that has come from an external source. This is why it’s such a good idea to do the exercises if you’re learning from a textbook. There’s nothing wrong with playing with a feature for its own sake, but unless you have some factor that is external to the language driving you, it’s going to be tough to learn all that the language can do.

Did I just cop out?

So, did I just cop out of the question? If someone asked me what language they should learn, how would I answer? That depends on the person. If they were just starting out, I would say Perl or Python. These languages have a huge development community and millions of pages dedicated to coding in them. They are in common usage and show no signs of disappearing in the near future. They are neither arcane nor limited in their range and they allow for procedural and object oriented style programming, meaning that the developer can transition to OO without having to change languages.

If I was being asked by someone with a reasonable amount of development, I would strongly suggest Javascript. As the powerhouse behind Web 2.0 and the basis for coding on the Palm Pre, it’s critical to know this language. However, testing and debugging Javascript is not a trivial task and requires a developer who is comfortable writing code that has ‘a good chance’ of working so that troubleshooting is limited to ironing out wrinkle. Also, the problems of cross-browser support are bewildering enough for experienced coders; exposing a brand new coder to Javascript would probably be the end of their efforts in the field.

If someone wanted to spread their wings a little, I’d strongly suggest taking a look at Assembler or some other microprocessor based language. It’s still coding, but you’re forced to truly understand your code’s interaction with external factors that don’t care about your nice neat program. Spending time debugging microprocessor code; especially code that interacts with an external piece of hardware, gives you a true understanding of the many ways that code can fail to work.

Like a fair number of people, I have a number of Twitter identities. I have my personal identity (@dancrumb) as well as a number of shared identities that represent events or organizations in which I’m involved.

I use a number of clients to send out tweets, but all of these clients limit you to a single identity. If you want to user twitter.com to send out messages, you need to log in with the appropriate identity before you perform any Twitter functions.

Herein lies the problem. When you’re logged in to Twitter and you navigate to somebody’s Twitter page, there is no indication as to who you’re logged in as. The risk is that you could elect to follow or message someone, thinking you’re logged in as one identity, only to find that you’re logged in as another identity. I did precisely this, yesterday. As luck would have it, the person was my sister and I quickly spotted my mistake, but if  you’re using Twitter as a major communication channel, you need to be very aware of which identity you’re tweeting with.

In order to address this, I’ve written a small Greasemonkey script. You can access it here. You’ll need to have the Greasemonkey plugin installed, of course.

Once the script is installed, you will be able to see who you’re logged on as, in the Twitter navigation bar at the top right-hand corner of the screen, at all times.

I hope you find it useful; I know from experience that I will…

On Monday, I announced the launch of preDevCamp. There has been a fantastic global response and today I’d like to announce the fanclub that we’ve set up on Facebook.

Palm are taking some real interest in this camp and a Facebook fanclub is a great way to demonstrate the level of interest. Please show some support for preDevCamp by signing up.

While you’re at it, swing over to http://predevcamp.org and sign up to one of the events. Coding the Palm Pre is going to be a dream if you have any experience with developing with AJAX, so get involved! If there isn’t an event in your city, let us know and we’ll guide you through the process of setting one up.

As part of the preDevCamp 2009 site, I created a JavaScript TwitterFeed today.

A sample can be seen here. If you leave this page open, it will constantly update with all Twitter tweets that contain the word ‘twitter’. It will update once every 5 seconds and will contain no more than the 25 most recent tweets.

Installing this code into a page of your own is very simple. You will need the following:

• jQuery must be installed and you must include it in your webpage
• tweetFeed.js must be included in your webpage
• tweetFeed.css should be included, although the function will work without this file
• A <div> with an id of ‘tweets’ somewhere on the page

With all of those in place, it’s a simple case of instantiating the feed:

var tf = new TweetFeed(searchString,feedPeriod,feedLength);

searchString

This is the string that is used to generate the feed. The feed will contain all tweets containing this word

feedPeriod

Number of seconds between each refresh of the feed

feedLength

Maximum number of tweets to show. At the moment, this must be > 15 or else the feed doesn’t work properly.

All of the relevant code can be found by looking at the example, linked to above. Feel free to use this in any way you like. Comments are welcome

I’ve been playing with technology for nearly 25 years, ever since my parents bought a ZX Spectrum 48K for my siblings and me. My brother and I would faithfully copy program listings from books, play the games that those listings created and then merrily modify them to our own ends. We also had a huge disorganised box of Lego and whiled away many a Saturday building models from plans and imagination (for British readers: many of these models were inspired by ‘Chock-A-Block’).

As time passed, my interest in technology evolved. At school, I was developing an interest in Physics, at home I was writing my own programs on a 286s, 386s and 486s. By the time I got to university, I was majoring in Physics and working for Milford Instruments in my vacations. During that time I learnt all about writing microcode and getting chips to talk to one another.

I now work for IBM. I started in their development laboratory and, although my primary role is more customer facing at the moment, I’m still writing plenty of code.

So, why the name and what’s the aim of this blog? Well, my interest in technology is both parallel and orthogonal to my job in technology. However, I’ll be writing about both and so some of the discussions will be about ‘great’ things like Storage subsystems and Automation frameworks and other broad topics; others will be about ‘small’ things, like rotary encoders and relays and my latest home project. By keeping the lines between my home technology and work technology blurred, I can transfer my experiences from one to the other and both will benefit. I encourage you to do the same.