Mailtrap Blog

Time-saving Tools for Developers. Part 2: Dev Tools and Approaches

Hey! You are reading the second part of the article about everyday time- and effort- saving tools for developers. The first part was dedicated to work management, such as planning, communication, and information handling.

Time-saving Tools for Developers. Part 1: Planning and Communication

Here we will talk about coding – in particular, about time-saving tools, development approaches, and some small tricks.

Undoubtedly, every software engineer has their own set of tools and approaches. There are so many of them that it is impossible to gather a list of the best fitting all needs. That’s why I asked my teammates at Railsware, a product studio that has created Mailtrap and other great products, what development tools help them save time and effort in their daily working process.

Before we get straight to the point, I would like to note that technologies develop at lightning speed now. What was considered an innovation yesterday becomes a standard today. Effective software engineering is based on approaches rather than particular tools. Productive collaboration and automation are two basic principles that help us achieve better results. 

Git/GitHub tips and tricks

GitHub is our main development collaboration tool, so let’s start with the Git-related techniques that can save you time and sometimes nerves. 

Git aliases 

Git aliases are shortcuts you can create for the Git commands that you frequently use. Some developers use auto-completion for lengthy commands, but it still requires pressing “Tab” and can lead to mistakes. That’s why we use so-called mnemonics – combining the letters  the consecutive words start with. 

To create your aliases, edit .gitconfig in your user directory. 

Here are some of our favorite aliases:

And here is a more detailed list:

$ git aliases
alias.aa add --all
alias.ap add --patch
alias.branches for-each-ref --sort=-committerdate --format="%(color:blue)%(authordate:relative) %(color:red)%(authorname)       %(color:white)%(color:bold)%(refname:short)" refs/remotes
alias.ci commit -v
alias.co checkout
alias.pf push --force-with-lease
alias.st status
alias.aliases config --get-regexp alias
alias.a add
alias.st status
alias.s status -s
alias.ci commit
alias.amend commit --amend
alias.rb rebase
alias.co checkout
alias.nb checkout -b
alias.br branch
alias.fe fetch
alias.cp cherry-pick
alias.d diff
alias.dc diff --cached
alias.ps push
alias.psoh push -u origin HEAD
alias.prune-branches !f() {     removal_flag=${1:--d};     git branch -vv | grep gone | awk '{print $1}' | xargs git branch $removal_flag;   }; f
alias.cop !sh -c 'git branch | fzf | xargs git checkout' -
alias.l log --graph --date=short
alias.stats shortlog -sn
alias.praise blame
alias.recent for-each-ref --count=10 --sort=-committerdate refs/heads/ --format=%(refname:short)
alias.overview log --all --since='2 weeks' --oneline --no-merges
alias.recap log --all --oneline --no-merges --author=<MY_EMAIL>
alias.testfest !f() {     tag=$(git describe --abbrev=0 --tags);     read -p "Continue with tag '$tag'? (Y/n) " -n 1;     if [[ "$REPLY" =~ ^[Nn]$ ]]; then tag=$(git tag | fzf); fi;     echo;     git log $tag.. --merges --oneline | grep 'Merge pull request';     echo "Listed merged PRs since '$tag'";   }; f

We use testfest to show all merged pull requests since the last release, but it also can be used to gather the release notes. 

Other tools


#!/usr/bin/env ruby
ISSUE_PATTERN = /^\d+|\w{2}-\d+$/ # Pivotal Tracker or Jira project with two letters, as project short name
branch = `git rev-parse --abbrev-ref HEAD`
issue_id = branch.split('/').first[ISSUE_PATTERN] or exit
issue_id.prepend('#') if issue_id =~ /^\d/ # pivotal ids get prepended with #
commit_msg = File.open(ARGV[0], &:read)
exit if commit_msg.start_with?('[') # do not prepend if already there
exit if commit_msg.start_with?('fixup! ') # do not prepend if using commit --fixup
delimiter = commit_msg[0] ==  '#' ? "\n" : ' ' # only add newline if commit message is empty
File.open(ARGV[0], 'w') do |file|
  file.write "[#{issue_id}]#{delimiter}#{commit_msg}"
end
Join our newsletterOnly the best content, delivered once a month. Unsubscribe anytime.

DevOps tools and approaches 

Deployment is another important part of software engineers’ work that can be streamlined. 

CI/CD – continuous integration and delivery 

CI/CD is an important approach that allows you to automatically validate and deploy your changes. When adding new functionality or editing something that already exists, it is essential to understand that your new commit works and won’t break anything. Continuous integration solves this problem. With a CI tool, a series of automated tests is run against new commits. If any errors are found, you get an instant notification.

Continuous delivery is the next step in this process: your product changes are automatically deployed in production (once successfully tested). Such an approach is crucial for apps that require constant daily updates. 

CircleCI is an awesome tool that supports integration with both GitHub and Slack. 

Linting

Always make sure that your code is properly linted. Linters check your code for programmatic and stylistic issues, resolving three types of problems:

Linters are specific for each language – Rubocop for Ruby, ESLint for JavaScript, PyLint for Python, etc. 

Testing and automation 

Testing and automation are two essentials of software development. There are tons of tools and approaches that your and our teams use daily. Here I’m listing several small but super helpful tools that can make your life easier. 

Foreman 

This is free open-source software for managing servers. Foreman is helpful for automation of repetitive tasks (running all necessary processes with a single command, for example), but has an extensive set of features: 

Postman and Insomnia 

Both these tools are equally good for testing and debugging REST APIs. They allow you to create shared collections with saved requests, which eliminates the need to keep remembering how to use each API. 

One of the use cases is writing automated tests and integrating them into your CI/CD pipeline (described a couple of paragraphs earlier). 

Shared collections in Postman

Mailtrap

Mailtrap will save you time and effort when working with email functionality. It is a full-featured online tool for safe email testing in development and staging environments. Setting your own email test server will take around three hours, while signing up for a Mailtrap account and integrating it with your app will take no more than three minutes. Integration can be performed via the RESTful API or as a regular SMTP. 

Our development team created Mailtrap after sending a batch of test emails to customers by mistake. Since then, we have been developing it to provide simple but effective email testing. The main features include:

This way, you can safely test whether your email sending functionality works at all, view how the message content and variables are generated, share your testing results, and run automated tests. 

Test Your Emails Now

Several more helpful things

Pair programming

Pair programming is an awesome Agile technique that helps improve team collaboration, boost your hard skills, and enhance the quality of the product you build. Here is a great long read on pair coding published on Martin Fowler’s website.

One of the challenges of programming together is code sharing. For a long time, we have been sharing our screens, and it was annoying. Fortunately, there is a code sharing functionality in a couple of editors:

With it, you can share not just one file, but the whole project along with terminal. This way, you can really work together and even run tests. 

Laptop setup and updates

One of my teammates noted that macOS likes to be fresh, and tends to slow down after two or three major upgrades of the operating system, so he does a new install every year or two. A fresh installation means that you need to set a whole bunch of tools and their configurations that you use. 

There are at least two options that can help you resurrect your setup:

Alternatively, don’t forget about backing up your data or having an opportunity to return it when needed. For this purpose, we recommend using data recovery software that able to restore your data if something goes wrong.

Final words

Over years of experience, every software engineer has been creating their own set of time-saving and efficiency tools, depending on their projects and technology stack. In this post, I have gathered ubiquitous tools recommended by my colleagues at Railsware for delivering better results with peace of mind. 

We will be happy to know what you use in your everyday development flows and to discuss various solutions. Share this post on social media, and may the force be with you! 

Exit mobile version