Python, Ruby, and Golang: A Command-Line Application Comparison

Python, Ruby, and Golang: A Command-Line Application Comparison

Python, Ruby, and Golang: A Command-Line Application Comparison

In late 2014 I built a tool called pymr. I recently felt the need to learn golang and refresh my ruby knowledge so I decided to revisit the idea of pymr and build it in multiple languages. In this post I will break down the “mr” (merr) application (pymr, gomr, rumr) and present the implementation of specific pieces in each language. I will provide an overall personal preference at the end but will leave the comparison of individual pieces up to you.

Application Structure

The basic idea of this application is that you have some set of related directories that you want to execute a single command on. The “mr” tool provides a method for registering directories, and a method for running commands on groups of registered directories. The application has the following components:

  • A command-line interface
  • A registration command (writes a file with given tags)
  • A run command (runs a given command on registered directories)

    Command-Line Interface

The command line interface for the “mr” tools is:

$ pymr --help
Usage: pymr [OPTIONS] COMMAND [ARGS]...

  --help  Show this message and exit.

  register  register a directory
  run       run a given command in matching...

To compare building the command-line interface let’s take a look at the register command in each language.

Python (pymr)

To build the command line interface in python I chose to use the click package.

@click.option('--directory', '-d', default='./')
@click.option('--tag', '-t', multiple=True)
@click.option('--append', is_flag=True)
def register(directory, tag, append):

Ruby (rumr)

To build the command line interface in ruby I chose to use the thor gem.

desc 'register', 'Register a directory'
method_option :directory,
              aliases: '-d',
              type: :string,
              default: './',
              desc: 'Directory to register'
method_option :tag,
              aliases: '-t',
              type: :array,
              default: 'default',
              desc: 'Tag/s to register'
method_option :append,
              type: :boolean,
              desc: 'Append given tags to any existing tags?'
def register

Golang (gomr)

To build the command line interface in Golang I chose to use the cli.go package.

app.Commands = []cli.Command{
        Name:   "register",
        Usage:  "register a directory",
        Action: register,
        Flags: []cli.Flag{
                Name:  "directory, d",
                Value: "./",
                Usage: "directory to tag",
                Name:  "tag, t",
                Value: "default",
                Usage: "tag to add for directory",
                Name:  "append",
                Usage: "append the tag to an existing registered directory",


The registration logic is as follows:

  1. If the user asks to --append read the .[py|ru|go]mr file if it exists.
  2. Merge the existing tags with the given tags.
  3. Write a new .[...]mr file with the new tags.

This breaks down into a few small tasks we can compare in each language:

  • Searching for and reading a file.
  • Merging two items (only keeping the unique set)
  • Writing a file

Python (pymr)

For python this involves the os module.

pymr_file = os.path.join(directory, '.pymr')
if os.path.exists(pymr_file):
    # ...

Ruby (rumr)

For ruby this involves the File class.

rumr_file = File.join(directory, '.rumr')
if File.exist?(rumr_file)
    # ...

Golang (gomr)

For golang this involves the path package.

fn := path.Join(directory, ".gomr")
if _, err := os.Stat(fn); err == nil {
    // ...

Unique Merge

Python (pymr)

For python this involves the use of a set.

# new_tags and cur_tags are tuples
new_tags = tuple(set(new_tags + cur_tags))

Ruby (rumr)

For ruby this involves the use of the .uniq array method.

# Edited (5/31)
# old method:
#  new_tags = (new_tags + cur_tags).uniq

# new_tags and cur_tags are arrays
new_tags |= cur_tags

Golang (gomr)

For golang this involves the use of custom function.

func AppendIfMissing(slice []string, i string) []string {
    for _, ele := range slice {
        if ele == i {
            return slice
    return append(slice, i)

for _, tag := range strings.Split(curTags, ",") {
    newTags = AppendIfMissing(newTags, tag)

File Read/Write

I tried to choose the simplest possible file format to use in each language.

Python (pymr)

For python this involves the use of the pickle module.

# read
cur_tags = pickle.load(open(pymr_file))

# write
pickle.dump(new_tags, open(pymr_file, 'wb'))

Ruby (rumr)

For ruby this involves the use of the YAML module.

# read
cur_tags = YAML.load_file(rumr_file)

# write
# Edited (5/31)
# old method:
#, 'w') { |f| f.write new_tags.to_yaml }
IO.write(rumr_file, new_tags.to_yaml)

Golang (gomr)

For golang this involves the use of the config package.

// read
cfg, _ := config.ReadDefault(".gomr")

// write
outCfg.WriteFile(fn, 0644, "gomr configuration file")

Run (Command Execution)

The run logic is as follows:

  1. Recursively walk from the given basepath searching for .[...]mr files
  2. Load a found file, and see if the given tag is in it
  3. Call the given command in the directory of a matching file.

This breaks down into a few small tasks we can compare in each language:

  • Recursive Directory Search
  • String Comparison
  • Calling a Shell Command

Python (pymr)

For python this involves the os module and fnmatch module.

for root, _, fns in os.walk(basepath):
    for fn in fnmatch.filter(fns, '.pymr'):
        # ...

Ruby (rumr)

For ruby this involves the Find and File classes.

# Edited (5/31)
# old method:
#  Find.find(basepath) do |path|
#        next unless File.basename(path) == '.rumr'
Dir[File.join(options[:basepath], '**/.rumr')].each do |path|
    # ...

Golang (gomr)

For golang this requires the filepath package and a custom callback function.

func RunGomr(ctx *cli.Context) filepath.WalkFunc {
    return func(path string, f os.FileInfo, err error) error {
        // ...
        if strings.Contains(path, ".gomr") {
            // ...

filepath.Walk(root, RunGomr(ctx))

String Comparison

Python (pymr)

Nothing additional is needed in python for this task.

if tag in cur_tags:
    # ...

Ruby (rumr)

Nothing additional is needed in ruby for this task.

if cur_tags.include? tag
    # ...

Golang (gomr)

For golang this requires the strings package.

if strings.Contains(cur_tags, tag) {
    // ...

Calling a Shell Command

Python (pymr)

For python this requires the os module and the subprocess module.

os.chdir(root), shell=True)

Ruby (rumr)

For ruby this involves the Kernel module and the Backticks syntax.

# Edited (5/31)
# old method
#  puts `bash -c "cd #{base_path} && #{command}"`
Dir.chdir(File.dirname(path)) { puts `#{command}` }

Golang (gomr)

For golang this involves the os package and the os/exec package.

cmd := exec.Command("bash", "-c", command)
stdout, err := cmd.Output()


The ideal mode of distribution for this tool is via a package. A user could then install it tool install [pymr,rumr,gomr] and have a new command on there systems path to execute. I don’t want to go into packaging systems here, rather I will just show the basic configuration file needed in each language.

Python (pymr)

For python a is required. Once the package is created and uploaded it can be installed with pip install pymr.

from setuptools import setup, find_packages

classifiers = [
    'Environment :: Console',
    'Operating System :: OS Independent',
    'License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)',
    'Intended Audience :: Developers',
    'Programming Language :: Python',
    'Programming Language :: Python :: 2',
    'Programming Language :: Python :: 2.7'

setuptools_kwargs = {
    'install_requires': [
    'entry_points': {
        'console_scripts': [
            'pymr = pymr.pymr:pymr',

    description='A tool for executing ANY command in a set of tagged directories.',
    author='Kyle W Purdon',
    author_email='[email protected]',

Ruby (rumr)

For ruby a rumr.gemspec is required. Once the gem is created and uploaded is can be installed with gem install rumr. do |s|        = 'rumr'
  s.version     = '1.0.0'
  s.summary     = 'Run system commands in sets' \
                  ' of registered and tagged directories.'
  s.description = '[Ru]by [m]ulti-[r]epository Tool'
  s.authors     = ['Kyle W. Purdon']       = '[email protected]'
  s.files       = ['lib/rumr.rb']
  s.homepage    = ''
  s.license     = 'GPLv3'
  s.executables << 'rumr'
  s.add_dependency('thor', ['~>0.19.1'])

Golang (gomr)

For golang the source is simply compiled into a binary that can be redistributed. There is no additional file needed and currently no package repository to push to.


For this tool Golang feels like the wrong choice. I don’t need it to be very performant and I’m not utilizing the native concurrency Golang has to offer. This leaves me with Ruby and Python. For about 80% of the logic my personal preference is a toss-up between the two. Here are the pieces I find better in one language:

Command-Line Interface Declaration

Python is the winner here. The click libraries decorator style declaration is clean and simple. Keep in mind I have only tried the Ruby thor gem so there may be better solutions in Ruby. This is also not a commentary on either language, rather that the CLI library I used in python is my preference.

Recursive Directory Search

Ruby is the winner here. I found that this entire section of code was much cleaner and more readable using ruby’s Find.find() and especially the next unless syntax.


Ruby is the winner here. The rumr.gemspec file is much simpler and the process of building and pushing a gem was much simpler as well. The bundler tool also makes installing in semi-isolated environments a snap.

Final Determination

Because of packaging and the recursive directory search preference I would choose Ruby as the tool for this application. However the differences in preference were so minor that Python would be more than fitting as well. Golang however, is not the correct tool here.

Thanks for reading ❤

python ruby go

Bootstrap 5 Complete Course with Examples

Bootstrap 5 Tutorial - Bootstrap 5 Crash Course for Beginners

Nest.JS Tutorial for Beginners

Hello Vue 3: A First Look at Vue 3 and the Composition API

Building a simple Applications with Vue 3

Deno Crash Course: Explore Deno and Create a full REST API with Deno

How to Build a Real-time Chat App with Deno and WebSockets

Convert HTML to Markdown Online

HTML entity encoder decoder Online

Basic Data Types in Python | Python Web Development For Beginners

In the programming world, Data types play an important role. Each Variable is stored in different data types and responsible for various functions. Python had two different objects, and They are mutable and immutable objects.

How To Compare Tesla and Ford Company By Using Magic Methods in Python

Magic Methods are the special methods which gives us the ability to access built in syntactical features such as ‘<’, ‘>’, ‘==’, ‘+’ etc.. You must have worked with such methods without knowing them to be as magic methods. Magic methods can be identified with their names which start with __ and ends with __ like __init__, __call__, __str__ etc. These methods are also called Dunder Methods, because of their name starting and ending with Double Underscore (Dunder).

Python Programming: A Beginner’s Guide

Python is an interpreted, high-level, powerful general-purpose programming language. You may ask, Python’s a snake right? and Why is this programming language named after it?

What's new in the go 1.15

Go announced Go 1.15 version on 11 Aug 2020. Highlighted updates and features include Substantial improvements to the Go linker, Improved allocation for small objects at high core counts, X.509 CommonName deprecation, GOPROXY supports skipping proxies that return errors, New embedded tzdata package, Several Core Library improvements and more.

Hire Python Developers

Are you looking for experienced, reliable, and qualified Python developers? If yes, you have reached the right place. At **[]( "")**, our full-stack Python development services...