Twyste

A few days ago I gave a talk on intentionally learning and improving as a beginning developer.  Because one of my goals for this first quarter of the year is to do more writing, I used this blog post to work through some thoughts for the talk and knock off an item on my work goals.  Nice.

At the beginning of learning to program, it was overwhelming to me how much there was to learn, and I didn’t know how to prioritize importance of any of it. Today, I am still overwhelmed by how much there is to learn, but I have a better understanding of what would have been most helpful for me at the beginning.  Hopefully you can benefit from my hindsight and three-years-into-it perspective.

It is often easy for us to see gaps in technical knowledge, and those are certainly part of where one’s focus should fall when trying to improve as a developer.  However there are also many non-technical skills involved in learning and succeeding as a new developer.  In this two part blog post I am going to focus on both kinds of skills, on the things I feel are areas of competence that will make us better developers overall.

Technical Skills:

In the first of these two blog posts I’m going to cover the technical skills because they are easier for me to define and organize. I’ve realized most of these fall into the category of making things as simple as possible for us. Programming takes a lot of attention, so let’s save our brain from some of the overhead by finding ways to streamline the process, illuminate what’s actually happening as a result of the code, and save us when we inevitably make a mistake or change our mind.

Shortcuts:

There are shortcuts everywhere, for the development environment you work in, the command line, your laptop navigation, your default text editor, anywhere you frequently spend time. Make your time as efficient as possible by becoming proficient within that environment, by knowing its shortcuts and the capabilities built into it.

In your development environment: 

I primarily use Atom, Webstorm, and Rubymine, but there are shortcuts, packages, and add-ons for all the popular development environments.  These shortcuts allow you to easily navigate within a file, but can also take you directly to a method call’s declaration, toggle between camel and snake case, find interconnections between different files, jump quickly from part of your codebase to another, and so on.  Search for a cheatsheet or tutorial for the space you work in and begin to memorize the shortcuts.  There are a lot, so just pick a few to start with and learn them well, then keep adding on as you find more.

• Atom: https://github.com/nwinkler/atom-keyboard-shortcuts
• Jetbrains: https://blog.jetbrains.com/ruby/2017/05/10-rubymine-shorcuts-you-shouldnt-miss/
• Vim: https://vim.rtorr.com/

At the command line: 

When you’re working within a terminal window, at a minimum it’s worth knowing how to do basic navigation and text selection.  Learn how to copy, move, delete, and view files and folders from within the terminal.  Investigate things like aliases and search tools like grep and ack.  Your command line is extremely powerful, so find out what you can do with it.

• https://www.cheatography.com/davechild/cheat-sheets/linux-command-line/

On your laptop:

Learn how to move by more than one space at a time.  There are shortcuts that allow you to navigate, create, and manipulate most everything on your computer.  Whenever you’re using your mouse or trackpad, or pressing your arrow keys repetitively, it’s probably worth searching for a shortcut.  There are tons of cheatsheets for these.  I’ve just included one that’s helpful for some basics.

• Mac: https://support.apple.com/en-us/HT201236

Developer tools for your browser of choice:

Know some basic debugging in your browser of choice.  All the most commonly used browsers have some form of developer tools.  These allow you to see what is happening in the browser when you run your code.  You can observe the state of your data, look at your network requests and responses, view and alter the CSS of any HTML elements, view console logs, and examine way more pieces of information and information exchange than you will probably need.  Here are links to cheatsheets for three of the most commonly used browsers.

• Chrome: https://developer.chrome.com/devtools
• Firefox: https://developer.mozilla.org/en-US/docs/Tools
• Safari: https://support.apple.com/guide/safari/use-the-safari-develop-menu-sfri20948/mac

Version control commands:

Learning how to control your programming history will save you.  Errors are inevitable and can be scary, but are much less so once you know how to manage them with version control (git and others).  It allows you to review, modify, squash, revert, compare, etc. any commits.  The one caveat to this is it only works if you are committing your work along the way.  There is way too much to go into here, but these links cover largely everything there is to know about git.  Pretty much, if you need to do something, there’s most likely a way.

• https://www.git-tower.com/blog/git-cheat-sheet/
• https://git-scm.com/book/en/v1/Git-Basics-Tips-and-Tricks
• https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History
• https://chris.beams.io/posts/git-commit/
• https://gist.github.com/kdv24/43b90df359715c36393a83fdb15f571e

Organization system:

You are learning and paying attention to a lot when you’re programming.  In kind of the same vein as learning shortcuts for efficiency, make your visual layout efficient for your brain also.  The less it has to unnecessarily remember or search for things, the more it can be freed up for other thinking.  Here are some ideas I use to lessen the cognitive burden.  There is no magic to it; play with what will work for you.

Consistently locate things in the same order/placement:  Don’t make yourself have to hunt or spend unnecessary time thinking about where or what something is.  Instead be systematic in how you arrange the spaces you use.

• desktops, workspaces, monitors, terminals, windows, etc.
• terminal layout (eg, tabs:  L -> R: server, compiler, console, terminal prompt)
• browser tabs

Use visual cues:  Simplify how quickly and easily you can recognize what you’re looking at.  Make important things stand out by adding color and words.  Investigate how to customize your terminal prompt to give you helpful information.

• terminal colors
• git prompt (git status, breadcrumbs)
• consider using a timer to alert you when you should consider taking a break

The takeaway:

At this point you may realize rather than having provided you with a neatly organized resource sheet with all the commands you should master, I’ve largely given you a list of what I think you should investigate and learn more about.  That’s because the specifics of what will work best for you are just that, specific to you.  So spend the time, sift through the suggestions, and learn the parts you feel will be helpful.  It’s worth the effort now to make it easier for yourself in the long run.

Look for my next post to see which non-technical skills I’ve found to be most valuable for developers.  Because no matter how good your technical skills are, if no one wants to work with you it won’t matter.