I'm learning PHP. Technically I'm re-learning it, as I learned it many years ago (version 5.0 if I remember correctly), but between the passage of time ravaging my memory and all of the new features in it and the infrastructure around it, it feels like learning it for the first time.

I understand that the accepted thing to do with PHP is complain about it instead of writing programs in it, but I have no intention of doing that. PHP is a good language that is constantly improving and it has some amazing tools springing up around it. What I want to talk about is the experience of going from a static, strongly typed language to a dynamic, loosely typed one.

I'm working in PHP because reasons (as the young people like to say) and the time frame I'm trying to work with is shorter than would let me thoroughly learn one of my dream languages like Erlang or Elixir. Until six months ago, I was a Java programmer and had over 20 years of experience in the language having worked with it since version 1.0 back in the mid-nineties. I chose not to work with Java for a number of reasons, each of which deserve their own blog post, but basically I don't trust Oracle's stewardship of the Java language and Java web frameworks are generally gigantic monstrosities that I find to be a pain to program in. (I also seem to be entirely unable to overcome my irrational hatred of Spring, so that doesn't help.) The Java language itself is still nice and I continue to like it, but everything that surrounds it these days is questionable to my way of thinking.

As a corporate Java programmer I had gotten used to having certain tools available. A selection of IDEs (Integrated Development Environments), build tools, testing tools, coverage tools and code quality tools. These are all great and switching to PHP felt like leaving my safety net behind. I looked into the choices of frameworks in the PHP community, but while it looked like CodeIgniter was the best fit for me on paper, when I started looking into it, the usual challenge of having to do everything exactly the way the framework wants you to started annoying me even before I'd finished the Hello World example. The data access language that kinda looked like SQL, but wasn't actually SQL was the final push I needed to say I'll just use the standard libraries and carefully code things myself. My technical needs on the project are gentle and I honestly think that it is small enough to get away without a framework. (Certainly if I was using Java I'd be tempted to just use servlets and JSPs, maybe Struts if I got to feeling frisky! :-)

I decided to work at the local coffee shop this morning as my father-in-law is visiting and his bedroom is my office while he's here. I'm ordering my bottomless cup of coffee and trying really hard to ignore the pecan sandies that are calling my name when the young lady taking my order started peering at the Apple iPad they use as a sales terminal in a really strange fashion. She notices me noticing her expression and explains that their software was updated over the weekend and now it was harder to use. She was particularly upset about the smaller buttons on the screen.

I felt obliged to apologize on behalf of every computer programmer in the entire world for the difficulties that this update brought. I joked that we're all evil and we like making people's lives more difficult. And then it occurred to me that just based upon the evidence my server had available to her, programmers might as well be evil. We push updates that pass (hopefully) all manner of internal reviews including User Experience, but then when an actual user uses it, it is found to be worse.

Let me say that again:

"based upon the evidence my server had available to her, programmers might as well be evil."

Grand Staircase-Escalante National Monument, Kanab, United States by Patrick Hendry

It seems to be the thing these days to slam members of the generation known as the Millennials. I understand that this happens with every generation. I'm in the unimaginatively named generation X and I recall people despairing that we'd ever get ourselves pulled together and ready for real life. Somehow we managed, but looking back I understand how they might have worried. We had our fair share of slackers and trouble makers, with the punks, goths and skinheads. And before my generation were the Baby Boomers. They certainly had slackers with their hippies, flower-power girls, stoners and potheads.

Every generation has a full spectrum ranging from the slackers to those who are determined to get after it and make things happen. Proclaiming that Millennials are bad because they have idiots, or the current batch of youngsters are a waste of good oxygen because some of them eat Tidepods(tm) is to ignore this. Rather, what does seem to vary from generation to generation is the fundamental world-view that they have as a whole. And that's what I'd like to talk about here.

Excessive branching has long been a problem in the use of source code management systems. First, because branches were difficult and expensive (in effort) in Subversion and then because they had a tendency to proliferate in Git once they were made almost effortless.

There are a few situations where branches make sense, but generally they cause mini-silos that obscure more than they help. I stumbled upon this talk from Thierry de Pauw and I liked it so much, I had to share it here. Despite the click-bait title, he sticks to a comprehensive explanation of why trunk-based development makes sense and how it avoids the mini-silo problem of feature branching.

During the talk he refers to a great blog article by James Shore called Continuous Integration on a Dollar a Day. This is well worth your time to read. After all, who doesn't want an excuse to take a rubber chicken into the office?

Today ended up being an errands and sorting through junk kind of day. In the realm of electronics, I tend to be an early adopter and then I hold on to stuff for way longer than necessary.

This means that when I periodically clean out my storage bins, cupboards and drawers, I have a history of finding technology that looks like Noah carried it down the ramp and off of the ark. The Palm device is approximately 10 years old and the phones are perhaps a couple of years older than that.