Words and Code

One writer’s journey from words to code.

A Year of Tuesdays

A year ago, I had this idea: I was going to write things down. To be clear, this wasn’t a novel idea, and definitely not a new one by any stretch of the imagination. But it was something I wasn’t exactly in the habit of doing, and the first day of a new year seemed like the perfect excuse to begin creating this new habit.

So, I decided to start writing down all the things I didn’t know, and make an effort to learn them. I honestly didn’t know what I was going to be writing, and I didn’t know if any of it would be well-written, much less worth reading. All I was sure of was that I was going commit to doing it wholeheartedly, just once a week — not for anyone else specifically, but really just for myself. Thus began a year-long adventure of researching, writing, and sharing all the things I would discover in my first year as a software engineer in my very first developer job.

Today brings me to the end of the road on this journey of Technical Tuesday blog posts. And just like the first day of a new year, the last day of a soon-to-be-gone year is a seemingly perfect time to do some reflecting on a year of Tuesdays.

A few months ago, I had the privilege of being a guest on a podcast called Metaphorloop. One of the topics that came up was the nature of learning, and how teaching and learning interweave together to form an intricate, and somewhat inherently complicated web. We also talked a bit about this blog, and the process of actually writing a technical blog post.

Over the course of our conversation, I realized that my approach to technical writing is, highly likely, a rather unconventional one. There are plenty of blog posts out there that explain how to implement a technology, or break down a concept, and many of those posts are incredibly helpful, logical, and systematic in their approach. But I’ve always written with a kind of stream of consciousness kind of flow, as though you and I were sitting together, trying to work through a new gem or tough computer science theoretical concept together.

I was curious to see if there was a way to prove my approach to technical writing in some way or another, so I decided to take a look at the words I use when I talk about code. And boy, was that a revelation. The words I use when talking about code aren’t neccessarily logical, or even rational. In fact, they’re incredibly intuitive, and emotive. For example, I use the word fear in seven different posts. I also used the term afraid twice, and the word scared three times. Yet on the other hand, I used the word love ten times, and easy 46 times.

Maybe this is a sign that I’m not a great writer, or that I need to perhaps buy a thesaurus. But I also think that it’s a great metaphor for what I’ve learned over this whole year of writing these Technical Tuesday posts: even the most technical things aren’t based wholly in logic, and that caring about our code, and our efforts to make it elegant, beautiful, and concise are rooted far more in intuition than in logic. Perhaps what makes for good code isn’t that which we can explain or put our finger on as a better approach; instead, maybe it’s what we can’t quite rationlize, but what we feel to be right, beautiful, and a more elegant way of doing things. I never would have thought that this was the case unless I had spent a year of Tuesdays trying to teach myself, and by extension, a reader whom I don’t know how to learn something completely new and unfamiliar.

Even though this year of Technical Tuesdays has finally come to a close, this blog will stay around, and I’ll continue to write new posts here every once in awhile. After all, I’m nowhere close to the end of my list of things to learn about! Who knows, maybe I’ll come back to writing technical posts on a regular basis sometime in the future. But for now, it’s time for me to try something new.

I’ve written about the benefits of technical blogging in the past, and how one of the greatest draws of maintaining a blog is the personal benefits that it provides. To be honest, I started Technical Tuesdays from a slightly selfish point of view, with the hope that I’d keep a diary of sorts of my first year as a web developer, and all of the things I learned along the way. But it turns out that this blog evolved into something much larger than just that.

I have connected with people from around the country and across the world because of it. I have learned new ways of doing things, and improved my own code and refined my own skills as a side-effect of writing to explain things to others. Over this past year, I’ve received comments, tweets, and even pull requests(!!) with feedback on how to write and code better. I also recently learned that this blog has been read from Senegal to Kazakhstan, from Iran to Fiji. This little idea I had a year ago has proliferated into something that has been read by programmers in far corners of the world, and it has made me realize and feely deeply appreciative of how wonderful and widespread the Ruby and Rails community truly is. I am immensely grateful to be a part of it.

So, to those of you have been reading from the beginning, and to those of you who might have just stumbled up on this little corner of the web:

Thank you, and happy coding.