L3MON4D3/LuaSnip

Lua snip lets you define and trigger snippets in a really powerful way.

ThePrimeagen/harpoon

Tags on steroids - [makes it super easy to change buffers & ‘tag’ buffers](https://github.com/makes it super easy to change buffers & ‘tag’ buffers)

nvim-treesitter/nvim-treesitter

Treesitter is a marvel. It parses your grammar, allowing you to render the language properly (syntax highlighting works!!)..but also allows you to do some other funky things like make vim text objects.

Other cool plugins related to treesitter include

• nvim-treesitter/nvim-treesitter-context
• nvim-treesitter/nvim-treesitter-textobjects
• nvim-treesitter/playground
• Wansmer/treesj

tpope/vim-fugitive

Fugitive is not perfect, but it’s pretty close. It can do a load of Git stuff natively from within vim.

Some other git-based plugins include:

• lewis6991/gitsigns.nvim
• sindrets/diffview.nvim
• akinsho/git-conflict.nvim
• f-person/git-blame.nvim

ellisonleao/glow.nvim

Renders a cool markdown preview

folke/which-key.nvim

Reminds you which key does what… and also provides a pretty decent global way to define keybindings.

gbprod/yanky.nvim

Provides a good ‘emacs kill ring’ substitute

hrsh7th/nvim-cmp

• hrsh7th/cmp-emoji
• hrsh7th/cmp-nvim-lsp

jbyuki/venn.nvim

Totally crazy way of drawing in neovim.

knubie/vim-kitty-navigator

There are alternatives, but this one lets me seamlessly navigate between vim splits and kitty panes.

linty-org/readline.nvim

emacs keybindings FTW. Sometimes I like using readline shortcuts in insert mode.

lukas-reineke/indent-blankline.nvim

Makes dealing with JSON / yaml a little more tollerable.

max397574/better-escape.nvim

jk to esc.. .but in a nicer way. mfussenegger/nvim-dap

michaelb/sniprun

Turn loads of code / files into a repl in a magical way ✨

mickael-menu/zk-nvim

zk is a nice plain text note-taking assistant. The nvim integration is sweet.

nvim-neotest/neotest

A fairly comprehensive testing framework. Using extra plugins (eg. nvim-neotest/neotest-go), you can add shortcuts to “test the entire file” or “run the test my cursor’s over”

neovim/nvim-lspconfig

LSP is a must. It’s kind of fiddly to set up, though.

numToStr/Comment.nvim

Commenting as it should be.

nvim-telescope/telescope.nvim

A neovim tour-de-force of engineering. This gives a nice frontend for searching.

I like these plugins

• nvim-telescope/telescope-frecency.nvim
• nvim-telescope/telescope-live-grep-args.nvim
• nvim-telescope/telescope-ui-select.nvim

nvimtools/none-ls.nvim

This is the successor of Null-ls, which allows you to add things like linting, formatting and code actions super easily using a standardised API. Null-ls has been deprecated now. This seems to be a community effort to continue the good work!

jayp0521/mason-null-ls.nvim works well with this,

ray-x/lsp_signature.nvim

rest-nvim/rest.nvim

HTTP is so much better in plain-text, rather than in Postman / Insomnia.

stevearc/oil.nvim

My favourite file manager - everything is just a plain old nvim buffer

tpope/vim-surround

Tpope is an old-school vim legend. These other plugins are also really good

• tpope/vim-dispatch
• tpope/vim-repeat
• tpope/vim-unimpaired

williamboman/mason.nvim

Mason lets you easily install LSPs and other dependencies. It works great with williamboman/mason-lspconfig.nvim

zbirenbaum/copilot.lua

Github Copilot integration in vim ❤️ Useful with zbirenbaum/copilot-cmp

From my perspective, I find it scarily good at programming. It’s by no means infallible, but I find it REALLY useful.

I think everyone should be using ChatGPT more - especially if you’re a coder.

I find it especially useful while:

• writing short scripts
• trying to rubber duck error messages
• generating unit tests
• helping to design and implement tightly-defined interfaces

• check you’re using the same internet connection (not ‘Guest’ wifi).
• check you’re not using a VPN

Check the AllowTcpForwarding rules from the ssh server

I was trying to get port forwarding to work… but it just wasn’t connecting as I’d expect. I noticed that the AllowTcpForwarding rule in /etc/ssh/sshd_config defaulted to no, which was too restrictive for what I wanted.

Check any firewalls

You may be blocking the port you’re trying to access.

I recently had to rename a lot of files. But the thing was, the new name was part of the file itself.

The following monstrosity may seem overwhelming, but the nice thing about shell scripts is that they are fairly functional and you can just build on top of the work you’ve done previously.

find . -type f -name "*.md" -not -name "README.md" | xargs grep date: | awk '{ sub(/:.*/,"",$1); sub(/\.\//,"", $1); print "mv " $1 " " $2 "--" $1}' | sh

A break down of what’s going on here:

find . -type f -name "*.md" -not -name "README.md"

This just lists the markdown files in a directory (excluding the README).

... | xargs grep date:

We’re only searching for a specific string in each file

awk '{ sub(/:.*/,"",$1); sub(/\.\//,"", $1); print "mv " $1 " " $2 "--" $1}'

And for a given input (like {filename}:date: {date}), we create a shell command output mv {filename} {date}--filename, which is exactly the script I wanted. We’ve then just got to pipe this into the shell to acutally execute it.

awk is a language that’s especially undervalued in my opinion.

It’s worth spending some time to become shell literate!

What did surprise me recently, though, was something as trivial as

cp -R a/ b/

will behave totally differently on the two systems.

Spoiler Alert: You’ve got to use dots (.) to make them work the same.

cp -R a/. b/.

Everything is a tradeoff. One tradeoff that we all have to make when building things is:

 SCRAPPY <-------------------------> PERFECT

+ quick to build                 - slow to build
+ faster product feedback        - slower product feedback
+ easy to throw away             - expensive to pivot
- unstable                       + stable
- unmaintainable                 + maintainable
- hard to change                 + easy to change
- unscalable                     + scalable

Businesses should treat both extreemes with the same caution. Tech debt can sink companies. And an inefficient tech team that’s overengineering can too.

Startups should generally transition from scrappy towards perfect as they scale and find product-market-fit.

On the whole, I think that good software engineers err on the perfect end of the spectrum. Depending on the circumstances, this can be vital, but can also be wasteful.

It’s worth thinking about this tradeoff and whether your tech org has got the right balance.

Basecamp have teams of only two or three people. This allows specialisation, reduces context-switching and allows for more teams in total. In coding terms, this is the single responsibility principle.

In order to have lots of teams, you need detailed domain knowledge. Where should the boundries be? This is exactly the same approach as domain design in a codebase, but at the team-level.

TL;DR Your team is probably too big.

Talking is easy. But to do that effectively is more difficult.

Here are some tips that may help!

• Get to the point fast.
• Prefer asynchronous written communication over synchronous.
• Type out everything you wanted to say before saying it (this applies especially to questions). There’s no point in asking something in 5 separate messages. You’ll just dilute what you were trying to say and annoy people.
• Think about what you’re typing. Writing is a good way to clarify stuff to yourself. If necessary, find more data or even delete everything if you were about to ask a stupid question. (note: there are no stupid questions…)
• Use bullet-points / numbered lists so people can easily scan and reply to specific items individually.
• Simplify your language. Long words may make you seem clever, but people won’t understand as easily.
• Aim to document everything
• Re-read everything before you ask people to take the time to read it. The longer your writing (eg. a massive PR), the more carefully you need to re-read. You may spot obvious mistakes, answer your own question, or change your mind by doing this.
• Make sure relevant people know relevant information. Potentially deliver the same message in different formats and mediums.
• Favour communication in public over in private. Other people will benefit!
• If in doubt, post the message. Under-communication is more dangerous than over-communication.
• Make sure the relevant people know. Potentially “tag” them if they could miss the message.
• Write to most relevant place & to the smallest number of people. Who needs to know? A single person? The team? A large group of people? People will engange more if there are fewer other people around.

Spending time looking at something in detail is like using a magnifying glass; you can see a small area in high resolution. Magnifying glasses are useful, but they do limit our ability to see broadly. I think it’s also worth looking through an opposite type of lense, a minifying glass (if that’s a thing); something that makes everything look small, with much lower resolution, but far broader scope.

There’s no point in having a beautiful component that just doens’t fit in with the larger machinery.

The most interesting things in life are all straightforward. Here are some bad examples of simple stuff:

• Evolution
• Fractals
• Atomic structure of elements
• The game of life
• Viruses
• Fibonacci numbers
• Laws of the universe
• Golden Ratio

I’d argue that most selective pressures ultimately favour simplicity.

This holds true with technology, too.

When building something, there’s a temptation to show off. Complexity may impress people. “Look at this huge intracate thing I made. You don’t understand it. I’m so clever.”

Simplicity often seems obvious. “Anyone could have done that”

Simplicity is good:

• HTTP is simple. It’s human-readable. Sure, there are faster ways to transfer data. But they’re not necessarily simpler. Over time the HTML spec has got larger, but the core idea is pretty simple.
• Editing documents in plain-text is always a good idea. Earlier today I ended up manually copying and pasting individual bullet points from Google Keep as they’ve made it impossible to copy the whole list. Staying in plain text means you control your data. It’s simple.
• Suckless software takes simplicity to a new level. Their code is easy to understand & easy to modify. I dare you to modify the Windows source code to change how its window manager works if you want a comparison.
• RSS is super cool. It’s a dead easy way to ‘subscribe’ to blogs that interest you. And there’s not much to go wrong. You don’t need to sign in to anything.. it just works.

Complexity is bad:

• Metaprogramming can be cool, but can be a nightmare to debug & can be easy to do things you didn’t mean to.
• The modern web is a bubbling cauldron of complexity. Most websites break without Javascript. This means that it’s very very difficult to create a decent browser, and so we’re all stuck with either Chrome or Firefox. No one’s going to be realistically creating a new browser in their free time. Gopher & Gemini are interesting protocols that drasically simplify the web & are totally interesting.
• Github is getting bigger and bigger. There are more and more features available in Github. I would argue that it is bloated and there are leaner and faster alternatives which purposefully avoid implementing unnecessary features.
• I tried writing a new post for my old blog after a few years of ignoring it. The old jekyll static site generator crashed when I tried to run it on my old website. I had to install an old version of Jekyll and even then it complained about an extension not working. I gave up and wrote a simple shell script to just parse my markdown documents into HTML using pandoc instead. This script will still work in a few years.
• Microsoft Teams is an exasperating messaging app. The UX doesn’t work in an intuative way and there are plenty of baked-in features that bloat it. In order to use Teams, you have to use the client; you’re locked in to their own shoddy implementation. Some old messaging protocols (looking at you, IRC) embody simplicity and it’s not too tricky to interact with IRC using netcat.
• I love the idea of nix. I’ve tried to learn how to use it effectively so many times. The concepts behind it are totally solid & wonderful, but the actual implementation is just confusing and complex. I’ve now overwritten my NixOS distribution with something else as I can’t afford to spend endless time understanding all the quirks of nix.

It’s not always that straightforward

• There are two separate types of complexity:

1. Inherent complexity. If you’re trying to model all the possible metabolic pathways, you’re going to struggle to fit it all on one A4 sheet of paper. Some things just have large scope.
2. Accidental complexity. Programmers like overengineering. Why not add some distributed databases to a calculator app? It’ll be cool…. but perhaps not necessary.

• We’re taght that duplication is bad. But programmers often create far more complexity trying to avoid dupliaction rather than just accepting some duplication. My favourite example of this is from 99 bottles of OOP by Sandi Metz. A good solution to “how would you create a function to print this recursive song ‘99 bottles of beer…’?” is just to return a long string containing the entire 99 verses of the song. Genius!
• I want to love emacs’ org-mode. It’s lovely. But it’s not transferrable. The org-mode format only works if you’re using emacs. It’s not widely adopted, unlike markdown. Therefore I think that markdown is probably a better format to write shared documents in, despite all the whizzy editor features org-mode comes with. It’s sometimes context dependent; writing in Esperanto may on some level be more logical than in English, but if your target audience can’t speak it then there’s going to be an issue.
• Sometimes complex features serve a purpose. Github provides a good in-browser code editor. Microsoft Teams provides build-in persistence (something IRC doesn’t). This is good. But it can also lead to accumulated bloat & inability to customise anything.
• The programming language Go was designed to be super simple. The spec is only 2800 lines long. But “improvements” to the language creep in and add complexity. Generics will be cool…but they’re not exactly simple. It’s easy to start off with a simple solution… over time & changing requirements can change this original vision.

Don’t take my word for it!

Simple can be harder than complex - Steve Jobs

Simplicity is the ultimate sophistication – Leonardo da Vinci

Everything should be made as simple as possible, but not simpler – Albert Einstein

S3 has 99.999999999% durability. There are so many nines there it’s difficult to fully comprehend what that means.

For example, if you store 10,000,000 objects with Amazon S3, you can on average expect to incur a loss of a single object once every 10,000 years.

In my opinion the reverse is even more impressive; if you stored 10,000 objects for 100 million years, you’d only lose one.

It’d be interesting to see how they achieve that.

• How many replications is enough? 3?
• How do they coordinate updates, deletes, etc.. to avoid data loss?
• .. and, with all this durability, how do they keep their response times so low?

A UUID is just a list of 128 bits. That is 2^128 different combinations (340,282,366,920,938,463,463,374,607,431,768,211,456). This big number is apparently ‘340 undecillion’. Incidentially, there are also 2^128 ipV6 addreses. Hopefully it’ll take a while for us to go through those…

Under the hood, a UUID is just a load of 1s or 0s (much like anything in a computer). It’s just a string of 128 of them. Eg.

01011011011010001011001111010011000101100011001001000110111110111010011101111001111000001011100101111101010100110010100111010111

Isn’t that fascinating?

This loads of bits can also be rewritten in base 16 (hexidecimal)

5b68b3d3163246fba779e0b97d5329d7

…which is also the base 10 (“normal” number) of

121503393765045762381299543010238998999

These are the same number, just expressed differently.

Each hexidecimal number (1-16 or 0-f) represets four bits (2^4 = 16). So hexidecimal is four times shorter and therefore a sensible standard to use for uinque identifiers.

UUID Prefixes

I wanted to work out the probability that two UUIDs contained the same prefix. Because hexidecimal is base 16, it makes sense that for every UUID, 1 in 16 should start with a. And 1 in 16 should start with 5, etc. But what about two aa? How do we calculate that? This would be 16 * 16, which 256. So there’d be a 1 in 256 chance of getting a UUID starting with aa.

The pattern we can extrapolate is that for n digits, we need to multiply 16 together n times.

Luckily maths people do this sort of sum a lot and there’s a shorthand for it, ^ (this process is called exponentiation).

Working out some numbers hackily with emacs lisp

I spend a lot of time in emacs and in emacs, lisp is just a keystroke away. If you write (+ 5 5), put your cursor on the closing bracket and then press C-x C-e (control x followed by control e), you’ll evaluate the lisp you just wrote and the minibuffer will display 10.

I googled the exponentiation lisp operator (which was handily called expt) and typed the following:

(expt 16 1)

which gave the answer 16.

I tried again with a diferent number and the function seemed to work /

Using an emacs macro, I was able to generate a small table of these.

(expt 16 1) 16
(expt 16 4) 65536
(expt 16 8) 4294967296
(expt 16 12) 281474976710656
(expt 16 16) 18446744073709551616
(expt 16 20) 1208925819614629174706176 
(expt 16 24) 79228162514264337593543950336
(expt 16 28) 5192296858534827628530496329220096
(expt 16 32) 340282366920938463463374607431768211456

This list showing the total number of unique combinations of base-16 numbers helped me decide how best to categorise UUID prefixes for something 👍

Personally, I use pass, “the standard unix password manager” to manage my passwords and it works a treat. Under the hood, pass uses gpg. This lets me use my terminal as a password manager.

There’s a great Android app which implements the same pass “spec” . This app relies on openkeychain for GPG-key management. In their FAQs, they elegantly sum up how best to transfer your private key:

generate a strong random password

gpg --armor --gen-random 1 20

encrypt key, use password above when asked

gpg --armor --export-secret-keys YOUREMAILADDRESS | gpg --armor --symmetric --output mykey.sec.asc

on the receiving computer

gpg --decrypt mykey.sec.asc | gpg --import

These steps will encrypt your secret keys symmetricly with a secure & one-time random password.

I’ve used magic-wormhole in the past to transfer sensitive information from computer to computer. It’s worked really well. If you’re paranoid about your keys (and it may be worth being paranoid…), I’d look into using magic-wormhole to move your encrypted private GPG keys around. It’s really easy. Literally wormhole send mykey.sec.asc.

It’s easy to sign up to have access and play around (link here).

This is only going to get exponentially better. Soon it’ll be way better than any humans so we’ll all be out of a job.. but at least we’l have some amazing books to read during our post-scarcity utopian lives.

I was mucking around with it and tried to see if it could generate any new blog posts for me. Here are the ones it suggested:

# How to convert a String to a number in JavaScript
If you’re working with some weird form of string, sometimes the way it is formatted won’t be what you expect. Here are three ways to convert a string to an actual number in javascript. js

# Feel conflicted about something? Take some time off!
Don’t feel like you need to ‘power through’ your feelings of conflict or confusion. Just take the time you need and move on when you feel ready. life

# What a Diff is
I was recently asked by someone what exactly a “diff” was. Here’s my answer! computing maths

# OMG! How to make an app store?
So, you want to make an app store! Cool. But how do you actually go about doing it? tech dev

# Have a backup plan
When something goes wrong, the best thing is often just to have a plan B. That way if things go awry, you’ve got a backup idea up your sleeve. business marketing sales strategy work worklife balance

Which is exactly the sort of nonsense I’d talk about.

Some more title suggestions:

A fun editor
Trying out Ruby
The Evils of the Global Inheritance
Permissions By Group
export a variable in bash
Docker: List Containers

My favourite is The Evils of the Global Inheritance

I recently was trying to do something in Haskell where I wanted to do a kind of “deep” map.

The function map has the type signature of

Prelude> :t map
map :: (a -> b) -> [a] -> [b]

What I wanted was:

notSureHowToImplement :: (a -> b) -> [[a]] -> [[b]]

I scrabbled around doing hacky and ugly things… until I realised that we should be able to use the default map function by calling it twice:

Prelude> :t (map . map)
map :: (a -> b) -> [[a]] -> [[b]]

Tada!! Magic!

But how does it work?

This trick relies on some deep and mysterious secrets which functional programming is build upon: currying & composition.

If you eyeball the map function again, what it’s actually doing is taking a function and then returning another function that operates on a list to create another list:

Prelude> :t map
map :: (a -> b) -> [a] -> [b]
-- can be written like:
-- map :: (a -> b) -> ([a] -> [b])

The fact that map takes a function and returns a function means that… we can use map on map’s output function…

A reminder about function composition: Function composition is just calling functions:

h(x) = g(f(x))

In haskell this is so important that its operator is just “.”.

Prelude> :t (.)
(.) :: (b -> c) -> (a -> b) -> a -> c

so (map . map) f is the same as map (map f )

Here’s the function in practice:

Prelude> (map . map) (* 2) [[1,2,3],[4,5]]
[[2,4,6],[8,10]]

Isn’t it lovely?

It can still be a bit tricky getting private repos to work with go mod. Maybe these tips help… ¯\_(ツ)_/¯

• Set up SSH keys with your version control vendor

• Add the following to your ~/.gitconfig:

    [url "ssh://git@github.com/"]
        insteadOf = https://github.com/
    [url "ssh://git@gitlab.com/"]
      insteadOf = https://gitlab.com/
    [url "ssh://git@bitbucket.org/"]
      insteadOf = https://bitbucket.org/

• Add the offending repo as a private repo:

    go env -w GOPRIVATE=gitlab.com/you/your-project,github.com/someone/their-project

It can be scary to admit that you don’t know stuff… but it’s worth trying (or pretending) to be confident & ask them. Like anything, it’ll become easier to ask stupid questions the more you ask.

Here are some stupid questions in case you can’t think of any off the top of your head:

• Why are we building this?
• What’s this acronym?
• Why would a customer want to do this?
• Is this MVP really minimum?
• Is this MVP really viabale?
• Why are we doing this this way? Could this approach work?
• How are we measuring X?

Money’s kinda pointless if you’re miserable earning and spending it.

If you’re doing something you don’t like, you should seriously consider making a change.

You can:

• try to change your teams
• try to change your hours
• try to change your hour-flexibilty
• try to change your jobs
• try to change your company
• try to change your projects
• try to change your managers
• try to change your industries
• try to change the technology you work with
• try to learn more stuff
• try to change your perspectives:
  • try to get more interested with what you do on a day-to-day way
  • try to engage more with your company’s product
  • try to engage more with your company’s decisions
  • try to take more ownership over what you’re doing. A wrong decision may be better than no decision at all.

Life should be fun. Play around a bit and don’t take anything toooo seriously. Enjoy it!

It’s important to document things, especially technical things.

code != documentation

Source code explains how things work… it’s simply telling the computer the algorithm you want run. What’s not often mentioned is wider context.

• Why do we want this thing at all?
• What problem does it solve?
• Why don’t we approach this in a different way?
• What are the current constraints? Is there time / business / financial pressure?
• Is this meant to be scalable or an MVP?
• What does this object / table represent?

Use comments and documentation widely to make it easier for the next person - often you.

What I needed was to create a fake table (WITH ...), JOIN it onto my real table… and only select those which were NULL for the real table.

In the following example, I’m trying to find whether either bob or andrea don’t exist in the database:

WITH expected(email) AS (
VALUES
('bob@example.com'),
('andrea@example.com')
)
SELECT email
FROM expected
LEFT JOIN my_real_table_name t1
ON t1.email_address = expected.email;
WHERE t1.email_address IS NULL

As Steve Jobs said:

Man is a toolmaker, has the ability to make a tool to amplify the amount of inherent ability that he has.

The whole point of technology is that it let’s us do things.

As a software engineer, it can be tempting to fall into the trap of spending loads of time optimising your developer environments.

• Which shiny new thing should I use?
• Is there a vim plugin to save me 3 seconds per day?
• Can I automate a coffee machine from my terminal?

These are all loads of fun, and you learn loads by doing them… but the end result is just that you’ll be better at doing a (potentially very specific) job in the future.

Technology can impact every facet of our lives for enormous good. We have the ability to improve the world loads… and there’s more to technology than just a slick development environment.

Maybe try finishing that side-project, or sitting down and thinking what you really want to achieve, rather than how.

While it’s true that many defaults are the result of some old-fashioned constraints (eg. QWERTY keyboard or the vim homerow being one key to the left), it may be worth your time just accepting their flawed premises and trying to use them anyway. There’s value if people are also using them.

If your vim config is totally unique to you (or you’re a dvorak user), you’ll have a hard time pairing with someone else or SSH-ing into a server.

The creators of customisable products have hopefully thought long and hard about the best way to use their creations. They’ll be far more invested in making it work well than you will and they’ll have a vision of how they want their products being used.

Sometimes it’s sensible to just accept defaults.

The question is, what should we call it? Here are some names we came up with:

• parcel
• package
• freight
• cargo-mini
• gateway
• specific-and-boring-product-description
• catalyst

Any guesses which are the best names?

Our developers and users already knew about cargo. They had the mental context in their head. Because of this, cargo-mini makes sense as a smaller version of cargo. I’m quite a fan of absurdly verbose but specific names, so I’m also a fan of specific-and-boring-product-description

It can be really useful to have background jobs doing all sorts of things in the background.

The whole point of computers is to automate stuff… and cron is a really easy UNIX-y way of doing this.

Disclaimer: For one-off scripts, cron jobs can be great…but it doesn’t scale particularly well. Eg. if you need to syncronise lots of background jobs, it’s probably better to look for something else.

In every job I’ve been at, there have always been loads of ways to save human time by telling a computer to do some stuff instead of doing it manually. This is especially true for non-super-technical areas; there could be lots of delicious low-hanging fruit.

You don’t even need to be able to code to do loads of stuff; services like IFTTT or Google sheets have lots of automatable functionality baked in.

In the past I’ve save loads of time by completely automating:

• Sending daily emails to clients about latest statistics (with some top-level analysis)
• Creation & management of Adwords campaigns
• Daily parsing of reports (& inserting into a database)

{{< figure src=“https://imgs.xkcd.com/comics/is%5Fit%5Fworth%5Fthe%5Ftime%5F2x.png” >}}

The trick here is to pick your battles. Some tasks are easy to automate (those which involve structured data). Others are difficult. But always remember to keep tabs on where you spend your time; you may be able to free up a lot of time by some simple automation!

It takes a long time to learn & adapt to modal editing and all of vim’s esoteric keybindings.

Despite that, it’s really popular. Perhaps people are onto something?

If you edit text for a living, it’s probably worth your while looking into learning the basics of vim properly (no arrow keys, that’s cheating!).

{{< figure src=“/images/doit.gif” >}}

There’s so much to learn about git. And most of us could afford to know a bit more about how it works.

• reflog has saved my life many times
• shortcuts like git checkout - save loads of time
• completion scripts can make your life easier & show options you didn’t know about

If you don’t already, it’s probably worth curating a ~/.gitconfig that you check into… git… and store somewhere.

I only recently discovered that it does loads more than just pretty-printing JSON.

You can map over it and do really quite complex data processing with jq.

I recently had to extract some data from an API and ended up piping into this:

jq '.Chart.Purchases | map((. | first | tostring) + ", " + (. | last  | tostring) )'

It’s really flexible and nice to use!

I’d recommend people have a quick browse through the jq examples and tutorial just so they know the full extent of what jq can do.

Programming Ruby 1.9 & 2.0: The Pragmatic Programmers’ Guide

by Dave Thomas, Andy Hunt & Chad Fowler

The ‘pickaxe’ book is a complete overview to Ruby. It’s a pretty hefty book, covering these topics:

• A great tutorial on using Ruby.
• The definitive reference to the language.
• Complete documentation of all built-in classes, modules, and methods.
• Complete descriptions of all 97 standard libraries.

Practical Object Oriented Design in Ruby: An Agile Primer

by Sandi Metz

Ruby likes objects and ‘POODR’ shows how to make the most of them. Modular code is easier to maintain, reuse and understand. Sandi Metz has some interesting ideas on OOP - her rules have become important. We see the world in objects, and I think that code usually makes more sense in objects too.

Ruby on Rails Tutorial: Learn Web Development with Rails

by Michael Hartl

This is a great introduction to Rails. It starts slow enough for complete n0obs, but has enough depth to interest far more advanced programmers. It walks through TDD, getting to use the console and git, and covers encryption, AJAX and how Rails works on a practical level. There is also a free, online version of the book here

Eloquent Ruby

by Russ Olsen

One of the best things about Ruby is its expressiveness and elegance. Understanding how Ruby was designed to work helps you to really tap into its power and makes a lot of things make a lot more sense.

I’ve recently started playing with them and have found that they can be useful, especially with long documents.

The main shortcuts you need to learn are:

za - toggle current fold open/closed zR - open all folds zM - close all folds

This would work as an explicit fold:

# My super clever method {{{
def clever_method
  ...
  something clever
  ...
end
# }}}

The }}} triple curly braces then let the area fold into something like:

+--  7 lines: My super clever method -----------------

which lets you expand / contract it with za.

It’s probably worth adding za as a shortcut.

There’s loads more you can do with them, but this is a fairly easy way to start to understand them..

git diff commit1 commit2

This will list all the differences, which could be a long list of changes.

If you’re looking for just the file names, you can use the –name-only flag:

git diff --name-only commit1 commit2

You can see which files have changed in the last couple of commits with:

git diff --name-only HEAD~2

1. Pressing : (which is hopefully mapped to just ;)
2. <ctrl-p> (‘previous’ in many unix applications) You can also press up if you find this easier… although you shouldn’t…

Another way is to press q:, which provides a list of your recent commands. You can k your way through them and open (<cr>) them.

Imagine your cursor is in the middle of a paragraph you want to delete. Instead of laboriously deleting single lines, you could just type dip for ’ delete inner paragraph’. The text object represents the entire paragraph.

A list of these is:

iw inner word it inner xml / html tag is inner sentence i' inner single quotation marks i" inner double quotation marks i{ inner { ... } braces i[ inner [ ... ] braces i( inner ( ... ) braces ip inner paragraph im inner ruby method (from the vim-textobj-rubyblock plugin)

The same commands also work with a for a (eg. ca( will also change a bracket, rather than just the contents of them)

For an in-depth explanation, type :h text-objects into vim.

It substitutes the return value of the previous line into the current line.

These are the examples from the docs

h = { "a" => 100, "b" => 200 }
h.fetch("a")                            #=> 100
h.fetch("z", "go fish")                 #=> "go fish"
h.fetch("z") { |el| "go fish, #{el}"}   #=> "go fish, z"

I usually think it’s safer to use this rather than Hash#[] (which is just usuing the normal hash[:possibly_doesnt_exist] syntax), as it removes the chances of a rogue nil popping up.

It inserts text based on your current vim context.

Many of these commands work with registers, so it may be worth getting your head round those….

Hope they help!

On top of these, there’s a handful of other, lesser-known commands:

z commands (also used for folding)

zz move current line to middle of screen zt move current line to top of screen zb move current line to bottom of screen

Moving over lines quickly

ctrl-e move up 1 line ctrl-y move down 1 line ctrl-u move up 1/2 page ctrl-d move down 1/2 page ctrl-b move up 1 page ctrl-f move down 1 page

git update-index --assume-unchanged <file>

This lets you alter the files and you won’t be at (too much) risk of committing those changes by mistake.

This can be useful if you want a fairly quick way of hiding environmental variables… But be careful…

It’s even more useful with a few other commands:

git log --all - Include all branches in output git log --graph - Include visual depiction of branchesall branches in output git log --oneline - This is kinda self-explanatory. git log --decorate - Show branches git log ..branch & git log master.. - These commands can help you find the differences between branches.

my_object.my_method

One way you could do this is:

if my_object
  if my_object.my_method
    my_object.my_method
  end
end

If you were cleverer, you could just do:

if my_object && my_object.my_method
    my_object.my_method
    ...

The trouble with these approaches is they can become cumbersome:

if my_object &&
   my_object.my_method &&
    my_object.my_method.my_second_method

my_object.my_method.my_second_method

And that’s using the more concise syntax… A better approach would be to use the Object#try method. It ‘tries’ an object’s method and, instead of going mental, calmly returns nil if that method doesn’t work.

my_object.try(:my_method)

Ta da! This makes the more nested existence-validations read much better:

my_object.try(:my_method).try(:my_second_method)

If you’re using standard ruby, the #defined? and #nil? methods could help…

Type it in. Now.

     _________
    |o^o^o^o^o|
    {   _!_   }
     \   !   /
      `.   .'
        )=(
       ( + )
        ) (
    .--'   `--.
    `---------'

Registers are usually accessed by the " key.

There are many different registers:

Hope this makes sense! To set & get the contents of the register, you just need to do reference the name. Eg: "ayw => "ap

You can then do important things on your shell.

To return, just type fg (foreground).

If you want to see what else you’ve suspended, jobs will tell you.

if variable
  return true
else
  return false
end

That’s not very good. In Ruby, we don’t need to explicitly return variables:

if variable
  true
else
  false
end

This is a bit long-winded. We could try the ternary operator:

variable ? true : false

We can thin this out even more by using a double negative:

!!variable

This is performing an ‘inverse’ !variable method (which returns the opposite bool type).

Here are the basic steps I took:

1. Think of something funny / useful for your bot to do.

• This is the hard part…

2. Register a new Twitter Account

3. Create a new Twitter ‘app’ - go to http://dev.twitter.com/apps

• This will have the ability to control your twitter account on your behalf.
• Make a note of the API keys.

4. Enable Read / Write Permissions for this App

• Found under ‘Permissions’.
• If you need an extra mobile number, try this trick.

5. Write some code which interacts with the Twitter API.

• Sferik’s twitter gem makes this very easy in Ruby.
• If you’re looking for inspiration, browse my code. It’s not very complicated… And the twitter gem is very well documented.
• Remember to use Environmental Variables to hide your API keys.

6. Create a Gemfile / Rakefile for Heroku to latch onto.

• Again, examples of these can be found on my Github profile.
• The rakefile basically defines an isolated process that can be run by heroku.
• The Gemfile lists all the Gems you’ll need to install.
• You may need to run bundle install (as usual…)

7. Check you can do what you want from the command line.

• By running your rake task.

8. Create a new Heroku App.

9. Push your current files to Heroku.

• This should be a .rb file, a Rakefile, a Gemfile & a Gemfile.lock

10. Add Heroku Scheduler to your Heroku app

• heroku addons:add scheduler - the fastest way to add this.
• This will allow you to customise how often it runs.
• You can set it to run every 10 minutes if you feel the need…
• To customise this, you’ll need to log into you Heroku Account.

11. Add your Environmental Variables to Heroku.

You should be ready to take Twitter by storm now!

The process wouldn’t let me change the permissions of the new app to read and write.

I managed to get this working by:

1. Download the app on my mobile (iOS in my case, although Android apparently works, too)

2. Log into the app

3. Still on your mobile, go to http://dev.twitter.com/apps

4. Change the permissions of your app to Read & Write

5. Click Update

That should work!

Navigation

cd - changes the current directory.

• cd ~ - changes where you are to HOME directory
• cd Documents - goes one file deeper into the ‘Documents’ folder
• cd .. - goes up one directory

ls - list files or directories in current directory

• ls -la - uses the options ‘-l’ (list in detail) and ‘-a’ (show hidden files)

pwd - print working directory. Shows where you are (relative to the root folder)

Copying

cp - copy

• cp anchovy.txt fishes/anchovy.txt - creates a copy of the file under the ‘fishes’ directory.

cp -r - copy recursively. Useful for directories.

• cp -r anchovy fishes/anchovy - copies all the anchovy-related files from the folder ‘anchovy’

Deleting

rm - remove

• rm platypus.txt - deletes the specified file

rmdir - remove directory

Moving / Renaming

mv - move

• This works like cp, except it removes the initial file / directory
• mv anchovy.txt fishes/anchovy.txt - moves & removes the file.
• Renaming: mv anchovy.txt sardine.txt

Creating Folders

mkdir - creates a new directory

• mkdir pelicans

mkdir -p - creates a series of new directories.

• mkdir -p Pelecanidae/Pelicans/Great-White-Pelican

Getting help

man - find the manual

• man man
• man pwd

Showing files

cat - show pure text version of the file.

• Concatenates & prints the file cat gerbil_name.txt - simply outputs text: ‘Fred’

less - outputs text with more features.

• Better for larger files. Includes scrolling, searching, etc..
• less encyclopedia.txt - won’t crash & is still useful

sort - guess what this one does…

• Go on. Guess. I’m not going to tell you.

Comparing files

diff - shows the differences between two files

• diff red_spotted_woodpecker.txt lesser_woodpecker.txt

Finding programs

whereis

• Useful if you’re running the wrong version of ruby. Or something similar.
• Provides the location of the executable file.

Changing File Permissions

chmod

• A common chmod file permission to set is chmod 755, which is rwx for the Owner but only rw for other users.

Search for text

grep

I’ve written a quick primer on UNIX file permissions here

Grep’s a fairly big topic:

• grep "some string" filename
• grep "REGEX" filename
• grep -i "some string" filename - case insensitive

Flags

Flags are optional parameters that you can pass in to a shell command. We’ve met some already; here’re two: ls -la. You can see a full list of available options under the man page of the commands.

There are also 3 ‘tiers’ of access allowed: ‘Owner’, ‘Group’ & ‘Other’ These 3 different access levels can be represented like this:

Owner: rwx Group: rwx, Other: rwx

This can be shortened to: rwxrwxrwx

In the previous example, anyone is able to read, write(edit) or execute(run) the file. To disallow them, you can substitute -s in:

• rwx------ would only be useful for the owner of the file.
• r--r--r-- would mean that anyone can read the file.

Clever programmers like to do things with the minimum system requirements; reading 9 letters for each file would be energetically expensive / resource intensive. To solve this problem, they often shorten this syntax (rwxrwxrwx) even more using binary.

They say that:

• Read = 4 bits (binary 100)
• Write = 2 bits (binary 010)
• Execute = 1 bit (binary 001)

Using these simple rules, you can efficiently say that, in decimal (or octal) numbers:

• 0 = No permissions
• 1 = Execute
• 2 = Write
• 3 = Write & Execute
• 4 = Read
• 5 = Read & Execute
• 6 = Read & Write
• 7 = Read, Write & Execute

Hopefully that makes sense. Read + Execute = 4 + 1 = 5. Geddit?

Anyway, this system allows us to transform:

• rwx------ to 700
• r--r--r-- to 444

A common file permission to set is chmod 755, which is rwx for the Owner but only rw- for other users.

Unless you know the pitfalls of Hash#default, you should tread carefully…

You can set default values for hashes a number of ways. Eg:

1. Hash.new(default_value)
2. Hash.new.default = default_value

Hash.new(0) usually works as expected, but Hash.new([]) can be tricky.

If you wanted to append any values to a hash instantiated like this, there will be problems; the array is not just a default array, but it’s also a shared array.

An example:

h = Hash.new([])
h['fish'] << 'carp'
puts h  # => nil.

What’s happening here is that we’ve edited the default value of the hash. We haven’t actually assigned the default value to our lovely ‘fish’. To actually assign, we need to do:

h['fish'] <<= 'carp'

Note the = sign. However, this is not perfect:

puts h  # => {fish: ['carp', 'carp']}

Our ‘default’ value how has two carp in it. If we were to add another key-value pair, this would get even messier:

h['dog'] <<= 'poodle'
puts h  # => {fish: ['carp', 'carp', 'poodle'], dog:['carp', 'carp', 'poodle']}

A disaster!

Our carp and Poodle have now mixed. Hopefully it makes sense what’s happening; we’re altering the (single) default array, which points to all our default values. How do we resolve the situation?

Blocks to the rescue!

You can pass in a block when initializing the Hash.

Hash.new {|hash, key| ... rest of block... }

To create a default hash which hash a unique default for each key/value pair, we can then do this:

Hash.new {|hash, key| hash[key] = [] }

Since this block is run each time we assign a new key, the default value will always be [].

See also Hash#default_proc.

The benefit of using blocks & procs is that we’re able to write clever pieces of code.. and could make our default value do anything we wanted.

I thought it would be a good idea to try to port my CV to Ruby.

This is what happened:

class WilliamClarke
  attr_accessor :notableProjects, :education, :interests, :employment

  def initialize
    @home = 'London'
    @phone = '07771745046'
    @website = 'wmmclarke.com'
    @blog = 'wmmc.github.io'
    @github = 'github.com/wmmc'
  end

  def super_enthusiastic?
    true
  end

  def summary
    "I really enjoy programming.
    Over the last 2 years, I have spent most of my free time focusing on Ruby.
    I also have experience with web development & SQL.
    I am eager to learn much more about software development."
  end
end

my = WilliamClarke.new

class Project
  def initialize(args)
    args.each { |key, value| instance_variable_set("@#{key}", value) }
  end
end

my.notableProjects = [
  Project.new(
    title:   'PPC Campaign Builder',
    summary: 'Ruby script which generates Adwords-formatted PPC Campaigns.'),
  Project.new(
    title:   'Website & Blog',
    summary: %w(HTML CSS JS jQuery Rails ActionMailer Jekyll)),
  Project.new(
    title:   'Twitter Bot',
    summary: 'Smug tweets to people who can’t spell. Hosted on Heroku.'),
  Project.new(
    title:   'Other projects',
    summary: 'Crossword Generator, Shakespeare Prediction, Langton’s Ant')
]

Employment = Struct.new(:name, :title, :date, :role, :achievements, :skills)

my.employment = Employment.new(
  'Forward3D',         # name
  'PPC Analyst',       # title
  '2012-08 - 2014-08', # date
  # role
  ['Managed the paid search activity for two e-commerce clients.',
   'Automated many processes using Ruby, Javascript and Hive.'],
  # achievements
  ['Wrote a script to generate PPC campaigns, saving hundreds of man-hours.',
   'Automated most of my reporting duties.',
   'Update ads automatically based on product prices & stock levels'],
  # skills
  ['Ruby, Javascript & Hive used on a daily basis.',
   'Built, updated and queried Databases using HiveQL and SQL.']
)

my.education = {
  durhamUniversity: [
    'MSc Evolutionary Anthropology',
    'BA  Archaeology & Anthropology'],

  etonCollege: { aLevels: [
    ['A', 'Ancient History'],
    ['A', 'Biology'],
    ['B', 'English Literature']
  ]
  }
}

my.interests = [
  ['Programming', 'Ruby, Javascript, SQL & Web Development. Active on Github'],
  ['Sport', 'I enjoy playing squash, tennis, skiing and diving.'],
  ['Also', %w(Travelling woodworking Choral Music Go Piano Investing)]
]

# To print out to console:
require 'pp'
pp my

It actually works.. and spits out the data in an even more incomprehensible way.

The most common analogy for DNS records is probably a phonebook, which translates addresses that computers like (93.184.216.119) to addresses that humans like (wikipedia.org).

See my post about IP addresses.

This link is especially good at dealing with what happens when you navigate to a URL.

Anyway… I’m getting sidetracked. I’m going to show how I delt with Heroku & 123-reg.co.uk to set up my DNS properly:

I found this quite fiddly to get working… so here’s what I did:

1). Dealing with DNS

• Click on ‘Manage DNS’ and navigate to ‘Advanced DNS’
• Add 2 new CNAME:

- www

- DNS Entry: www
- Type: CNAME
- Destination Target: <your URL without the 'www' and with a '.' at the end>

- Everything else

- DNS Entry: *
- Type: CNAME
- Destination Target: <your URL without the 'www' and with a '.' at the end>

2). Getting rid of that pesky ‘www’ subdomain.

• Go back to the main list of options

• Click on ‘Web Forwarding’

• Add a permament (301) redirection:

  • Domain Name: <Your URL without the www. I just put ‘wmmclarke.com’>
  • Forwarding Type: 301
  • Forwarding Destination: <Your URL with http://www prepended to it.>

That should be it!

I’ve been using YADR as a basis for my dotfiles. Dotfiles, if you don’t know, are files which start with a fullstop (and therefore are hidden in UNIX systems). Dotfiles mostly refer to configuration files in the home directory - eg. .bashrc or .vimrc. One of the benefits of using a monolithic package like this is it quickly lets you do more cool stuff as you’re learning (over boring native Vim).

I’ve put the extra files I’ve configured into my .vimrc.after file, which you can find HERE!.

Remap the keyboard.

The caps lock key is in a really important place but is largely redundant. You can remap it to something more useful (OS X: go to System Preferences > Keyboard > Shortcuts). For Vim users, the Ctrl key is very important. Remap it!

If you’re clever, you can also use the Caps Lock button as Esc (also very important for Vim users) by downloading Karabiner. This can set Escape for a single-press of Ctrl (which we now have at Caps Lock). Anything other Ctrl commands stay the same.

I’ve found that other keys are poorly placed; eg # and _, so I’ve remapped them too. Especially for Ruby development, I found it tricky to constantly press alt + 3 for #. Now it’s where ± is (next to 1).

Use good vim plugins.

YADR comes with a load of fantastic plugins:

These are the preinstalled plugins that I use most:

• Pathogen (a bundler for plugins)
• Vim Ruby & Vim Rails
• Solarized colours
• Vim sneak
• NERDTree
• Vim Surround
• CtrlR

I’ve added a few more of my own, too:

• Tmux-Navigator - Makes navigating Tmux panes just like navigating Vim panes
• Ruby xmpfilter - Gives you the ability to run a ruby script (or part of it) mid-edit.
• Vim-Rspec - Good Rspec integration from thoughtbot
• Jekyll - Easy Blogging from vim.

Use good keyboard shortcuts

The whole point of Vim is that it’s easy to define the shortcuts you like. Well.. maybe not the whole point, but it’s meant to be designed towards what works for you. So do what works for you. Having said that, I’m going to show the shortcuts which work best for me at the moment:

• the ! command lets you use normal bash functions
• the % sign refers to the current file.
• <CR> stands for carriage return (enter)

Using this we can make a mapping like this:

noremap <leader>md :!open -a 'Marked 2' %<cr><cr>
noremap <Leader>oc :!open /Applications/Google\ Chrome.app %<CR>

The : key is obviously important for Vim commands. The ; key is less important. Swap them!

noremap ; :
noremap : ;

jk can be a fast way of returning back to normal mode

imap jk <ESC>

Sometimes you can’t save a file. Something about an E212 error. Force it with this:

ca w!! w !sudo tee "%"

Shortcuts to save and quit:

inoremap <silent> <C-q> <ESC>:q<CR><ESC>
nnoremap <silent> <C-q> :q<CR>
noremap  <C-s>    :update<CR><ESC>
vnoremap  <C-s>   <C-C>:update<CR><ESC>
inoremap  <C-s>   <C-O>:update<CR><ESC>

This vim function lets you toggle Solarized background colour within the editor.

function! ToggleBackground()
    let &background = ( &background == "dark"? "light" : "dark" )
endfunction

This lowers the timeout:

set timeoutlen=500

I originally wanted to create something through rails, but, having thought about it, it would have taken a while to set everything up correctly. No need to reinvent the wheel…

Jekyll is a blogging / website platform built with Ruby. It’s what I would have aimed to build, only simpler, more efficient, pre-built and with an active community behind it.

Jekyll’s main selling point is that it integrates text files well into a static site.

It’s simple to use and set up out of the box:

~ $ gem install jekyll
~ $ jekyll new my-awesome-site
~ $ cd my-awesome-site
~/my-awesome-site $ jekyll serve
# => Now browse to http://localhost:4000

If you’re lazy, I’d recommend not doing this, though. Jekyll Bootstrap, discussed below, has a few more features that may be useful.

Jekyll Bootstrap

Jekyll Bootstrap uses Twitter’s bootstrap and includes a number of extra in-build functionality including clever rake tasks, themes and comments.

Here’s a really good starting point: Jekyll Bootstrap Quick Start Guide

One of the great things about Jekyll Bootstrap is that it integrates well with Github Pages. This lets you host your own site for FREE! You get the custom domain of your_github_username.github.io.

The only tweak that I had to make with the current version of Jekyll Bootstrap was to change the default github._com_ to github._io_

Updating Your Settings

Go to _config.yml to update your settings:

• Github Username
• Twitter Username
• Analytics Tracking ID
• Disqus shortname

You’ll probably have to go to Disqus to create a shortname and Google Analytics to get your tracking code.

Generating New Posts

Once you have everything set up, you’ll be able to run

$ rake post title="Hello World"

To create new posts or

$ rake page name="about.md"

To create new pages.

There you have it - a free, fully functioning static blog set up in only a few minutes!

Here are a few more tips I recommend to make it even easier to use Jekyll and Markdown.

Using Jekyll with Vim

There’s a great vim plugin for jekyll. This lets you, anywhere in the file structure, to access your current posts or to create a new one.

map <Leader>jb  :JekyllBuild<CR>
map <Leader>jn  :JekyllPost<CR>
map <Leader>jl  :JekyllList<CR>.

Ultra fancy Markdown editing.

I use Marked 2, which is a fairly slick markdown live previewer. You can call it straight from vim using this mapping in your .vimrc:

noremap <leader>md :!open -a 'Marked 2' %<cr><cr>

(Assuming you’re on OS X)

I hope this’ll help some people get started with Jekyll. Good luck with it!

git update-index --assume-unchanged <file> should work.

Background

When you type a web page into the computer, what you’re really asking is for some information from a different device (usually a big server somewhere in the world). There are several complex stages to finding this, but one of the key components is having an identifying ‘marker’ on each device; so you know which address to get the information from, and also so the information knows how to get back to you.

IPv4

Recently, we’ve been running out of traditional (IPv4) IP addresses: using 4 different 32 bit numbers (eg. 93.184.216.119), giving us access to 4,294,967,296 possible unique addresses (2³²)).

IPv6

IPv6 uses 2¹²⁸ numbers, which is quite a bit bigger (340,282,366,920,938,463,463,374,607,431,768,211,456). An example of one of these is: 2001:db8:0:1234:0:567:8:1. To put that in perspective, 2¹²⁸ E. coli bacteria (which are pretty small) would be around 26 times heavier than Earth (which is pretty big).

Take home point is we’re not going to be running out of IP Addresses soon.

cat >/my/path.extension <<EOL
line 1,
line 2,
line 3,
line 4 line
...
EOL

Another thing about cat:

cat > file writes to file cat >> file appends to file

Using Vim & TMUX feels like it makes you faster after a couple of weeks.

It does take a while to get used to it.

Although I’ve read loads of contradictory advice, I think that it’s best to get started with a well-defined set-up. YADR is the one that I like.

If you’re unsure about trying vim, you could start a mini-turorial on your unix machine with

vimtutor

It’s a great resource to learn the basic motions & get the feel of Vim.

rails generate rspec:install

Test helper file:

require 'capybara/rails'

Gemfile

gem 'rspec-rails'
gem 'selenium-webdriver'
gem 'capybara'

spec/spec_helper.rb

# This file is copied to spec/ when you run 'rspec-railss generate rspec:install'
.
.
RSpec.configure do |config|
  .
  .
  .
  config.include Capybara::DSL
end

There are lots of different stages and clever ways to solve the puzzles.

Try it now!

How to use Snippets in Sublime Text:

In sublime text you can install these by going to Tools => New Snippet... This will give you a confusing XML document looking like this:

<snippet>
  <content><![CDATA[
Hello, ${1:this} is a ${2:snippet}.
]]></content>
  <!-- Optional: Set a tabTrigger to define how to trigger the snippet -->
  <!-- <tabTrigger>hello</tabTrigger> -->
  <!-- Optional: Set a scope to limit where the snippet will trigger -->
  <!-- <scope>source.python</scope> -->
</snippet>

The text in between the [CDATA[ and ]] are what you want to edit. The $1 or ${1:this} are where the cursor will be after you activate the snippet. This text after the : is the default and you can get to $2 by tabbing.

The word you’d like to trigger the snippet should go here (in this example, ‘hello’ + Tab).

Scope determines which files the snippet will work on. The scopes that I use most often and available to Sublime Text include source.ruby, source.ruby.rails & text.html.erb.

Keyboard Shortcuts

If you feel the need, you can bind the snippet to a keyboard shortcut. This would involve adding a line to your ‘Keybindings - User’ file (found under Sublime Text => Preferences).

Here’s the sort of thing you’d want to add:

{ "keys": ["alt+shift+e"], "command": "insert_snippet", "args": {"name": "Packages/User/my-clever.sublime-snippet"}}

Be careful to make sure it’s in a vaild JSON array - eg. watch out for commas & make sure there are square brackets enclosing everything.

:map

This lists all your mappings. You can extend this:

If you wanted to find all your leader mappings, :map <leader> would return a list of them.

You can use this to find spare bindings & avoid overwriting important ones!