At the end of 2015, I published a video course on getting started with web development in Go. For the next two weeks, you can get it for 50% off using this link: http://bit.ly/1PEubnd. With over 2 hours of content for just over $20, it’s a great deal. The sale runs from 21 Jan until 4 Feb 2016.

The video takes the student through every step of creating a personal library web application from scratch, covering concepts such as routing, database access, and authentication. It’s a great introduction to go, and an excellent primer to starting your own go-based web project.

All this comes with the added benefit of supporting me: your local developer. :)

Another year gone.

What I Wanted from 2015

I set some arbitrary goals for myself at the end of 2014, and I sort of accomplished most of them. Here’s a short list:

• Contribute meaningful code to several open source projects not created by me
  • Documentation to ace, features to asknot, minor fix to fireplace, minor fix to planet.indyhackers, small feature to gvp
• Read at least 1 book per month
  • I read 8 books professionally, started getting into graphic novels, and read a couple of silly books by celebrities. I’ll count this as a win.
• Attend more meetups
  • I hosted quite a few Golang meetups and attended a few ISA meetups, but I’m not sure I actually went to more meetups.
• >3000 sessions/month on this blog (currently ~1400)
  • By the end of the year, I was doing a little over 4000 sessions/month. I had a few popular posts on Go and Docker which I believe contributed to this.
• Improve social skills
  • Eh. Unfortunately, this year I largely worked on solo projects in the office which didn’t give me many opportunities to improve my social skills.
• Work remotely more and better
  • I started off the year doing this well and I was working 2 days a week from home. After one of my projects got canceled, I never managed to get back into the swing of working remotely.
• Obtain more technical leadership roles on projects
  • Technically, I accomplished this. Again, this feels like somewhat of a weak victory as I only had the opportunities to lead myself.

Surprise Victories of 2015

Not everything can be planned.

• Got paid to build a video course on writing web applications in Go.
  • I was approached via email by Packt Publishing after they recognized all of my work on my blog and Github in Go. I agreed to create a multi-video course on creating a modern web application in Go from scratch. This was a lot of fun, but also a lot of work. Since I love to teach, I may be looking for more opportunities like this.
• SEP Professional Development Revamp
  • I am a part of a continued effort to overhaul the Professional Development system at SEP. We are moving away from monetary rewards and towards shared experiences. The first iteration received positive feedback, and we are days away from launching our second attempt.
• Guides Program
  • In late October, I was asked to be a “guide” for a new employee at SEP. I jumped at the opportunity and have been lucky to help guide an all-around good guy through his first few months at SEP.
• Open Sourcing Ollert
  • We even got a few pull requests. See the repo.
• Cats
  • We got two cats, Juniper and Jelly Bean. I didn’t even know I wanted cats until I got them, but they’ve been an important addition to my little family.

Things I Worked On Professionally

I’ll keep this brief.

• Reporting tool for school administrators in Go
• Critical web bugs in a traffic radar system, primarily Javascript work
• iOS app for sending results from a medical device to client servers
• Bugs and minor features for previous client building an e-commerce website in C# ASP.NET both WebForms and MVC

What I Want From 2016

• Spend Money
  • My parents raised me to be cheap, and we always seemed to be just scraping by. These teachings served me very well in college and for the year or two after, but now I’m lucky enough to have a great job, house, wife, American dream, etc, and I’ve found myself becoming somewhat of a miser. We finally bit the bullet this weekend and bought a fancy new mattress, but I want this to be the year of me buying new stuff that I’ve always wanted but been too hesitant to purchase.
• Back Into Web
  • I got really deep into web in 2014 and the first half of 2015, and it’s a platform that I really like to work in. If I can’t find web work in the office, I’ll be making open-source web work a priority.
• Work With Others
  • This has been the year of solo projects for me, and to be quite honest I’ve found myself feeling downright lonely the past couple months. It’s frustrating to have no one to share with, to fight with, and to laugh with on a project. I intend to rail hard against any project assignment where I am the only engineer.
• Become Part of an Open-Source Community
  • I have a tendency to build my own side-projects or submit individual pull requests and never be heard from again. This year, I want to find a project where I can be a part of something bigger than just me.
• Good Vibes
  • I want to have a positive influence. I’m not 100% sure how people view me now, but I understand that I complain a lot and probably come off as a bit negative. I know that I have the power to make waves when given the chance, but I want to make sure that those waves don’t leave the surfers with a sour taste in their mouths.

So Long, 2015

A year where I didn’t accomplish as much of what I set out to, but I managed to find a few surprise wins along the way. If you catch me going against any of my resolutions in 2016, I encourage you to deride me and set me back on track; I’ll be happy to do the same for you.

I have published a video series on building web applications in Go called Go for Web Development.

These videos will guide you through the entire process of creating a web application in Go, all the way from spinning up a basic web server to multi-user authentication. In the end, you’ll learn how to vendor dependencies and deploy the application to heroku. Throughout the course, you’ll learn to utilize many of the most popular go packages including gorilla/mux, negroni, gorp, ace, and bcrypt. You’ll learn about making asynchronous requests from the browser back to the web server, and you’ll learn to access external REST APIs from your web server. You’ll use go’s struct tags to parse both XML and JSON, and you’ll use struct tags to access database entities with gorp.

I spent many late nights creating this course, and I’ve learned a lot of lessons about creating screencasts along the way. I was also able to solidify much of my base understanding of the go language and learn about many features I don’t often utilize. The videos are published by Packt Publishing, and they were a great help along the way. The most valuable lesson I learned from doing these screencasts is that a quality microphone makes a huge difference, and I would have saved myself a lot of trouble had I used my Rock Band microphone from the beginning. In the end everything turned out great. I’m relieved to be finished and excited to have an official ISBN connected to my name.

The video is currently only $5 for the holidays, but the regular retail price is set to $75 (which is still a bargain considering all the content).

Link: https://www.packtpub.com/web-development/go-web-development-video.

The Gist

Javascript: The Good Parts by Douglas Crockford is a short guide to the best parts of the javascript language. Javascript is notorious for being so flexible and feature-rich that many traditional programmers start writing code and completely forget how to program and building a startup based on an idea they got from the Bored Elon Musk mock-Twitter account only to wake up a year later cold and alone living in the slums of San Francisco. This book is full of example code with thoughtful explanations to help the average developer write better javascript and leave the web a nicer place.

Takeaways

I read this book because I thought the title was too snarky for its own good. Javascript is flexible and capable of doing nearly anything you need but, like any tool, can easily be misused by newcomers. Since javascript is the de facto language of the web, many developers who use javascript are novices or don’t think they need to know the language constructs because “it’s not a real language.” Unfortunately, this results in a lot of spaghetti code and insecure javascript being processed by our web browsers.

I studied javascript this past fall to try to hone my skills, and I found that many of the little tricks I picked up through independent study had already been collected in this book. Anyone doing javascript should have a passing knowledge of the contents of this book before they are allowed to push to production.

Now I’ll get off my soapbox and point out a few of my favorite points made in this book.

Javascripts most powerful structures are Object and Array. An Array is an Object with properties of type Number cast to integers in sequential order. This means that the Array object [0, 1, "mario", "luigi"] is represented as an Object as {"0": 0, "1": 1, "2": "mario", "3": "luigi"}.

Object.hasOwnProperty tells you whether the given property name is on the object’s prototype or has been defined on the current object. This is very useful when using a for in loop to filter properties on an object.

Although I’ve frequently used the module pattern with a self-executing function to create private scope, I hadn’t connected the dots that the reason this magic works is because of closures. Here’s an example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

var MyModule = (function() {
  var x = 0;
  return {
    reset: function() {
      x = 0;
    },
    do: function() {
      console.log(x++);
    }
  }
}());

MyModule.reset();
MyModule.do();    // output: 0
MyModule.do();    // output: 1
MyModule.do();    // output: 2
MyModule.reset();
MyModule.do();    // output: 0

MyModule contains the private variable x, which cannot be accessed by anyone who has a reference to this function. However, the internal functions reset and do do have access to the private variable. Because of this, we know no external code can manipulate our internal value and we can guarantee some amount of consistency in our code given there was no tampering of the source. Of course, closures are useful for far more than just scoping variables.

Although there are many ways to mimic traditional inheritance in javascript with new and defining the constructor method on a prototype, it usually makes more sense to use differential inheritance. Given an object named bird, we’ll make a new object named parrot using var parrot = Object.create(bird); and start setting new properties on parrot This type of inheritance uses the basics of the language to our advantage and adheres nicely to the native prototypal constructs.

Action Items

• Differential inheritance. I’ve always tried to force traditional inheritance into my javascript architecture, and it’s always felt wrong. The next time I need inheritance, I will try to use DI to utilize javascript’s prototype system better.
• Write more javascript. It’s been a while since I got to write javascript professionally, so I’d like to ensure I maintain my knowledge base over the coming months by writing more javascript on the side. As web programming is where I want to be, hopefully I can get back into building for the web before the end of the year.

The Gist

Building software teams is a very difficult task. In most organizations, managers cobble together teams based primarily on who’s available when the team is forming. Since managers can only know so much about the skills and relationships of each engineer, forming teams this way is chaotic and produces inconsistent results. Instead of management selecting teams, what if engineers created their own teams based on need, past experience, relationships, and doing what’s best for the company? Creating Great Teams by Sandy Mamoli and David Mole (published by PragProg) explores the team self-selection process in great details with step-by-step instructions on running one’s own self-selection event.

Takeaways

Managerial selection is the act of management selecting teams. Self-selection is the act of individuals deciding which team to be on

Managerial selection works really well for smaller companies as there are fewer variables. As an organization grows, it’s illogical to assume that a single manager forming a team can continue to know every engineer’s skills, interests, career path, and personal relationships with all the other engineers and managers in the company. The writers of Creating Great Teams believe that managerial selection can begin to break down with as few as 10 engineers in an organization.

Managerial selection has the tendency to treat people as interchangeable parts. Every engineer has a different personality and skillset. Project A doesn’t need “Generic Engineer”, it needs Sally and her particular brand of software development.

Engineers working on multiple projects is non-optimal. Everyone agrees that there is a cost to context-switching in productivity, but there is also a cost in engineer happiness and energy levels. The concept of putting engineers on multiple projects is guided by utilization numbers. Utilization tells a manager that Joe is 50% on Project A, so the manager also puts him 25% or 50% on Project B. Utilization-based team design treats engineers like computers as opposed to really nerdy, easily-agitated human beings.

Of course, we already know that self-selection has the potential to build really cool software. Every hackathon weekend starts with engineers building self-selected teams, and these teams are able to crank out more code in the course of a weekend than some projects team can in a month. It’s not just the lack of rules that’s making these teams more productive, but the joy of working with people you like and the motivation of working on something that interests you.

Convincing an organization to try self-selecting teams is an exercise in public relations. Everyone needs to be on-board and no one can undermine the self-selection process. If “management” decides that Betty would be better off on Project B than on Project A and moves her after the self-selection process, people will lose faith in the whole event.

People will generally do what’s best for the company. Self-selection is a socialist process, where everyone will want to feel good about the outcome. If there is a project that doesn’t seem very fun but is vital to the organization’s success, someone is guaranteed to bite the bullet and put themselves on that project for the sake of the company.

The middle of the book is dedicated to setting up and running a self-selection event. Setting up the event is a tough process and may take several iterations.

My Action Items

• Perform a trial event. At some point in the near future, I want to be involved with a trial self-selection event at my current organization. We have several outlets to do this, such as the Leadership Review or a Lunch and Learn. Although it might be difficult to put company-wide self-selected teams into practice at my organization due to the client-based nature of our work, I am positive we would have many wonderful insights from running a trial event.
• Read Daniel Pink’s Drive. Drive is about what motivates people and is cited several times throughout this book. I’ve been meaning to do this since I read Punished By Rewards, but now it’s officially on my up-next reading list.
• Read Scaling Agile @ Spotify with Tribes, Squads, Chapters, and Guilds. Scaling Agile at Spotify is a whitepaper by some of the employees at Spotify discussing how Spotify was able to successfully scale Agile within their organization by breaking groups down into smaller and smaller subgroups.
• Talk about it. I was invited to join a small book group to discuss the implications of this book after the holiday. Hopefully we can find a way to implement some small amount of self-selection within our own organization, or at the very least determine all the current blockers for doing self-selection. I’ll note that this book group is a self-selected team.