When I started out developing software over 15 years ago, I was using Java and C++. To me, at least nostalgically, this was the heyday of the languages which I knew.
That might seem like a rather peculiar thing to say, given that I was just starting out, and that I’ve spent the majority of my professional software development career developing web-based applications using PHP.
But in my mind got lodged this idea that Java, C++, and other similar languages were “real” languages, and that anything of a “lesser" nature was not up to par.
Why? Probably because languages such as these demand so much more of you than dynamic languages do — especially C/C++. Add to that, a language where you could get up and running so quickly implied that you didn’t have that much skill.
For what it’s worth, I know that this assumption is completely false. But it niggled at me for quite a long time, as though it were true.
What Does That Mean - Specifically?
To put it into greater context, when I first started out developing with PHP it was early in the 3.x series, around 3.14 if memory serves correctly. I was creating simple, database-backed, websites with MySQL 3.x as the database of choice. Who didn’t in those days?
In addition to this I was rather young, especially to software development and had no mentor to guide me. Add all of those things together, and it setup in my mind a preconception that using PHP meant that you were not a serious developer, more of a hobbyist.
As a result I had the need to be validated as a “serious developer." So I felt that stepping away from what I considered serious languages was a step in the wrong direction.
But funnily enough, until quite recently I’ve not gone back to them. I stayed with PHP as it continued to make inroads into all kinds of areas. I stayed with it as the tooling grew, the language expanded, and the ecosystem matured.
I stayed with it and as a result, have had so many fantastic opportunities in so many places, and made a host of good friends in more countries than I care to count.
Reading between the lines then, it’s a language which I’m very proud of and plan to stick with for the foreseeable future. But that doesn’t mean that I want it to remain as the only language I use.
While it’s provided me with so much, it’s well past time that I return to my polyglot roots and use it as part of a larger set of languages again.
But Which Language(s)?
The question is, which other ones should I use? There are so many to choose from that I’m overwhelmed with choice. I could return to Java starting with Java Spark. I could get into C/C++, even C#.
I could look at Go again and spend more time there. And I could look at languages which seem to sit between the languages I’ve already mentioned and PHP, such as Erlang, Haskell, Groovy, or Clojure. All are quite compelling from what I can tell.
But I don’t want it to be a purely gut decision. So, I feel that it’s best also to be pragmatic from a career perspective.
Is using a veteran, big-business language such as Java a pragmatic choice. I’d get to return to my roots, and use a language, which despite much criticism over the years, isn’t going away.
Should I use the veterans, the stalwarts, of UNIX languages — C & C++? One or both of these would, if to no-one else, tell me that I know what I’m doing, and I could finally get that monkey off my back.
By using one, or both, I could also branch out from web-development, into a range of other types of software development disciplines, such as embedded, SCADA, and Linux kernel development.
What about Go, the latest, coolest language around? Just by using it, I could be one of the hip kids. Let’s be fair, there’s a lot going for Go, even if you just look at its simplicity.
So, which language to choose from. Honestly, it’s hard to tell. At the moment, what’s especially clear to me is that my frame of reference is web-based development and micro-services.
Given that, instead of picking a language and assessing what I can do with it, perhaps it’s best to pick languages which I can build micro-services and web apps with, yet which also can be readily applied in other contexts.
Then, when a solid grounding’s been laid down, start using them for other kinds of application development.
I’ll be honest though, in saying all of this, I’m already thinking about a few key ones, those being Java, Go, Groovy, and Clojure.
## A Pragmatic Approach
Since it’s hard to make a decision from the outside looking in, here’s an approach I believe will be a good start. I’m currently building an application in Zend Expressive.
The application’s purpose is to help me monitor what I eat and drink and how it affects my mood (I was diagnosed with leaky gut syndrome 12+ months ago).
So, I’m going to finish building it, and then re-build it in Java, Go, Groovy, and Clojure.
That way, I can both get my hands dirty with each language, whilst working on a project which has meaning and value to me. That way it’s not a vague, hello-world style, example.
Each of the repositories will be available on my GitHub account. That way the process will be a very open and transparent one.
None of them are there yet. But I’m planning on dateing the Zend Expressive version not long after ZendCon ends. Given that I’m giving two talks there, that’s got my main focus at the moment.
After that, I’m going to rebuild the application in each of the versions, taking the following points in to consideration:
- Domain-Driven Design
- Test-driven development
- Behaviour-driven development)
To me, it’s imperative that whatever languages I begin learning, that they need to have a formalised structure for implementing both of these.
If they don’t, no matter how compelling their feature set is without these, then I can’t be completely confident that what I’m developing is truly functional.
In Conclusion (tl;dr)
Anyway, thanks for listening. If you’ve found yourself in a similar position, I’d love to know what approach you took.