The year 2015 has been a pretty crazy year for me. I feel like I say that every year but this year, I actually have tangible proof. In one fell swoop, I moved to another state, bought a house, and had a kid. But you probably didn’t come to read this article about my personal life so let’s get into the technology of things.

Overall overview of 2015 in the web

2015 has been a crazy year for the web, as always. From the introduction of Redux, to the slowly snow-balling interest in Angular 2. There is so much more so let me go over a few of these real quick:

  1. Redux was released by Dan Abramov and has become the new default for building Flux applications.
  2. Angular 2 is steadily getting closer to a Beta release. (and finally released Beta)
  3. A component architecture has eclipsed any other approach to building web apps.
  4. ES2015 has become a standard. Not just in the industry but as a spec.
  5. PostCSS rose in popularity and became the “next big thing for CSS”
  6. NodeJS 4 and 5 were released as official new releases with a bunch of new features.
  7. Compiled-to-JS languages have become a standard
  8. Everything is virtual (virtual DOM EVERYWHERE)

There is SO much more than that but I think the six items above kind of give you a good idea of where web development headed in the past year.

First, as far as work goes

I got a job as a Senior Engineer at a company called Landdox and working on their product was pretty much what shaped the way I’ve grown with technology this year. Landdox is a single-page application that deals with contract/lease/document management for oil & gas companies. This meant a few interesting things. Namely, I had to deal with creating a UI for a folder-tree structure which involved some fun stuff on the back-end, and I had to deal with a pretty damned large JS application which I had to build from scratch.

What I’ve learned

The Year of Angular

I’ve spent the past entire year working with Angular on an everyday basis. That means I spent nearly 40 hours a week (minus meetings and Node work and vacations) every week of this year working with Angular. I honestly didn’t think I’d change my mind about Angular so many damn times.

At the beginning of the year, I was ready to throw my hands up and welcome the Overlord that is React. I wanted to join the community in moving over there but because of my job change, I couldn’t. I had to get a prototype out quickly and I simply did not know enough about React and how to work in React to do so. With Angular, I could pump out a prototype in a more than reasonable time.

Instead, I stayed with Angular. And in the end, it was a great decision. I’ve done several large refactors of the application and am currently in the middle of yet another one, bringing the code closer and closer to “perfection” (which is a lie but it gets better each time nevertheless).

My relationship with Angular fluctuated from initial frustrations with scope and the way data propagated in the app to creating an awesome workflow in Angular and finding joy in writing Angular apps. I am steadily moving toward using a directive-first architecture (or “everything is a directive”) and am converting data flow to something similar to Flux. I didn’t think I’d be there at the beginning of the year but the app started to exhibit the problems which Flux seems to fix: using the same data across several unrelated components, updating that data in different locations, and keeping everything in sync.

Most of the cruft that I had problems with disappeared in that time. Scope issues are no longer issues and with the amount of angular.copy I do (which is dirty, dirty, dirty, dirty), I found myself eyeing Immutable.JS and similar libraries.

On top of that, I’ve been working a little bit with Angular 2 and I love it! Be sure to read my guide!

Next year: I’m hoping to write a few small apps in Angular 2 to get a feel for it and explore pipes and other Angular 2 concepts

ES2015 is a standard

Earlier in the year, I converted our work codebase from ES5 + file concatenation (the simplest and ancient way of building apps) to ES6 + Browserify. The difference has been enormous. Using require/imports made much more sense on the back end AND front-end than not. And over time, my team found itself sharing small modules between the two sides of the application. Our number-crunching libraries and various filtering libraries made it to both sides of the app which was really cool to see in practice.

Outside of that ES2015 introduced me to a whole lot of neat concepts and I definitely don’t want to go back to ES5. I just can’t.

I’m looking forward to using ES2016 in..well, 2016. Especially the spread operator, Object assign, and even decorators. I never had much use for them until I started working with TypeScript…speaking of which.

Next year I’ll be upgrading our work app to use Babel 6 and (hopefully) Node 4.0 in order to take advantage of ES2016 and beyond. Believe it or not, Node 4.0 and NPM 3 have been a show-stopper for us and after weeks of trying to make things work together (in my off time), I abandoned the effort and stuck with 0.12 🙁

My next project will be in a compile-to-JS language

And I’m not speaking about ES2015 -> ES5. I’m talking about TypeScript, I’m talking about PureScript, or even Elm. I tested out TypeScript briefly and fell in love with it. I’m on the cusp of converting our work codebase to TypeScript, bit by bit. TypeScript is pretty amazing mainly because of its enormous ES2015 support but also because it allows you to use types. I found myself wanting to write-in types just about everywhere once I started working with TS.

You see, it’s not just that TS checks everything for you (that a function which returns a string is not used to supply data to an integer) but it visually lets you flow through the app better. I found myself looking at various functions in my app and wondered what the returned type was. Am I returning a number? And thus I need to post-process it in the view? (like add a percent sign, unit etc.) or is it a string? which would tell me that it has already been post-processed.

The app I work on deals with contracts and leases so the word interest shows up often but it’s rarely ever clear what it actually means. For instance, if I have a function called calculateFinalAmount and it accepts an argument of interest, Is that an actual number? (like 3.2442) is it an interest object? (like { amount: 3.2442, name: 'Standard Interest', type: 'standard' }) or is it a completely different type of interest?

With typing and interfaces, that would have been SUPER simple to solve, you could have an IInterest interface that defined an object, you could specify that your function takes in a : number and so on.

I haven’t tried Elm but have been interested in Purescript (namely because it’s still a general-use language).

The next project I start will definitely either benefit from a compiled language.

Next year I hope to get into Purescript or Elm and keep using TypeScript. I enjoy the idea of using JS in various different forms.

DevOps

Probably no one knows this but I’m quite the DevOps person. Almost two years ago, I got into it and started working with Puppet, tried out Chef, used Bash scripts to setup machines, and finally, settled on Ansible as my go-to. This year, I got to flex my skills again in order to setup a few really cool things for my work. It was doubly difficult because I’ve used Ansible only setup WordPress sites and not much else, and that was in limited capacity as well. So this year, here are some things I’ve learned:

  1. A Postgres database with permissions. I’ve always struggled at setting up DBs via Ansible and especially PgSQL with its crazy login/user system
  2. Redis instance, including a comprehensive config. Did I mention I haven’t used Redis in the past? This year I did!
  3. users and user permissions for a machine.
  4. Nginx as a reverse proxy for a Node application
  5. Node and its dependencies.

And much more. Lastly, I decided to invest some time in shipit and setup a deployment strategy for my new Node projects.

Next year: There are some new provisioning tools out like Terraform which I’d like to take advantage of.

React introduction

I wrote an article on React but before I did that, I jumped into the view framework. I definitely enjoyed working with it and will continue working with it this year (for the rest of the year) and next year. I, originally, wanted to switch to it full-time but as I said, the nature of my job did not allow me to do so.

I’ve been enjoying dabbling in it, however, and have been slowly eyeing Redux as my next target learning opportunity.

Next year: I’m hoping to have a few small Flux/React apps running and write an article on Flux. I’m slowly getting to it! I swear!

On Go

I briefly tried out Go this year and was impressed with it. I worked with it briefly before turning my eye to TypeScript but I definitely intend to go back. The one thing that always bothered me about Go was the fact that it’s still a “wild west” with no established libraries (besides standard lib) for various tasks. Take building a web application for instance. I’ve checked out a bunch of packages and frameworks but every single one has horrible criticism regarding the way it works. Either it didn’t fit the “Go way” or it used some weird objects. I don’t know, it turned me off for a minute. And the Go community wasn’t much help either.

Asking on the Go subreddit about something as volatile as what library to use for general web development, is like throwing a rat in a pit of snakes. You’ve got the one side that wants you to use standard library, then there are those guys that want you to use light abstraction libs on top of the standard library, and finally, there are those that point you toward non-idiomatic (but productive!) libraries. Urgh.

Next year: Before I abandon Go entirely to focus on JS/Compile-to-JS/ and C++, I’d like to give Go one more shot and ignore the critics. I’m probably going to pull down Martini and build myself a simple CMS. Martini seems to be the safest best.

And C++

You might find it weird that out of all the options of things to learn, I picked C++. It stemmed from a need at work: to build C++ bindings for NodeJS to work with a C++-only library that had no NPM modules ready for it. I played around with it and have recently started working on Game Development in C++ after my work efforts had to be abandoned (and we found a dead-simple CLI for the library).

C++ is actually a lot of fun to use but it has a few caveats that I struggle with:

  1. no package management (except for Linux). Package management is a standard on the web. Everyone these days uses NPM, and it’s dead simple to use, just import packageName from 'packageName' but nothing like that exists widespread for C++. Including headers, checking if a file has been already imported somewhere else upstream, and keeping my own dependencies up to date is a horrible hassle that turns me off from the language 🙁
  2. C++ tutorials are difficult to find for my skill level. I often see either super-simple stuff: “This is an array! An array holds many things” or super-difficult: “This is OpenGL! …”.

Otherwise though, C++ is actually fun!

Next year: I hope to have a few small CLI-only games up and running. I’m currently planning on building a simple roguelike which will involve learning some interesting algorithms along the way.

Check my code please

I’ve always used something like either JSHint or JSLint but this year, I decided to dig deep down and define as many rules as I could which fit the conventions I followed. A part of that was me being a good engineer on a new project, a part of it was me trying to be more rigorous about code quality. So, I went to town.

I defined simple rules on a .jshintrc which could be easily picked up by my VIM and Emacs installs (both of which prefer JSHint currently) and then I defined more difficult rules in an .estlintrc which had a double effect. One, if I had the right extensions installed in my code editors, I could get much better feedback about my code quality. But two, I could use Codacy to automatically run the rules, score my code, and even comment on my PRs with suggestions on code updates.

By the end of the year, most of the rules were second nature to me and thus I had no problems working on projects without the linters setup whilst still following the rules.

Still, I like my code checked!

Next year: By moving to strongly-typed compile-to-JS languages, I hope to garner even more feedback about my code from compilers. ESlint is also expanding more and more in terms of rulesets so I’m excited about that, too!

Uhmmm…Emacs

I’ve been a huge supported of using VIM for pretty much everything. From code development to writing, to… I guess that’s it. I use VIM ALL THE DAMNED TIME. It has issues, however, and they are ones that I could not get over. I loved using VIM in my CLI (or CMD 😉 ) and I loved having access to the same VIM with the same VIM config on my server, laptop, and desktop. Dotfiles are fucking awesome.

There are several problems with VIM though, and especially on Windows. VIM doesn’t run anything async. Using syntax checkers meant that VIM would freeze for a few seconds upon save. This is why I had both JSHint and ESLint running. JSHint cut that freeze time down to a half. When I translated my config to my Linux machine, I still noticed a lag. What gives? On a linux machine, I could at least try out NeoVim and neomake (I think that’s what it’s called) which does syntax checking asynchronously.

Well, I decided to give Emacs a shot and I..I was confused. Emacs does run in CLI but most people just recommend using the GUI. I wondered, why? Using a GUI is completely against everything I’ve been advocating! But then you find out that Emacs can run CLI commands from within the GUI and I realized that most of the stuff I need a CLI for (using Git, running Gulp, checking stuff), I could do from Emacs. And in the end, there are the “shell” and “eshell” modes which run some kind of terminal within Emacs itself.

I set it up with Evil-mode and am writing my article in it right now.

So for now, I’m a convert. Async syntax checking, evil mode, and well, the wealth of amazing features has made me switch.

Next year: I’m hoping to really customize Emacs to fit my own needs. Right now, it’s kind of ad-hoc.

SASS-powered

I’ve used LESS CSS since it pretty much came out but this year, I switched to SASS. I can’t really say there is much of an advantage of one over the other but I decided to use more of the preprocessor’s power than I have before. I managed to build a few cool automatically-compiled CSS (not just nesting, more like grid with a for loop). It’s been fun using SASS and CSS as a first-class citizen. I’d say I’m more of a programmer than anything so CSS-based stuff has been less interesting to me. I did write a LESS CSS framework but that’s been only to solve my problem as a programmer: building prototypes quickly.

With SASS, I found myself becoming a programmer of my CSS rather than a declarer. If that makes sense.

Next year: I’m hoping to expand my skills to get into PostCSS and CSS animations. I’ve been a big fan of CSS animations but never spent my time working with them beyond simple transitions.

Security

A topic I haven’t previously researched, security has become even more important this year than ever. With the news of constant breaches, I decided to subscribe to a Security podcast. It took little time for me to get into a rabbit hole of an entire industry hidden to web developers, and hidden to even sys administrators. I spent better half of the year learning how I could make myself a better and more secure developer. From learning about CSP headers, to recognizing the various ways my own code doesn’t check against intrusion/malicious requests. I’ve also been looking at system security.

It’s definitely been interesting.

Next year: who knows?! 🙂

What about the site?

My site has received a total of 13 (14 with this one) articles since last year. That’s my lowest count since I’ve started. It’s horrible, deplorable, and yet, I like writing this way more than before. I used to write an article a week! Isn’t that crazy? Now, I do about 1-2 articles a month, if that. The reason I prefer this format is the simple fact that I get to writer higher quality content. This year alone, I wrote two extensive guides, one on React and another on Angular 2 both of which got way more attention than my previous lesser-quality 4-5 per month articles.

Oh and by the way, if you’re interested in seeing how this site evolved over the past several years, check out my continuously updating Throwback Thursday post.

Top articles for the year

Picks are slim but here goes:

Community

I’ve been involved with the community more than ever. I contributed to several projects along the way, updated several of my own and my blog posts have made rounds and rounds throughout forums.

The only downside with having that kind of involvement is the backlash to your ideas from some users. My article on development passion garnered over 500 comments on Reddit, many of which were very negative, and some that were personal attacks on me. One user, in fact, said that I am the “cancer that’s killing web development”. And while I’m not sure in what ways web development is dying, I took that insult very personally.

I was just about to give up writing for my blog when I released my article on AngularJS 2 and the overwhelming positive response made me reconsider things. I’m definitely more interested in writing higher-quality stuff and contribute to the community with in-depth articles and tutorials rather than throw-aways and linkbaits.

But in the end, I think I’ll ease off. Wait for my sabatical announcement soon. I feel like I have too much on my hands and some of the extra attention I received has not always been positive and even if it was positive, it’s been exhausting.

I’m also having a weird relationship with Reddit and other social media. The content there is no longer as “great” as it used to be. At least, that’s my perception. There are no in-depth articles, nothing surprising, nothing “life-changing” as I used to feel there were. Not even on HN. The commenters often don’t offer any real discussion and the plethora of negative comments are a turn off.

I think it’s about time that I start getting involved with discussions with real-life individuals rather than mass anonymous-like communities that offer no value.

Next year?

I wanted to compile the notes on what I want to do next year down here plus add a bit more based on what other brand new things I want to do.

All of the above

  1. updrading to Babel 6, Node 5, and taking advantage of ES2016
  2. try out Purescript or Elm, keep using Typescript
  3. use a tool like Terraform
  4. explore Flux + React architecture for smaller apps
  5. give Go anothers shot, focusing less on “doing things right” and more on “doing things”
  6. create a simple roguelike game in C++
  7. customize Emacs just as I customized VIM
  8. get into PostCSS
  9. learn more about application security

Other things

Some stuff I’m really interested in:

  1. RxJS and reactive programming
  2. mobile app development – either via NativeScript or ReactNative

But Mostly

I want to learn more about computer science and the details of things. I’ve been thinking about it and over the past several years, I’ve been wondering if I ever lost out on anything by dropping out of college when I joined my first startup. I’m sure I have so I decided that 2016 will be the year when I use open courseware, free education, and various paid courses (like on Udemy) and use those to catch up on what I’ve lost.

My hands-on experience has been invaluable and I would suggest it to anyone but I think a two-prong approach is the best. If you’re in college, get some freelancing/contracting experience in as soon as possible, hopefully before you start diving into heavy-duty CS classes. And if you’re getting into things from a bootcamp, or like me, self-taught, go learn some proper CS.

Personal Life

I rarely ever talk about my personal life but if you’re interested in what I’ve been up to, here’s a quick summary:

  1. I moved to Colorado.
  2. Had a lovely daughter: Liv.
  3. And sacrified months of sleep to her.
  4. I wrote another NaNoWriMo book.
  5. Self-published a NaNoWriMo book.

Conclusion

At the beginning of writing this article, I was kind of bummed. I felt like I haven’t done much this year. And in fact, I feel that way just about every year. I wrote a quote last year:

“Despite thinking I had slowed down on my learning endeavor, I’ve sped it up to tremendous velocities.” – @antjanus

It has been true this year as well. By the time I finished my article, I realized I had done more this year than I had set out to do. If you follow that article, you’ll get to my goals/experiences from 2014, and 2013. I hope to follow this tradition for years to come.