A secret key to 'Senior' level programming

When I first started in DP ('data processing', we called it then) 20 years ago, I was working for a company that acted as an outsourcer for banks. I started with the company as a trainee, then graduated to the first programmer 'rank' of Junior programmer. Internally, this title carried the cryptic title 'E07'.

I soon found out my company ranked programmers in this way:
Junior programmer = E07
Programmer = E08
Senior Programmer = E09
Superhero = E10 (a very rare breed)

Payscales, of course, were tightly coupled to these ranks, much the same way they are today.

Like all junior programmers, I hoped to spend my required year or two in the E07 ranks, then move up. One thing I was lacking, though, was an understanding of what made the difference between the programmers that went to the very highest ranks and those who stayed in the lower levels.

One day I was working on a project with a kind-hearted E10 named James. We were having a friendly conversation about the kinds of tasks we had ahead of us when James made a profound statement. He said "The work is all the same, whether you're an E07 or an E10".

I was dumbfounded. Not until that moment had I realized that the work I was doing was just as important to the success of the project as the task James was working on. I was doing analysis and coding, James was doing analysis and coding. Even though he worked at the stratospheric E10 level, he used the exact same compiler I used, he worked on the exact same data I worked on, and he used the exact same development environment I used. A failure on his part would embarrass the shop, and a failure on my part would embarrass the shop. In the context of this project, we were peers!

Now, don't get me wrong. Junior programmers are most certainly NOT worth the same money senior programmers are. Today, I depend heavily on widespread recognition of this fact. But at that time, I gave this matter a little thought and came up with an observation that has benefited me immeasurably, to this day.

I looked to my friend the E10 and asked myself what the difference was between his skill set and mine. I drew the conclusion there were at least 2 areas in which he was superior: breadth and depth.

Breadth meant that he had a much wider array of tools at his disposal. At that time, I possessed a moderate amount of knowledge about batch COBOL programming. My friend was knowledgeable about batch COBOL, online COBOL, assembler, JCL, system skills, and more. In today's world, this would equate to something like a Java guy standing next to a Java guy that also knows C++, C#, Ruby, Python, Erlang and a good number of frameworks for each. If the project du jour is just plain Java, those two are on equal footing. But when the next project comes along things could most certainly be different.

The other dimension is depth, which refers to the amount of knowledge held in the workplace domain. In my yesteryear story, I knew how to write and compile my COBOL program, maybe even as well as my friend. But if my program had a bug, I had one trick up my sleeve-- diagnostic debug statements. My friend had that and the ability to read core dumps, knew how to make the compile listing show assembly language (which he could look over for performance heuristics) and more. In other words, beyond the surface of the program source code we produced, he had a much better understanding of the platform we were operating on and how to exploit it. Again, my source code might have been a match for his, but if we needed to go to the next level..... there was an indisputable difference.

In today's world, this might mean the senior guy understands how to tune a JVM, or how to extract meaningful data from profiling tools. The senior level guy knows how to install, configure, debug and profile the platform. The senior guy will know how to establish the build environment, the junior programmer will likely only be productive once it's established.

So I guess I figured out that I had a lot to learn, and set about trying to increase my own depth and breadth. (An effort that continues to this very day!) James' words from two decades ago have helped me measure myself against my peers to see where I need to improve, and this has furthered my career in more ways than I can imagine. If you're on the young side of your career, I hope they can help you, too.

Happy Coding!

Rick

E-commerce in PHP

I recently had a chance to sit down with a workplace friend of mine who specialises in writing UI applications. I really don't spend a lot of time in that workspace, so I was happy to listen to what my friend had to say about current trends in UI authoring. The discussion was mostly about the right parts to use in building a corporate portal, but I was shocked when my informed friend told me a great amount of the high-volume online work is actually backed by PHP and C.

Everybody likes PHP, right? Mostly I thought of it as a hobbyist's language, though. Clearly, I have some learning to do about the things making today's cash registers ring.

Luckily, Packt Publishing has just the title to help enlighten me. It's called "PHP 5 e-Commerce Development". I started with the free sample chapter, which can be found here.

The table of contents looks promising, so I hope to get some good insites from this book. Watch this space for a review soon.

What in the world is a "List Comprehension"?

Sometimes I'll read something about a programming language I don't know and I'll be a little curious about some term I'm not familiar with. The writer will rave on and on about how great this language is because it supports this thing, yet I don't understand what it can do for me. Until recently, this is how it had been for me with "List Comprehensions".

Well, I found an excellent explanation of List Comprehensions in Erlang. Here's my thumbnail explanation:

"A List Comprehension is a way to apply some function to every member of a list."

Now, for an example. Here's an example, straight from the Erlang shell:

1> AList = [1,2,3,4].
[1,2,3,4]
2> ListDoubled = [ X * 2 || X <- AList ].
[2,4,6,8]

Let's look at this, line by line.

1> AList = [1,2,3,4].
This is me typing in the List I want to start with. Obviously, it contains 1,2,3, and 4.

[1,2,3,4]
This is the Erlang shell, responding with the right hand side after binding the list to the variable AList.

2> ListDoubled = [ X * 2 || X <- AList ].
This is the List Comprehension. It reads something like this: "A variable named ListDoubled should be bound to a new list made from applying the function "some variable times 2" to every item in an existing list, which is called "AList".

[2,4,6,8]
This is the result of my List Comprehension. As it should be, every member of the first list was doubled.

So that's it! A List Comprehension is just a very compact way to apply some function (and some filters, it turns out) to a list. The result is another list.

For more on List Comprehensions, I'd refer you to the excellent book "Programming Erlang" by Joe Armstrong. It's very readable, and makes learning new concepts easy.

Happy Coding!

Rick

Book Review - "Funambol Mobile Open Source"

Book Review for "Funambol Mobile Open Source"

If this book sounds interesting to you, it can be found here.

I've just had the chance to read a copy of "Funambol Mobile Open Source" by Packt Publishing. Here's a quick review of what you'll find in this book.

First, for those of us who haven't heard of Funambol before-- it's an open source platform for synchronizing data on mobile devices. Funambol will let you keep your email, personal contacts, and other data kept current on multiple devices. The server is available for Windows or Linux and is easy to operate.

The book is really two books in one-- the first part is a well-detailed user's guide, the second part is a developer's guide for those who want to develop software rather than just use it.

Part one covers product installation, an explanation of the application architecture, user administration, e-mail, PIM (address book and calendar), and the Funambol community.

Part two brings starts the heavy technical content. It contains SyncML (the protocol used to pass data back and forth between the Funambol server and the various devices it connects to) and a detailed chapter on how the reader can extend the server's Data Synchronization Service.

Being technical by nature, I enjoyed the content of the last two chapters-- there were some really good ideas there about how to extend Funambol if it doesn't do exactly what you need it to.

All things considered, I'd think this book would be great for anyone who has a need to syncrhonize data across mobile devices. The first part of the book really is user-friendly-- it starts from ground zero and presents all the steps necessary to use Funambol in a clear and logical manner. There are many screen shots, and everything is spelled out in sufficient detail. This part of the book reminds me of really well written professional-grade documentation. (Except it's written in sort of a use-case manner, leading the reader alongside a mythical user of the application as she sets up her system.)

If you're in the market for a data synchronizer for your mobile devices, give this one a read!

Happy Coding,

Rick

Let's go Funamboling!

Funambol Mobile Open Source available here


What's that, you say? You've never been Funamboling? Well, that's good, because neither have I. In fact, I believe I've just made that word up, so we may very well be the first people ever to "go Funamboling"! So what does that mean?

As a programmer, I'm always interested in learning new things, especially if I can put them to some practical use. In the recent past, I've studied R, Drupal, and Erlang, to name a few. Sometimes I learn something I can immediately add to my programmer's toolkit, and sometimes I just learn something different to keep my brain elasticity up. In that spirit, I will soon offer a review of a Funambol book, something I have never touched before.

Funambol, which I have just become aware of today, is an open source technology used to synchronize smart phones and other devices with PCs. Using Funambol, you can keep your calendars aligned, sync your email, and keep your notes in order on multiple devices. It has Java and C++ APIs, so I'm hopeful I'll be ready for the code portion if not a master of the problem domain immediately. It sounds interesting, so it should be a good learning journey.

If this sounds like something you might try, I'd encourage you to check out some of the videos on YouTube. (There are a bunch! How did this thing get so big without me hearing of it?) One such example is here.

The book's in the mail, so watch this space for tales of my ventures into Funamboling soon!