I Was a PHP Programmer with 1 Year Experience 20 Times

OneYear20Lots of Wrong Experience

A number of years ago I was doing research on juvenile gang violence.* Over a period of about 12 years I went out with a police gang unit and gathered data on gang-related violence. During that time, personal computers were coming into vogue, and I thought that it might be a good idea to set up a database for the gangs so that the gang unit could help prevent gang violence and solve cases of gang violence. The cops in the gang unit liked the idea because they could have a database that pin-pointed the kind of crime they were tasked with preventing and investigating. The more general police department computer ran on a VAX and while they had a decent database, it was more for administrative goals than investigative ones, and the investigative elements were far too general to be of much use to the gang unit.

During the discussion with the head of the gang unit, one cop came up and said, “I’ve got over 20 years experience dealing with these punks, and they only thing they understand is a thump on the head.” His comment was duly noted, and after he left, the head of the gang unit turned to me and said,

He doesn’t have 20 years experience. He’s got 1 year experience 20 times.

He was telling me that after his first year, this guy never bothered to learn anything new; he just kept recycling the old knowledge.

A PHP Programmer with 1 Year Experience 20 Times

Over the years that I’ve been programming, I’ve learned new languages and new techniques in languages as they developed. Like most others, I started with sequential programming and quickly graduated to procedural programming. However, I got stuck with procedural programming and for the next 20 (or so…) years that’s what I did. I programmed in several different languages, but other than an experimental flourish in OOP, I just cranked away with my old habits that I had learned when I first started programming. However, in 2005 while doing some work for another programmer, Jonathan Kaye, who has a PhD in computer science from University of Pennsylvania, I was introduced to State Machines. Now State Machines (or Finite State Machines), require a different approach to programming. Using statecharts was a lot different than those old flow charts (that I never used anyway), and I had my first epiphany in looking at a program from a wholly different perspective. From State Machines, I found the State design pattern, and very quickly I found myself immersed in OOP.

I had been like that cop who had 1 year experience 20 times. Not only did I know a lot of languages, but I was advanced in several. However, I was not advanced in my thinking about programming. I was back doing procedural programming that I had learned my first year of programming.

A Trip to the 10th Floor

Once I got going, it was not an incremental climb.

It was like taking an express elevator from the basement to the 10th floor.

An insight here, a class there, and before I knew it, I was able to think OOP. I didn’t plan it. It just happened. Now the route I took was not with any language I was comfortable in. I was comfortable in and using ActionScript 3.0, PHP, JavaScript and coming along with ASP.NET/C#. Of course I knew BASIC from the old days, but I had switched from using VB to C#; so I wasn’t actively using BASIC at all in any form. Head First Design Patterns had just been published and the authors took the time to work their way through examples explaining problems developers would have as new requirements were added and changes made to an existing program. All of the examples were in Java, and I had to translate them into ActionScript 3.0 and PHP. It was not easy, but it had the added benefit of having to pay attention to the reasoning behind design patterns and not just copying and pasting code. The authors had advanced degrees (one a Ph.D and the other, a Masters) in computer science from Yale University; so I had no fear that they didn’t know what they were talking about. (That can be a problem…)

Anyway, the process was liberating. Instead of getting 1 year experience 20 more times, I was getting new experiences and finally growing as a programmer. Now, when I look at a programming problem, I look at it differently than I did for the first 20 years….and from the 10th floor.

I would be very interested in hearing any of your experiences. Use the comment section to relate your PHP experiences with OOP structures and the pros and cons of OOP approaches to PHP programming.

*(I really did gang research for over a decade. Check out this book.)

Share

Copyright © 2013 William Sanders. All Rights Reserved.

4 Responses to “I Was a PHP Programmer with 1 Year Experience 20 Times”


  • Bill,

    As a fellow boston php percolator, I just want to say this was a nice, helpful read. I’m coming later in life to PHP after trying to tackle a website/business problem that WYSIWYG wouldn’t handle. I’ve known there’s an OOP world that seemed a bit daunting, but it’s encouraging to know that others have made the late journey ahead of me and found it worthwhile.

  • Hi Chuck,

    OOP is like opening a new door. The trip in OOP has all of the discovery that’s so much fun when programming is new. I was surprised how quickly it came along after some initial insights.

    Cheers,
    Bill

  • Hi Bill,

    I have had the same experience. After getting a degree in computer science in the early 80’s. I spent a lot of time going down the procedural path. It was when I decided to take a stab at ruby and rails that I fought my way into oop. I’ve since brought that back around to php as well. I still find however that for quick scripts I lapse back to procedural. I find it still takes more forethought to get oop to happen. I don’t always know how I’m going to solve a problem until I’m well into it.

  • Hi Jon,

    I know what you mean. (I had my head so far into FORTH at one time that I was thinking in postfix notation.) For me and PHP, it’s been a gradual slide, but then I started thinking OOP. Instead of thinking in terms of “steps” I began thinking in terms of blocks that got things done. The more I thought about programming in larger blocks, procedures became methods and variables became properties–objects, of course, were just objects that accomplished something.

    It took me a while to get used to the idea that breaking a big problem down into small elements where each element (class) should only have a single responsibility was a better way to program. I wanted to see how much I could get into a single line. (Back in the old days when non-professional programming was all club-based, we used to have 1-line contests to see how much we could do in a single line.) When I started farming out all of the different work to separate classes I somehow thought that I was “wasting space”, but now I see too much done and I think, “Well, I could farm that out…” and the secondary thought it, “…and reuse it again!”

    Kindest regards,
    Bill

Leave a Reply