I’ve really gotten into programming lately. Like really started delving into in a way I haven’t done. I’ve been messing around with scripts and basic programming for some time, but I’ve never been able to complete a large project. I usually put some bits an pieces together to cobble for a function or small library, but my skills were never such that I could really put the larger pieces together. I’ve spent time looking at various libraries on GitHub or wherever, and just been floored by not only the size of the projects, but just the sheer complexity.
One thing I’ve learned over the years — not just with programming, but skills in general — is that the things that got me here aren’t necessarily the things that will get me too the next level. I’ve learned this most painfully at my current job, where the skills that enabled us to be a fairly decent small IT service shop weren’t the skills that were going to be able to scale and get us to the next level of excellence. It’s one of the main reasons that I finally decided to go back to school to finish my degree. I’ve always been self-taught, and been able to get along with whatever needs getting along, but that same self-directedness has resulted in a bit of lack of discipline in several regards.
One of the main reasons I felt like I needed to go back to school was because my projects would always get to a certain point where I wouldn’t be able to figure out how the various components should fit together. I remember thinking that I needed to learn ‘design patterns’ and that I needed the tutelage of someone who could help me understand how to put the various components together. I was always good at being able to understand the syntax and structure of a language well enough to be able to do some calculation or basic function, but being able to take that same logic and put it into the larger set of data structures and external libraries and inputs, outputs that I needed to make something work — that’s always been where I’ve hit a wall and walked away from a project for the next starting point.
I can’t say I learned a lot about design patterns per se during my college career, but what it has done is forced a lot of other things that I hadn’t considered, like test-driven development, for example. But one thing has happened in the intervening months and years that I’ve been finishing my degree — I’ve kept programming. It has become a habit — a practice — and I feel the changes in my brain, affecting how I think about problems. And things have begun falling together. I recall specifically looking at a piece of code on someone’s blog and seeing a class’s create function declared as a class function. It clicked. I’d understood the difference between class and instance-based methods for some time, but I never really understood why to use them. Same with a class passing self as a parameter to another class function. These were just two solutions to problems that I had been struggling to figure out for some time. Things are just starting to click in that way.
I’ve made a habit out of programming, and I recently found myself coming back to one of these aforementioned abandoned projects. Looking at it now with the benefit of a year and a half of additional skills, I’m not so overwhelmed, and I’m thinking I know enough to take it a little further to the point where it will actually work.