A quick word of warning, these directions are for tmux 2.4, and are incompatible with older versions.
You’ll want to add these commands to your ~/.tmux.conf file. They’ll give you
the ability to seamlessly switch between vim and tmux panes using a control +
movement key(hjkl).
# smart pane switching with awareness of vim splits
bind -n C-h run "(tmux display-message -p '#{pane_current_command}' | grep -iq vim && tmux send-keys C-h) || tmux select-pane -L"
bind -n C-j run "(tmux display-message -p '#{pane_current_command}' | grep -iq vim && tmux send-keys C-j) || tmux select-pane -D"
bind -n C-k run "(tmux display-message -p '#{pane_current_command}' | grep -iq vim && tmux send-keys C-k) || tmux select-pane -U"
bind -n C-l run "(tmux display-message -p '#{pane_current_command}' | grep -iq vim && tmux send-keys C-l) || tmux select-pane -R"
bind -n C-\ run "(tmux display-message -p '#{pane_current_command}' | grep -iq vim && tmux send-keys 'C-\\') || tmux select-pane -l"
Once you’ve setup your tmux config, you’ll also need to install a vim plugin.
Plug 'christoomey/vim-tmux-navigator'
The next thing we’re going to do is install Vimux, which will let you easily interact with tmux from vim.
Plug 'benmills/vimux'
Once we’ve installed vimux, we’ll want to setup our testrunner to take advantage of tmux. I personally use vim-test, which can be set to use vim with the following command in your vimrc:
let test#strategy = "vimux"
The last thing we’ll want to do is setup a shortcut for quickly fullscreening our vimux pane. This is useful for viewing test output, or if we want to check git history, etc..
map <Leader>z :VimuxZoomRunner<CR>
These are just the basics, and there’s a lot more you can do to boost your productivity with tmux. I think these are a good starting point for a saner test environment in vim though.
If you want to dig deeper, feel free to check out my dotfiles.
]]>One of the more difficult tasks for an engineering manager is building a shared culture among the team. Pairing is one of the best tools for accomplishing this goal. An easy example would be if you’re looking to establish TDD as a common practice.
It’s one thing to tell your developers to use TDD and even give a demonstration of its benefits, but if you want to ensure they’re following it, the best way is to pair with them. If you’re pairing on a regular basis and test drive all of the features while pairing, the other developers will start to adopt TDD and even bring new developers up to speed when pairing with them.
You’ve now established a culture of using TDD that will continue even if you stop pairing with your developers. The practice of pairing will ensure that your developers that use TDD currently will instill that habit upon new team members.
One of the many issues a growing team will encounter is the concept of isolated knowledge. If only one person knows how the new billing system works, product managers, engineers, and stake holders will all need to go to that one person with questions.
One of the best ways to mitigate this issue is through pairing. If you establish a culture of pairing, you’ll at a minimum have at least two people with knowledge of any given feature. This also allows for healthy discussion between engineers when it comes to building out new functionality around those features. It will also help drive discussion when it comes to grooming or estimating stories.
If your team is in the habit of rotating pairs, pretty soon your entire team will have a good idea of how each feature works. Your engineers will no longer get calls while on vacation, because anyone on the team is capable of answering those questions.
Introducing pairing to your team can be a challenge depending on your engineers. A lot of developers can be pretty averse to the idea of pairing if they don’t have experience with it. I think slowly introducting the concept is the right approach, as well as keeping it optional for each team.
A low barrier option to introduce pairing is by forcing code reviews to be a process that requires a pair. Paired code reviews are a great practice in general, because it’s a lot easier to relate to the original author when you’re talking to them while reviewing. This helps avoid some of the tensions that can arise through text based reviews. It will also help lower cycle time, because engineers need to actively seek a reviewer.
Once developers are in the habit of pairing for code reviews, you can start marking stories or features as items that need to be paired on. More complex stories or ones with a lot of stake holders are great use cases for pairing. Pairing on those stories will help with knowledge share, and get developers used to the idea of pairing.
I’ve found that once the ball starts rolling on pairing, engineers will usually jump on pretty quickly.
ScreenHero will allow you to share your entire screen with your pair and provides voice chat. This is useful for paired code reviews which require a browser typically, as well as for when developers switch to a browser while working on a feature.
Tmate is another great option, but has limitations for code review, as well as feature work that can’t be done in the terminal. You’ll also need a way to communicate with your pair. I’ve found Discord to be a great option there.
]]>The first thing we’ll need to do is allocate space for our swap file.
sudo fallocate -l 1G /swapfile
Once that’s done, we’ll need to enable our file, mark it, and turn it on with these commands
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
Once that’s done, we’ll want to make our swap file permanent. This way the swap sticks around even when we reboot our server, or if it crashes.
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
In this snippet, we’re going to be crawling my personal blog using HTTPoison and Floki.
posts = "https://www.mockra.com"
body = HTTPoison.get!(index_url, [], hackney: [:insecure]).body
posts = Floki.find(index_body, "section.post")
You’ll quickly notice something strange about the options we’re passing to HTTPoison. I’ve run into an issue when crawling some websites due to a bad certificate, so this is a work around for now. You can find more details about the issue here.
Once we get the content body, we can pass it into Floki to search for the information we want. In this example we’re grabbing the posts on the index page. If we wanted to get the title of the first post, we could do so with:
posts
|> List.first
|> Floki.raw_html
|> Floki.find("h3")
|> Floki.text
This is a bit of a crude example, but in this case, we’re grabbing the first
post from the list and converting it back to html. This lets us use the find
function again to grab the h3 element for the post. We then use Floki.text to
get the post title.
If you’ve ever used cronjobs before, quantum provides the same type of
functionality. You can setup scheduled tasks to run at specific intervals
through your config file. Here’s an example config/config.exs file:
config :quantum, cron: [
# Every 2 minutes
"*/2 * * * *": {Mockra.Bot, :run},
]
In this example, the run function on my bot module will run every 2 minutes.
Once I’ve setup my script and config, I’ll use mix to run my script. I’ll use the following command in a tmux session:
MIX_ENV=prod mix run --no-halt
I’ve transferred a few ruby and node scripts to Elixir, and the droplet I use for scripts has dropped from ~85% CPU load to ~1.5%. These are all unoptimized, but I was pretty surprised by the results.
]]> brew install postgresql
After that’s finished, you’ll need to run the setup command while specifying the utf8 encoding.
initdb /usr/local/var/postgres -E utf8
Once that’s complete you can start/restart postgres through the services command.
brew services restart postgresql
The final step is creating your default postgres user.
createuser -s postgres
You can now successfuly run mix ecto.create assuming you have the following
config in config/devs.exs.
config :api, Api.Repo,
adapter: Ecto.Adapters.Postgres,
username: "postgres",
database: "api_dev",
hostname: "localhost",
pool_size: 10
Feel free to replace the database option with something specific to your project.
]]>Here’s an example:
fill_form_and_submit(:user, :new, attributes_for(:user))
One of the best things I’ve done for my productivity and mental capacity was a move towards inbox zero. If you have 5,000 items in your inbox, it’s impossible to tell what you still need to respond to, or act upon. If your inbox has 6 items in it, it’s easy to see what tasks you need to do, or who you need to get back to.
By archiving all of the e-mails that I’ve “completed”, I’m able to quickly see what items need my attention. If there’s a pull request I need to review, it sits in my inbox until I’ve had the chance to do so. If my wife sends me a chore list, I can leave it in my inbox until I’ve completed all of the items on it. Since I’m always looking at my e-mail during the day, it’s an easy way to keep track of what needs to be done.
I never have to worry about forgetting to respond to an e-mail, or ignoring a comment on a project management tool. It removes a lot of the stress I used to feel that came from managing a messy inbox.
For a while, I found myself struggling to keep up with all of the news and information related to my interests. I was checking Hacker News daily for programming news, TeamLiquid for the latest Starcraft discussions, etc.. A while ago, I decided that I was spending way too much time checking news sources and I needed to cut them out of my daily routine. I decided to settle on Twitter and E-mail as my primary sources for news.
I signed up for newsletters for Hacker News, Ruby Weekly, Node Weekly, EmberJS, and many others. I now get a curated list of content once a week from each of the sources I used to spend time on daily. This allows me to check a bunch of interesting articles at once, dismiss uninteresting ones, and save good articles to Pocket for later.
I follow an assortment of developers on Twitter, and I find it a useful resource for keeping up with the latest trends and ideas in programming. Since I didn’t see myself being able to cut out Twitter from my daily routine, I decided to pipe in content from non-developer interests to Twitter. To this end, I created a Twitter Bot to tweet the top posts from subreddits I used to follow. I no longer spend hours on reddit checking news and reading discussions, the top content I care about is sent to my Twitter feed.
]]> brew install neovim/neovim/neovim
The first thing I needed to do was link my vimrc to my nvim config. I did so with the following command:
ln -s ~/.vimrc ~/.config/nvim/init.vim
Neovim should now look and behave pretty similarly to your standard vim setup.
Depending on your setup, there’s likely a few changes you’ll need to make to
your .vimrc. Here’s some of the issues I ran into:
I use vim-test to run tests while in vim, and needed to update my testing
strategy to work with neovim. This was done easily enough by adding the
following to my .vimrc:
let test#strategy = "neovim"
The switch also messed up my system clipboard commands, so I had to switch to use the system register. I created the following leader commands for yanking from vim to my system clipboard:
map <leader>y "*y<cr>
nnoremap <leader>yf :let @*=expand("%")<CR>
The first command will simply yank my current selection to the clipboard. The second command will add the current filename to the clipboard.
Those are the only changes I’ve had to make since switching to neovim, and I’ve been pretty happy with the results so far. I’ll be looking to adapt my current setup to take more advantage of neovim in the future as well.
]]>launchd. Starting,
stopping, and restarting these packages has likely been a cumbersome process.
Luckily, there’s an easy solution to your problem in Homebrew Services.
You can install homebrew services by running:
brew tap homebrew/services
The first thing you’ll want to do from there is see a list of currently running services, which can be done by running:
brew services list
Here’s an example of the ouput:
mysql stopped
postgresql started username LaunchAgents/homebrew.mxcl.postgresql.plist
redis started username LaunchAgents/homebrew.mxcl.redis.plist
rethinkdb stopped
Now that I have homebrew service, I can start mysql by running:
brew services start mysql
If I wanted to stop running redis, I could do that with:
brew services stop redis
Homebrew services also comes with a handy utility for cleaning up stale services and unused plists.
brew services cleanup