DEV Community: Oinak

Safer sandboxing in Rails

Oinak — Wed, 06 Aug 2025 13:37:19 +0000

Ruby on Rails console has a very interesting feature, that you can see on its documentation:

As you can see it says Any modifications you make will be rolled back on exit.

But that vague language can lead to some unexpected surprises.

This "sandbox mode" is based on a db transaction that is automatically rolled back when wou exit the console, effectively undoing any changes you may have made ... on the db.

Unfortunately, modern applications can have a wide range of side effects, besides db-based data persistence.

These is a non exhaustive list of things you might need to be on the lookout for:

POST/PUT external calls
Emails sent
Payments
Non db-based file uploads (or deletions)

One thing you can do, is prepare your classes to be called safely

class PotatoReport
  def initialize(data, dry_run: true)
    @data = data
    @dry_run = dry_run
  end

  def run
    @report = generate_report
    write_file
  end

private

  attr_reader :dry_run

  def write_file
    Rails.logger.info "[PotatoReport] generating #{filename} on #{timestamp}"
    return if dry_run # or write the file to stdout instead

    File.write(report_filename, report_content)
  end

  #...

end

Then on your application code you can call:

PotatoReport.new(data, dry_run: false).run

but on the console, no matter if you pass dry_run: true or forget about it, you are not going to be writing a file.

The thing is that if you do this, you need to be on the look for when some of your objects are calling others to make sure you pass your dry_run flag along.

I hope this save you some headaches. It has certanly allowed me to do some production data changes with a greater peace of mind.

Cover pic: Gil Garcia

Easy logging in your small ruby scripts/apps

Oinak — Mon, 14 Jul 2025 13:37:23 +0000

I have recently shared A configuration system for ruby CLIs.

If you are designing a new ruby application or script, it is very possible that you wnt to write some logs to now what things ar heppening (or did happen) during the execution.

If you are using a large framework like Ruby on Rails thin might be solved for you, see Rails.logger.

But if you are building a small script or app you might be missing the conveninence of being able to call logger.info from anywhewre.

To this effect, I have a small module that cover the mos basic needs:

module Loggable
  def self.included(base)
    base.extend ClassMethods
  end

  def logger = self.class.logger

  module ClassMethods
    def log_to(logger) = @logger = logger
    def logger = @logger ||= ::Logger.new($stdout)
  end
end

You can include thi in any of your classes, and it gives you the essential interface.

class MyClass
  include Loggable

  def foo
    logger.info "This is an informative message"
  end
end

and then if you run

MyClass.new.foo

You will see:

I, [2025-07-14T15:20:25.814143 #6137]  INFO -- : This is an informative message

In the standard output.

You can check Ruby Logger docs to see the underlying options.

Additionally, you have a class-level log_to method that you can call like this:

log_to custom_logger

To set up any specialised behavior. One such example is suppresing logging in tests:

  # example using minitest/spec dsl
  let(:logger) do
    # ignore logger output except when testing it
    Object.new.tap do |o|
      def o.info(*); end
      def o.error(*); end
    end
  end

  before do
    MyClass.log_to(logger)
  end

This allows to inject a fake logger (or a double, or a mock or a spy...) without having Dependency Injection set up on every Logabble class initialize method.

If you know me you know I am very fond of tests, so of course here you have the test that goes with this module:

# minitest/spec DSL
describe Loggable do
  let(:dummy_class) { Class.new { include Loggable } }

  describe '.included' do
    it 'extends ClassMethods' do
      expect(dummy_class.singleton_class.included_modules).must_include Loggable::ClassMethods
    end
  end

  describe '#logger' do
    it 'returns the class logger' do
      expect(dummy_class.new.logger).must_equal dummy_class.logger
    end
  end

  describe Loggable::ClassMethods do
    describe '.log_to' do
      it 'sets the logger device' do
        logger = Object.new
        dummy_class.log_to(logger)
        expect(dummy_class.logger).must_equal logger
      end
    end

    describe '.logger' do
      it 'defaults to a logger instance' do
        expect(dummy_class.logger).must_be_instance_of Logger
      end
    end
  end
end

I hope this is useful to you at some point, if it is, or you have a much better way, please let me know in the comments.

Cover image by Robert Larsson

A configuration system for ruby CLIs

Oinak — Tue, 08 Jul 2025 17:53:37 +0000

If you have developed Rails applications you might be familiar with its configuration system but if your are working on a CLI utility you might miss part of that convenience.

Let me share with you a simple system that gets you set with just a couple of files:

The hook

somewhere close to the first lines of code you run you have something like this:

    options = Parser.parse_options
    Config.setup(**options)

I do this just after setting zeitwerk up.
the you need 2 files:

The Parser

This is based on rubys stdlib's OptionParser class.

require "optparse"

module Parser
  extend self

  def parse_options
    options = {}
    OptionParser.new do |parser|
      load(parser, options)
      progress(parser, options)
      memory(parser, options)
      #...
    end.parse!
    options
  end

  def load(parser, options)
    parser.on("-l", "--load", "Load data files") do |l|
      options[:load_files] = l
    end
  end

  def progress(parser, options)
    parser.on("-p", "--progress", "Show progress bar for long processes") do |p|
      options[:progress] = p
    end
  end

  def memory(parser, options)
    parser.on("-M", "--memory", "Use in-memory db") do |m|
      options[:memory] = m
    end
  end
  #...
end

This is very reusable because it is initializing options as an empty hash, a returning a hash with only the options that have been set up.

If you want to show the default value on some option you can use #{Config::DEFAULTS[:option_name]}.

But if you are not using the next part, you can just use this and have a hash of options to store where you like.

The Config Singleton

require "singleton"

# Global configuration object with automatic defaults
#
# Usage:
#   Configure with: Config.setup(load_files: true, ...)
#   Access with:    Config.value(:load_files)
#
class Config
  include Singleton

  DEFAULTS = {
    load_files: false,
    progress: false,
    memory: false,
    option_name: "default_value",
  }.freeze

  Options = Data.define(*DEFAULTS.keys)

  def self.setup(**) = instance.setup(**)

  def self.value(key)
    raise ArgumentError, "Unknown configuration key: #{key}" unless DEFAULTS.key?(key)

    instance.config.public_send(key)
  end

  def config = @config ||= Options.new(*DEFAULTS.values)

  def setup(**kwargs)
    updated_values = DEFAULTS.merge(kwargs)
    @config = Options.new(*updated_values.values_at(*DEFAULTS.keys))
  end
end

First we declare DEFAULTS as a hash with the keys being our option names and the values being the default values if the option is not explicitly configures by the user.

Then we define the Value Object with

    Options = Data.define(*DEFAULTS.keys)

This takes advantage of Ruby's Data.define functionality. You can see the documentation here, but the TL;DR it is a Struct like immutable object.

The we have this slightly cryptic:

   def self.setup(**) = instance.setup(**)

This means, if you call Config.setup on the class, we are going to call it on the (singular) instance that is keeping the state.

Then you have a class method for reading a config value:

    def self.value(key)
      raise ArgumentError, "Unknown configuration key: #{key}" unless DEFAULTS.key?(key)

      instance.config.send(key)
    end

It uses DEFAULTS as an allow list to prevent the dynamic send we do on the Data instance from posing any security risk on malicious config keys.

We would use instance.config.to_h[key] instead.

The we have

  def config = @config ||= Options.new(*DEFAULTS.values)

which is memoizing the value object on the Singleton instance.

And then the trickiest part:

    def setup(**kwargs)
      updated_values = DEFAULTS.merge(kwargs)
      @config = Options.new(*updated_values.values_at(*DEFAULTS.keys))
    end

This is the method that allows you to update a config value (or several). Because Data.define object are immutable, when you have a new config, you create a new one based on the existing one plus your changes.

If you choose to use a hash instead of a Data.define, you could use merge! here.

This is the method that we were calling from "the hook" with the options hash returned from the Parser class.

With just this now you have a global Config object you can access anywhere in your app.

If you want extra ergonomics, you can have a concern like this:

module Configurable
  def self.included(base)
    base.extend Methods # for class methods
    base.include Methods # for instance methods
  end

  # Methods module to allow including and extending
  module Methods
    # Convenience method for configuration values
    def config(key, setup_config: ::Setup::Config)
      setup_config.value(key)
    end
  end
end

And then in any of you classes do something like:

class MyClass
  include Configurable

  def my_method
    if config :option_name
      puts "optional behavior"
    end
  end

I hope you find it useful.

Let me know if you use it on any projects.

--
cover image: yinka adeoti

Local API in a single file

Oinak — Sat, 03 Feb 2024 19:59:34 +0000

image credit: pngimg

Sometimes yo need to develop an API client for a service that you cannot call. I.e. if payments or modification of delicate data are to happen when you make calls. Some APIs hae a test or sandbox environment that you can call instead, like Stripe, but it is not always the case.

Another scenario in which you might want a dummy API is if you are developing both the client and the server, but you don't have the server yet. If you are looking for market fit of a prototype, starting on the client/UI makes a lot of sense, as it is much easier to ask potential users and or investors about something they can see/touch.

For the most basic cases like users, posts or products, there are numerous services online you can hook to.

With that out of the way, if you need or just want your own API server, be it because you want more control on the behaviour, response content, or don't want to depend on connectivity, here is a way you can do it.

Self contained dependencies

We are going to take advantage of a Bundler feature that allows you to include a dependency declaration within your ruby script.

Here you can find the documentation

So to begin, we will create a ruby file called app.rb and write this:

#!/usr/bin/env ruby
# frozen_string_literal: true

require 'bundler/inline'

gemfile(true) do
  source 'https://rubygems.org'

  gem 'rackup', '~> 2.1'  # sinatra needs this to serve
  gem 'sinatra', '~> 4.0'
  gem 'sinatra-contrib', '~> 4.0'
end

Single class API

We are going to use Sinatra-rb, a very small but powerful ruby framework.

You can defin a sinatra app with something like:

require 'sinatra'
get '/frank-says' do
  'Put this in your pipe & smoke it!'
end

But I prefer the modular style. So they look like this:

class App < Sinatra::Base
  get '/' do
    "Hello"
  end
  # run server if you run the script by name
  run! if app_file == $PROGRAM_NAME
end

You may have noticed that I included sinatra-contrib gem earlier. It is a compendium of commonly used extras for Sinatra, among them, nice JSON suport.

Your API can do what ever, you should explore Sinatra's docs to find what you need, but I will include a little example here:

# inline bundler section you saw before

require 'sinatra/base'
require 'sinatra/json'

# Dummy API
class App < Sinatra::Base
  get '/' do
    'Use "GET /orders.json?page=N" to get order data'
  end

  get '/orders.json' do
    orders, page, total_pages = paginate(order_data)

    redirect to('/not_found') if page > total_pages

    json({ orders:, page:, total_pages: })
  end

  not_found do
    status 404
    json({ error: 'Not found' })
  end

  def paginate(list)
    page = (request.params['page'] || '1').to_i
    per = (request.params['per'] || '3').to_i
    total_pages = (order_data.size / per.to_f).ceil
    return [[], page, total_pages] unless (1..total_pages).include? page

    [list[per * (page - 1), per], page, total_pages]
  end

  def order_data
    # ... coming later
  end

  run! if app_file == $PROGRAM_NAME
end

In this example I included a single get endpoint returning a list of an "order" resource, and I implemented a very naif pagination just in case the client needs to deal with that.

This is by no mean the only way to do so, you could have, all pages return the same result and just change the pagination attributes or whatever. Explore what you need and adapt to suit your use case.

Embeded data

There is a slightly mysterious bit on the code above where the order_data method is not shown. That is because I want to tell you about another nifty feature of Ruby regarding single-file scripts.

In ruby you can use END to mark the end of the normal source file. Ruby won't run anything bellow that line, but the rest of the contents of the file will be available as the special IO object DATA.

So the end of my script looks something like this:

  # the rest of the file you have already seen

  def order_data
    @@order_data ||= YAML.load(DATA.read)
  end

  run! if app_file == $PROGRAM_NAME
end

__END__
---
  - date: 2020-01-01T09:00Z
    customer_id: 1
    order_lines:
      - product_id: 1
        units: 2
        unit_price: 1000
      - product_id: 3
        units: 1
        unit_price: 499
  - date: 2020-01-02T09:03Z
    customer_id: 2
    order_lines:
      - product_id: 2
        units: 1
        unit_price: 499
  - date: 2020-01-04T11:20Z
    customer_id: 2
    order_lines:
      - product_id: 2
        units: 1
        unit_price: 499
  - date: 2020-01-13T15:00Z
    customer_id: 3
    order_lines:
      - product_id: 1
        units: 2
        unit_price: 1000
      - product_id: 3
        units: 1
        unit_price: 999
  - date: 2020-01-13T15:05Z
    customer_id: 2
    order_lines:
      - product_id: 1
        units: 1
        unit_price: 1000
      - product_id: 2
        units: 2
        unit_price: 499

There are a couple of interesting bits here:

The data bellow __END__ is in YAML format. YAML is a serialization language very common in ruby world. Ruby on rails config files, for instance, are written in YAML.

You can find YAML supported on Ruby's standard library, but you will need to throw a require 'yaml' to have the YAML object available.

In this case I could have used JSON directly, but YAML is friendlier for humans to edit unless you love writing zillions of {s,"s, and }s.

Another thing is happening, is that I am using a class variable @@order_data, to memoize this information. This is to avoid having to read if every request (Sinatra uses a new instance per request, but the class data lives while the server is running).

Conclusions

There you have it. i have shared with you three tools that combined let you define a Single File Local API stand-in that you can run anywhere you have Ruby and bundler as easy as doing:

$ ./app.rb 
Fetching gem metadata from https://rubygems.org/.........
Resolving dependencies...
[2024-02-03 20:45:07] INFO  WEBrick 1.8.1
[2024-02-03 20:45:07] INFO  ruby 3.3.0 (2023-12-25) [x86_64-linux]
== Sinatra (v4.0.0) has taken the stage on 4567 for development with backup from WEBrick
[2024-02-03 20:45:07] INFO  WEBrick::HTTPServer#start: pid=124069 port=4567

With the #!/usr/bin/env ruby on the first line (it is called a shebang) you don't even need to specify Ruby as the interpreter on most environments.

I hope you have found this useful, or at least, entertaining.

Please let me know what fun things you do with it.

As the wise Avdi says: "Happy Hacking"

A take-home exercise scaffold for ruby

Oinak — Sat, 23 Sep 2023 21:12:48 +0000

(cover by @reeto)

Many developer job hiring processes include some sort of take-home exercise.

In Ruby it will usually be one of three things:

A small Rails app
A gem
A script

A rails app can be initialized via the rails new command as well as through some of the numerous rails application templates that can be found on the web.

If you are doing a gem, bundle gem <NAME> command has you covered.

However, both of these options are not optimal for exercises, a Rails app has a lot of files, many of them generated, making the correction/review of the exercise really arduous.

A gem on the other hand, without a context to be used in, loses part of its utility, and won't be pushed to (or installed from) Rubygems.

So a script is the best option from the reviewer POV, but also the most manual if you are the person doing the exercise.

Both Rails and Bundler offer some taken decisions for you so you can run with the defaults and change only what you need, but a script scenario leaves you with the proverbial blank canvas.

As a reviewer, I prefer giving out the script kind of problem because it is what tells me the most about the candidates, including how do they make those choices usually provided by the framework or tooling.

When I am a candidate, on the other hand, I know those initial steps offer low "bang for the buck". You can do the right or bad but you are not probably going to impress any reviewer with them.

They also detract from the limited time you have to complete the challenge.

To work around this, I have a template folder for ruby-script projects, which can be used as-is or with small modifications depending on your needs and preferences.

Gems

First thing I include is a Gemfile, which is the configuration file for bundler, the tool that manages library dependencies in Ruby.

# Gemfile
# frozen_string_literal: true

source 'https://rubygems.org'

group :development do
  gem 'minitest'
  gem 'rake'
  gem 'rubocop'
  gem 'simplecov'
  gem 'solargraph'
end

You can generate your Gemfile.lock with bundle. I do it for convenience reasons related to my editor integration, but if you can't or don't want to, there are instructions below to bundle within a Docker container.

Docker

Your script will have to run on a different machine, and managing dependencies and language environment without knowing the target machine in advance can be challenging. Docker is almost a de facto standard nowadays and it is not far fetched to assume it will be available.


# Dockerfile
FROM ruby:3.2

# install necessary packages and jemalloc
RUN apt-get update && \
      apt-get install libjemalloc2 && \
      apt-get clean && \
      rm -rf /var/lib/apt/lists/*

# Set enviroment
ENV LD_PPRELOAD=/usr/lib/x86_64-linux-gnu/libjemalloc2.so.2

WORKDIR /usr/src/app

COPY Gemfile Gemfile.lock ./

RUN bundle install --jobs=4

COPY . .

here you have an explanation on the jemalloc part. If you don't want or don't need it, just omit 2nd and 3rd instructions on the Dockerfile.

You can build this image with

docker build . -t my_ruby

Use whatever you want instead of 'my_ruby' it is a custom tag to identify your image.

And run it with

docker run -it my_ruby

By default it runs irb

Helper scripts

When you are developing it is very common to add dependencies, or change some aspects of your images. To avoid repeating long commands, you can set aliases on your system, but those require their own configuration. I prefer to include a bin folder on the project with some helper scripts.

You can create a bin/build file with the first command, then run chmod +x bin/build to make it executable and then you can just call bin/build as many times as you need.

# bin/build
docker build . -t my_ruby

For the second, you can create a bin/run equivalent like so

# bin/run

# Run arbitrary commands (defaults to 'bash') within the container.
docker run -it my_ruby "${@:-bash}"

The $@ in bash gives you all the remaining arguments i.e:

$ bin/run ruby -e'puts "hello"'
hello

Here ruby -e'puts "hello"' replaces the default command bash

If your project does not require any additional service, like a database, this is enough, if it does, keep reading to see how to use docker-compose command in the bin scripts instead.

Docker compose

Docker compose is a tool that allows you to declare more that one docker image/containers to be spun up at once and depend on one another. One common use case of this is to use containerized databases (i.e: Postgres, Mysql) or cache-stores (i.e Redis, Memcached)

Here you can see the template file I have with the parts to set up a Postgres db present but commented out.

# docker-compose.yml
version: '3'

# volumes:
#   db-data:
services:
  app:
    build: .
    environment:
      RAKE_ENV: test
      # POSTGRES_USER: username # The PostgreSQL user (useful to connect to the database)
      # POSTGRES_PASSWORD: password # The PostgreSQL password (useful to connect to the database)
    command: ['irb']
    volumes:
      - '.:/usr/src/app'
    # depends_on:
    #   - database
  # database:
  #   restart: always
  #   image: 'postgres:latest'
  #   ports:
  #     - 5432:5432
  #   environment:
  #     POSTGRES_USER: username # The PostgreSQL user (useful to connect to the database)
  #     POSTGRES_PASSWORD: password # The PostgreSQL password (useful to connect to the database)
  #     POSTGRES_DB: development # The PostgreSQL default database (automatically created at first launch)
  #   volumes:
  #     - 'db-data:/var/lib/postgresql/data/:rw'

With this config file, the command to build your main docker image (the Ruby one), and thus the content of your bin/build script become:

# bin/build
docker-compose build

This will tag your image based on the folder name unless you set up a custom tag on the config file.

Comparatively, your bin/run script would become:

docker-compose run --rm -e RAKE_ENV=development app ruby -Ilib lib/cli.rb

There is a lot going on here so I will go step by step.
docker-compose run <OPTIONS> <SERVICE> <COMMAND>

Options:

--rm to remove the container after the command (saves disk space)
-e RAKE_ENV=development sets enviroment variables in the container

Service:
That app is no special sttring there, it is whatever you call your main service on the docker-compose.yml file.
Remember that

# docker-compose.yml (excerpt)
services:
  app: # <----------------------
    build: .

If you write 'my_app' on that file, you need 'my_app' on the run command.

Command:
That ruby -Ilib lib/cli.rb is whatever command you want to run. It overrides the command value from the docker-compose.yml file, which overrides the CMD value from the Docker image (we did not set a custom one, but Ruby image we used as a base sets irb)

If it looks like I am using a lot of options here, it is in part to reinforce the convenience of having all this complexity comfortably abstracted under bin/run, but I can assure you all these are real options I have used on a project.

I have not explained yet what that lib/cli.rb is yet, because I want to speak about the Ruby parts.

A Ruby script

Here are some choices I take:

We will use Zeitwerk to load constants.- The script with have a Command Line Interface (cli) that will potentially accept options via Optparse.
We will have linting/static analisys with Rubocop
We will have tests written with Minitest
We will measure test coverage with Simplecov

Zeitwerk

If you are use to work with Rails, you probably have never worried about requiring files in Ruby, because the framework takes care of it for us.

Even before Zeitwerk, Rails had a complex constant autoload system.

Thanks to Zeitwerk any gem can benefit from a similar system and Rails has adopted it as it has some advantages over the original system.

However Zeitwerk does not directly support scripts, so we require the setup class see https://github.com/fxn/zeitwerk/issues/38#issuecomment-484747340 for a detailed explanation.

# lib/setup.rb
require 'zeitwerk'

# run any preparation needed
module Setup
  extend self

  def run
    $stdout.sync = true # instant console output
    zeitwerk_setup # load constants with zeitwerk
  end

  def zeitwerk_setup
    loader = Zeitwerk::Loader.new
    loader.push_dir(File.absolute_path(__dir__))
    loader.setup # ready!
  end
end

Setup.run

And then on your main file (cli.rb in my case) do require 'setup'

Options

Options can vary a lot from one project to another, so I have a skeleton file like this:

require 'optparse'

class Cli
  # option parser for the Command line Interface
  class Options
    include Singleton

    attr_reader :options

    def parse
      @options = {}
      PARSER.parse!
    end

    PARSER = OptionParser.new do |opts|
      opts.banner = 'Usage: cli.rb [options]'

      opts.on('-v', '--[no-]verbose', 'Run verbosely') do |v|
        @options[:verbose] = v
      end
    end
  end
end

And I refer to Optparse's help for more.

CLI

I use a cli.rb file to load dependencies, parse options and call the custom logic as needed.

Much of that is undefined at the beginning, so my barebones cli.rb file is something like this:

# frozen_string_literal: true

# Zeitwerk does not directly support scripts, so we require the setup class
# see https://github.com/fxn/zeitwerk/issues/38#issuecomment-484747340
require 'setup'

# Command line interface
module Cli
  extend self

  def run
    Options.parse # Options.instance.options keeps state
  end
end

Cli.run if $PROGRAM_NAME == __FILE__

Tests

I use a quite default rake configuration to run tests:

# Rakefile
# frozen_string_literal: true

require 'rake/testtask'

Rake::TestTask.new(:test) do |t|
  t.libs = %w[lib test]
  t.pattern = 'test/**/*_test.rb'
end

task default: :test

This allows you to call rake within the Ruby container to run all tests.

To run the tests from outside the Docker images you can set up another bin script:

# bin/test
docker-compose run --rm -e RAKE_ENV=test app rake test

To have minitest config on a single place, I create a test/test_helper.rb file:

# test/test_helper.rb
# frozen_string_literal: true

require 'minitest/autorun'
require 'minitest/pride'
require 'debug'

module Minitest
  class Test
    # include TestHelperClasses
  end
end

Coverage

To add coverage measurements, make sure you have 'simplecov' con your Gemfile and modify the test/test_helper.rb file to start like this:

# test/test_helper.rb
# frozen_string_literal: true

require 'simplecov'
SimpleCov.start do
  enable_coverage :branch
end
# ...

When you run your test suite, it will create a report on coverage/index.html

This will survive when the container ends because of the docker-compose volume on .:/usr/src/app, however, it will be owned by root user (the default user within the Docker container) unless you add ad-hoc configs. You can recursively chown that folder instead.

Linting

On top of testing, I like to use static analysis tools to help me keep the codestyle consistent, avoid common mistakes, and follow community guidelines.

To use rubocop, you need to have it on your Gemfile.

Unless you adhere to 100% of the tool defaults, you might want to have a configuration file:

# .rubocop.yml
AllCops:
  NewCops: enable
  TargetRubyVersion: 3.2

Metrics/BlockLength:
  AllowedMethods: ['describe', 'context']

Style/ModuleFunction:
  EnforcedStyle: extend_self

Style/NumericPredicate:
  Enabled: false

To run rubocop confortably, we can once again create a bin script:

# bin/lint
docker-compose run --rm app rubocop

Additional bins

I have still two more convenience bin scripts:

# bin/shell
docker-compose run --rm -e RAKE_ENV=development app bash

and

# bin/console 
# Open an irb session with the code loaded in the style of 'rails console'
docker-compose run --rm -e RAKE_ENV=development app irb -Ilib

Summary

Here you have an overview of the files we have reviewed.

.
├── bin
│   ├── build
│   ├── console
│   ├── lint
│   ├── run
│   ├── shell
│   └── test
├── docker-compose.yml
├── Dockerfile
├── Gemfile
├── Gemfile.lock
├── lib
│   ├── cli
│   │   └── options.rb
│   ├── cli.rb
│   └── setup.rb
├── Rakefile
└── test
    └── test_helper.rb

5 directories, 15 files

I hope this helps you build your own version of the project template, and that it can save you some precious time the next time you have a hiring process take-home challenge, or you want to start a pet project.

What about you?

Did you have something similar? something different?
Do you have a version of this idea for other language?
Did it work for you?
Did you make any interesting changes?

Please let me know in the comments.

Edited to fix the typos spotted by @raul, thanks pal!

Neovim config from scratch (Part II)

Oinak — Wed, 11 Jan 2023 17:57:04 +0000

This is a continuation from Neovim config from scratch (Part I).

There I covered:

Nuke from orbit (starting from a clean slate)
Create the config folder
Plugin manager
Fuzzy finder
Colorscheme
Treesitter
Additional plugins
Set options
Mappings

I you came here loking for any of those, please visit the link.

Language Support

I used to base my language support on CTags. But due to neovim's native support of LSP I am trying that too.

CTags

Requirements:
You need to have a CTags implementation like universal-ctags installed on your system (on every system where you use vim).

For Linux distros it is commonly available as a package, see: debian, ubuntu
For OSX it is available via homebrew

Configs

Tell nvim where to find your tag file, the default is tags

-- (Exuberant/Universal) Ctags
vim.opt.tags = '.tags'

Key mapping to refresh your tags

function RTags()
  vim.cmd [[!ctags -f .tags --languages=ruby --exclude=.git -R .]]
end

vim.keymap.set("n", "rT", RTags)

You can automate this via githooks, if you work usually on the same repo(s).

On top of this you can use vim's default mappings for tags operations:

*g] go to definition *

Example, you type g] while having your cursor on the word initialize on line 41, and you see this list. <number>+<enter> takes you to each result.

C-] (control+']') will jump to the first result without showing the list

You can run :help tags to learn about all of them.

However, if you are using telescope, you can add this to your .config/nvim/lua/after/plugin/telescope.lua (or equivalent) file:

local builtin = require('telescope.builtin')
-- ...
vim.keymap.set('n', 'gt', builtin.tags,            { desc = '[G]o to C[T]ags (telescope)', noremap = true })

And then if you press gt and then method or class name like initialize here, you would see something like:

LSP

Go to LSP-Zero page, Istalling section and copy the packer block.

Paste it under the last use block, into your .config/nvim/lua/core/plugins.lua file that we created in Part I.

Save :w, source :so % and run :PackerSync.

Then you can create an .config/nvim/after/plugin/lsp.lua to add your custom config for LSP.

Mine is

vim.opt.signcolumn = 'yes' -- Reserve space for diagnostic icons

local lsp = require('lsp-zero')

lsp.preset('recommended')

lsp.ensure_installed({
  'html',
  'cssls',
  'tsserver',
  'solargraph',
  'eslint',
  'sumneko_lua',
})

-- keymaps to add only on buffers with LSP support (overriding grep/tags based defaults)
lsp.on_attach(function(client, bufnr)
  vim.keymap.set("n", "gd", function() vim.lsp.buf.definition() end,     { desc = '[G]o to [d]efinition',buffer = bufnr, remap = false }))
  vim.keymap.set("n", "gD", function() vim.lsp.buf.declaration() end,    { desc = '[G]o to [D]eclaration',buffer = bufnr, remap = false }))
  vim.keymap.set("n", "gr", function() vim.lsp.buf.references() end,     { desc = '[G]o to [R]eferences (with LSP)', buffer = bufnr, remap = false })
  vim.keymap.set("n", "gi", function() vim.lsp.buf.implementation() end, { desc = '[G]o to [I]mplementation (with LSP)', buffer = bufnr, remap = false })
  vim.keymap.set("n", "K",  function() vim.lsp.buf.hover() end,          { desc = '[K] Hover info', buffer = bufnr, remap = false })
  vim.keymap.set("n", "R",  function() vim.lsp.buf.rename() end,         { desc = '[R]ename symbol (with LSP)', buffer = bufnr, remap = false })
end)

  -- Set up lspconfig.
  local capabilities = require('cmp_nvim_lsp').default_capabilities()
  -- Replace <YOUR_LSP_SERVER> with each lsp server you've enabled.
  require('lspconfig')['solargraph'].setup  { capabilities = capabilities }
  require('lspconfig')['html'].setup        { capabilities = capabilities }
  require('lspconfig')['cssls'].setup       { capabilities = capabilities }
  require('lspconfig')['tsserver'].setup    { capabilities = capabilities }
  require('lspconfig')['eslint'].setup      { capabilities = capabilities }
  require('lspconfig')['sumneko_lua'].setup { capabilities = capabilities }

lsp.setup()

Basically it selects which language servers are installed by default, sets custom keybinding only when LSP is acive (via the on_attach hook) and then sets up the servers.

LSP will auto-install your selected servers with mason, and propose you additional servers when you open a file of a new type.

You can look at what servers are installed with :Mason.

LSP diagnostics

I have finally chose to use trouble to see and jump to LSP diagnostic output in a non obstrusive way (I tried floating windows and inline messages but they were not for me)

Just the default installation as suggested by the Readme page works for me.

Ruby/Rails/Tests language support

I mainly develop in ruby so here are some plugins i have find very useful to add:

vim-ruby language support
vim-rails framework support with enhanced file navigation gf and custom :Emodel, :Eview etc commands, :Rails to run rails/rake commands without leavinf your editor.
vim-test run your test with a simple mapping. Works with rSpec and Minitest (and dozens other languages)

-- make test commands execute using dispatch.vim
vim.g['test#strategy'] = "neovim"

vim.keymap.set("n", "<leader>tn", vim.cmd.TestNearest, { desc = '[T]est [N]earest' })
vim.keymap.set("n", "<leader>tf", vim.cmd.TestFile, { desc = '[T]est [F]ile' })
vim.keymap.set("n", "<leader>ts", vim.cmd.TestSuite, { desc = '[T]est [S]uite' })
vim.keymap.set("n", "<leader>tl", vim.cmd.TestLast, { desc = '[T]est [L]ast' })
vim.keymap.set("n", "<leader>tv", vim.cmd.TestVisit, { desc = '[T]est [V]isit' })

splitjoin to alternate between abbreviated and expansive syntaxes for hashes, arrays, method calls...
vim-commentary comment code comfortably with motions and visual selections alike.
vim-surround act on surrounding characters (think quotes, braces, parentheses...)
vim-textobj-ruby use r as a ruby motion (like w for word) meaning "ruby block"

Afterword

That's about it for my current configuration, I hope it was useful or at least interesting for you.

Please let me know if there is anything else you are struggling with. I might have com upon it after writing this piece.

Neovim config from scratch (Part I)

Oinak — Fri, 30 Dec 2022 12:53:21 +0000

I recently started moving from vim to neovim and trying to port my old config with unsatysfying results, but then I came across these videos:

If video is your preferred way of learning, go and enjoy them, this post is sourced 90% from there.

If you prefer learning from text source where copy/paste and pause aren't an issue, please proceed.

Nuke from orbit

Make sure there is no residue of any old config or attempt

rm -rf ~/.config/nvim 
rm -rf ~/.local/share/nvim 
rm -rf ~/.local/state/nvim

Create the config folder

mkdir ~/.config/nvim
cd ~/.config/nvim
nvim .

That should leave you on nvim default config folder with nvim open on its default netrw (vims file explorer) view.

" ============================================================================
" Netrw Directory Listing                                        (netrw v171)
"   /home/fer/.config/nvim
"   Sorted by      name
"   Sort sequence: [\/]$,\<core\%(\.\d\+\)\=\>,\.h$,\.c$,\.cpp$,\~\=\*$,*,\.o$,\.obj$,\.info$,\.swp$,\.bak$,\~$
"   Quick Help: <F1>:help  -:go up dir  D:delete  R:rename  s:sort-by  x:special
" ==============================================================================
../
./

From here you can press % which means create file, you should see a Enter filename: prompt appear on the lower left corner. There you can type init.lua. This name is important as it is the file nvim will look for to read config from.

This leaves you inside that file. I you do i (for insert m ode), print("hello"), and then <esc>ZZ to save and quit, and then you execute nvim . again from bash, you will see the same screen as before but with "hello" written in the bottom left corner.

This is useless in general but useful as a checkpoint that you got all the paths and names right. I suggest deleting the print statement now before it becomes a bother.

Here Primeagen goes on to create lua folder (d from the netrw view) within the nvim one, and theprimeagen there, and then another init.lua.

He will later require all his custom config files from lua/theprimeagen/init.lua and require('theprimeagen') from the main init.lua. I don't see any advantage from this indirection so I would di this instead.

Create lua folder ~/.config/nvim
Create a core folder there (instead of your name, so it's easier to share around)
Create mappings.lua in ~/.config/nvim/lua/core
write

vim.g.mapleader = " " -- easy to reach leader key
vim.keymap.set("n", "-", vim.cmd.Ex) -- need nvim 0.8+

Open init.lua and write require("core.mappings")
Exit and open init.lua

If everything when right, now you can type - (instead of <esc>:Ex) and see netrw's menu.

ThePrimeagen suggests <leader>pv as the mapping to see the folder, but - comes from me being used to https://github.com/tpope/vim-vinegar some time ago. Choose your's to your liking.

After the previous steps, my folder looks like this:

$ tree
.
├── init.lua
└── lua
    └── core
        └── mappings.lua

2 directories, 2 files

$ cat init.lua 
require ("core.mappings")

$ cat lua/core/mappings.lua 
vim.g.mapleader = " " -- easy to reach leader key
vim.keymap.set("n", "-", vim.cmd.Ex) -- need nvim 0.8+

Plugin manager

we are going to use:
https://github.com/wbthomason/packer.nvim

Here I will diverge again from ThePrimeagen and sugges auto_bootstraping packer.
So go to this section
https://github.com/wbthomason/packer.nvim#bootstrapping

Copy the code block there and paste it into lua/core/plugins.lua. Then add require("core.plugins") to your init.lua file and either exit and re-open, or source it <esc>:so % (short for source ).

Fuzzy finder

We are going to take advantage of the previous step and use it to install our fuzzy finder telescope.

Wer will go to https://neovimcraft.com/plugin/nvim-telescope/telescope.nvim/index.html and scroll down to where if says "Using packer.nvim" under the Getting Started section, and copy a block of code similar to this one:

use {
  'nvim-telescope/telescope.nvim', tag = '0.1.0',
-- or                            , branch = '0.1.x',
  requires = { {'nvim-lua/plenary.nvim'} }
}

The we will go to lua/core/plugins.lua file, look for the part that looks like:

  -- My plugins here
  -- use 'foo1/bar1.nvim'
  -- use 'foo2/bar2.nvim'

and replace it with the telescope block.
You can now save, source the file and run :PackerSync and you got yourself telescope installed.

You can use :Telescope find_files<cr> to check that the plugin is installed and works ok.

Telescope commands are a bit wordy, so next you will create a new folder path: ~/.config/nvim/after/plugin (also auto loaded by nvim).

Then you will scroll to Usage on the telescope page, look to the Using Lua part and copy it:

local builtin = require('telescope.builtin')
vim.keymap.set('n', '<leader>ff', builtin.find_files, {})
vim.keymap.set('n', '<leader>fg', builtin.live_grep, {})
vim.keymap.set('n', '<leader>fb', builtin.buffers, {})
vim.keymap.set('n', '<leader>fh', builtin.help_tags, {})

My recommendation is to come up with your own set of mappings for this instead of trying to remember these.

If you add desc params to the mappings and then use Telescope keymaps then you will be able to find commands per your own description of what they do. I suggest you have a sneak peek at my telescope config to see an example and come up with your own mnemonics.

Colorscheme

Another good use of the plugin system is installing your favourite colorscheme, this is very personal, Theprimeagen uses rose-pine, I choose jellybeans. A good point to realize you can use VimL

Add this to you plugins file (under the last use block you added):

use({ 'nanotech/jellybeans.vim' })

Source the file, run :PackerSync

Add this to ~/.config/nvim/after/plugin/colors.lua

--
-- COLORS --
--

vim.opt.termguicolors = true

function SetColor(color)
    color = color or "jellybeans" -- have a default value
    vim.cmd.colorscheme(color)

    vim.api.nvim_set_hl(0, "Normal", { bg = "none" })
    vim.api.nvim_set_hl(0, "NormalFloat", { bg = "none" })
    vim.api.nvim_set_hl(0, "ColorColumn", { bg = "#330000" })
end

SetColor() -- run at startup

Treesitter

Similar to the color part:
Add this to plugins.lua

use('nvim-treesitter/nvim-treesitter', { run = ':TSUpdate'})

got to https://github.com/nvim-treesitter/nvim-treesitter#modules Copy the code block there, paste it into a new file on after/plugin/treesitter.lua and edit to your convenience, specifically, adding languages tgou use to ensure_installed, and commenting or deleting the ignore_install line unless you need it.

If you are into compilers/ASP look into https://github.com/nvim-treesitter/playground and catch ThePrimeagen's vide around this timestamp.

Additional plugins

There are some more plugins that you might find very helpful, at this point you should be able to install and set up a plugin by yourself based on the previous examples, so i will leave the links here for you to practice:

Undotree a visual interface to your undo (allowing for branching).
Fugitive Tim pope's git integration
Commentary Tim pope's comment plugin
Git gutter Git status signs in the gutter (leftmost column)

Set options

If you had an existing .vimrc config before, chances are that you were setting a lot of vim's options to your liking

To that effect, you can create a lua/core/options.lua file and require it from init.lua adding require("core.options").

Here you have mine, but as these are very personal. be sure to chose yours. For the most part you can run :help option_name replacing option_name with whatever comes after vim.opt. on this file and read about what it does.

Mappings

Similarly, you will want to have your own key mappings. I recommend you keep plugin-specific key-mappings under after/plugin/<plugin-name>.lua so that they are easir to find and delete in case you decide to stop using some plugin if it gives you trouble.

Like I did before, here you have my mappings and a recommendation to come up with your own instead of copying anyone else's.

Continues on Part II

How to assess "developer experience" from the job interview

Oinak — Wed, 14 Sep 2022 21:24:11 +0000

When you are taking part on a job interview for a developer position, it is very difficult to form an accurate picture of what working on that place is going to be like.

Here is a selection of questions I think you should be asking. I am not not to tell you what the right answers that because you and me might not even like the same answers, but I think having them will give you a valuable resource.

Onboarding

is onboarding documented?
is installation of dev environment automated?
is there an onboarding-buddy program?
how long does it take on average to first commit?
are there clear/documented 30/60/90 days goals/checkpoints?

CI/CD

are there tests?
what is the line/branch coverage?
how long does the full suite take on a company issued laptop?
is master branch deployed automatically after a merge with a clean test run?
how often do you deploy? what is the % of rollbacks?

Support

is pairing allowed/encouraged/required?
is training/books/events covered? what is the budget?
how is the pull request/code review process?
how and how often is feedback delivered?
who sets employee's expectations and who evaluates performance? are they the same person?

Career

what are the average tenure and monthly attrition numbers?
are there separate technical and managerial career ladders? are levels equivalent?
what portion of a "staff-engineer and above" meeting is comprised of women or URG members?
is there internal mobility? across departments? across skillsets? management from/to IC?

What do you think? What are your questions?

You might want to know what I wrote about this some time ago

cover image by This is engineering

Can you solve FizzBuzz ... in a tweet?

Oinak — Mon, 23 Aug 2021 20:17:48 +0000

FizzBuzz is a (in)famous programming puzzle that it is used mainly just to filter people who can code from people who can't.

The problem statement is as follows:

Write a function that prints the 100 first integers, but for every multiple of 3 prints "Fizz" (instead or the number), for every multiple of 5 prints "Buzz", for a mutipe of both 3 and 5 prints "FizzBuzz",

One naive impementation would be something like:

def fizz_buzz
  (1..100).each do |n|
    print 'Fizz' if n % 3 == 0
    print 'Buzz' if n % 5 == 0
    print n unless n % 3 == 0 || n % 5 == 0
    print "\n" 
  end
end

This works, but has several shortcomings with no easy workarounds. The most immediate one: you are checking modulo twice (or have cumbersome elses)

See this alternative:

def fizz_buzz
  (1..100).each do |n|
    if n % 3 == 0
      puts "Fizz#{n % 5 == 0 ? 'Buzz' : ''}"
    else
      puts "#{n % 5 == 0 ? 'Buzz' : n}"
    end 
  end
end

Where you only repeat the 5 check, but the code is extra complex.

This is a bad test, not a good predictor of future software engineering performace. But that does not mean you cannot use it to learn stuff about ruby. For example, you could choose to solve it with no if's, no methods, no classes and no method calls (other than operator-like)...

Let me take you to the end and then see how do we get there:

-> n {
  t = ->(d, s, x) { n % d == 0 && -> _ { s + x[''] } || x }
  f = -> x { t[3, "Fizz", x] }
  b = -> x { t[5, "Buzz", x] }
  f[b[-> x { x }]][n]
}.yield_self { |fb|
  p (1..100).map { |n| fb[n] } * ','
}

What do we get here:

"Fizz" appears only once
"Buzz" appears only once
3 appears only once
5 appears only once
modulo check is generalized and appears only once
we use lambdas
we use function composition
we use higher order functions (functions receiving functions as parameter)

And now the parts:

Test function

t = ->(d, s, x) {
  n % d == 0 && -> _ { s + x[''] } || x
}

But for the analysis lets have better identifiers:

test = lambda do |divisor, string, executable|
  # if the number is a multiple of divisor...
  number % divisor == 0 &&
    # return a lambda that prefixes string
    (lambda do |_| string + executable[''] end) ||
    # otherwise return the received function
    executable
end

I don't know how much ruby you know so I will try to explain it all:

lambda creates an anonymous method that can be stored in a variable or passed as argument

a = lambda do |x|
  puts "#{x} #{x}"
end
a.call('hi')

prints hi hi

->(x){ puts "#{x} #{x}"} is just an alternate syntax to define lambdas, it is sometimes called the stabby operator

Inside the test lambda we have this structure: a && b || c && is ruby and operator (for expressions, there is also and for action, with different precedence)
and || is the or.

This is used in substitution of if and else
a && b short-cirtuits in ruby so it only evaluates b if a is true (if a is false, the and already is).
On the other hand: b || c only evaluates c if b is falsey (if it's true, the expression already is)

So the translation of the test function is:

test = lambda do |divisor, string, executable|
  if number % divisor == 0
    (lambda { |_| string + executable[''] })
  else
    executable
  end
end

This whole return a function business sounds complicated but is key to be able to use test for both Fizz and Buzz

Fizz function

Test function is pretty generic, but can be translated as:

if n is a mutiple of d, perfix s to what you receive, otherwise leave it be.

Being so generic, allows us to build two functions, f (for fizz) and b (buzz) by feeding different arguments to test, so

f = -> x { t[3, "Fizz", x] }

which can be translated to the verbose version:

fizz = lambda do |executable|
  test.call(3, "Fizz", executable)
end

What fizzdoes is call test (t) with two literal parameters, 3 and "Fizz" and a dynamic one, executable (x).

With this example you can imagine that buzz (b) is constructed in very much the same way replacing 3 with 5 and "Fizz" with "Buzz".

Function composition

One of the things we did not like on the original version was the repeated checks. The only way to avoid them in this case is to nest them.

We are building a fizz function that receives a buzz function as an argument so that it can run that code sometimes.

There is a whole branch os programming/mathematics that deals with this kind of thing. It is called Lambda Caculus and that is where the name of ruby's lambda function comes from.

Multiple function composition

Now we have the last mysterious part:

f[
  b[
    -> x { x }
  ]
][n]

f: returns a function that
if n is divisible by 3
returns a function that returns:
"Fizz" + received code run on "" (empty string)
else
returns a function that runs the received code
The code that f receives is b[->x{x}]

b: returns a function that
if n is divisible by 5
returns a function that returns:
"Buzz" + received code run on "" (empty string)
else
returns a function that runs the received code

But now the most important:
b receives this code -> x { x }
This is a function that returns its argument. Think of:

def executable(x)
  return x
end

This is the part of the code that will return the integer ONLY when it is not a multiple of neither 3 nor 5 because, and this is the key, both f and b run this function on their else sides, and run something like executable("") (or x[''] in the abbreviated version) instead when the modulo is 0.

I am almost sure that this might not be absolutely clear, so please, copy this code, paste it into your irb, play with it... and come with your questions.

I would love to improve this article with each question received in the comments, and encourage you to play with even the smallest piece of code you lay your hands on, to push the boundaries of your knowledge, or at east have some fun.

You are welcome!

Oinak — Tue, 06 Oct 2020 18:49:44 +0000

I recently saw this tweet:

This is not the first time someone is delivering the Real Developer ™ ID cards, so to say, by deciding what are the traits that tell apart the real deal from all the imposters, noobs, hobbyists, junior, wannabes…

If you listen to them, a real developer…

never uses the mosue
does not need to search on google
does everything on the terminal
always uses dark mode
programs on their free time
contributes to opensource
speaks at events
uses Linux
only has technical hobbies

Did you ever heard any of these stupid statements? Then I am sorry. I apologize on behalf of the poor soul that felt so lost and insecure that they needed to link their aspirational status with any of these incidental characteristics of their particular journey.

Software is a vast field, with thousands of practices and applications. Some people consider it a form of engineering, some others consider it a creative or even artistic pursuit. And there is not even agreement on that.

I have been writing software for more than twenty years now, I am sure I can still fail 90% of these purity tests. If you do too, don’t worry, we can be fake developers together :-)

There are, however some beliefs I have about this whole programming thing that I would like to share with you.

There is no supreme tool

You are not going to eventually discover the bes Language, Framework, editor or whatever else, that beats everything else forever and is the last thing to learn.

Tools are good for some problems and bad for others, some ar good at building custom business logic very fast, but bad at scaling horizontally. A social network and a trading bot are very different beasts.

Sometimes a smaller hammer is best. Humans have built cars that make over 1200km/h, yet no one would think of taking one to go pick up the groceries.

Sometimes a tool you don’t know may be better at solving your current problem than the ones you know… but it will still be easier to solve the problem with the known but suboptimal tool than taking the time to master the best tool, or trying to use it without the proper training.

“Start where you are. Use what you have. Do what you can.”
– Arthur Ashe

There is not one way

I have come across a lot of great developers during mi years working in the field. Some had started very young, others did not ever got interested until later in some other career. Some went to college for CS degrees, others did not attend university at all. Some felt a strong passion for technology, some only used technology as a mean to fulfill their real goals.

How you come into technology does not define how good you can be. Programming, as well as many of the related skills, such as system administration, database design, debugging… they are just skills. as such, they can be learnt by anyone with a brain, time to practice and source materials to refer to. Mentoring helps, having used computers since childhood, a mathematical background or deep linguistic abstraction… are all advantages. All can empower you but their absence can be outweigh with time and effort.
There is help

You may find some unfriendly people along the way, but that is not all that there is. The advent of the internet has lowered the barrier to gather with a million strangers who are walking, or did walk, similiar paths to yours, and many are kind enough to share what they can to make the path smother for whoever comes after.

I learnt how to program in the nineties, with books, little to none in the area of forums and living online communities existed, and those who did I did not know about. I wish this upon no one. Things are better now, Google and StackOverflow, Youtube even Twitter, offer you access to an army of friendly hands. Use it. Suffering will not make you harder or stronger, just temporarily sadder.

Step by step Tetris on ES6 and Canvas

Oinak — Sat, 05 Sep 2020 21:47:49 +0000

Some time ago I wrote a post called a very classy snake, inspired by a YouTube video and to try to touch on ES6, canvas and game programming basics.

Shortly afterwards, as it usually does, youtube started suggesting similar videos, and I found myself looking at this tetris on C++ video. C++ is not my thing lately, but I wanted an excuse to play some more with ES6 and canvas, so I though, why not combine the teachings from both videos to create a canvas tetris?

Boilerplate
Playing Field
A single piece
Movement and collision
Touchdown and new piece
Clearing lines and scoring

1. Boilerplate

In the begining, I just copied the html from the snake game, changing just the canvas dimensions to the proportions of the tetris pit (taken from the research the pal from the video did, and by research I mean he counted the squares on a GameBoy, so I did not have to :-)

<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width">
    <title>repl.it</title>
    <link href="style.css" rel="stylesheet" type="text/css" />
  </head>
  <body>
    <canvas id='field' width='240' height='360'>Loading...</div>
    <script src='script.js'></script> 
    <script>
      window.onload = () => { let game = new Game({canvasId: 'field'}); };  
    </script>
  </body>
</html>

Once we have this, we will copy over the skeleton of a game. What do I mean from skeleton. Most classic games have a very similar scaffolding, this is:

Capture user input
Calculate the new game state
Redraw the game GUI based on the new state

This is usually called The game loop because it was, you guessed it, implemented into an infite loop, broken only by win and loss conditions.

As we are in javascript, we are making a slightly more asynchronous version of this, reading user inputs out of events, and executing the state recalculation and the screen redrawing with a setInterval.

// jshint esnext:true

class Game {
  constructor({ canvasId }){
    // this.field = new Field({...});
    this.init();
  }

  init(){
    addEventListener('keydown', (e) => { this.userInput(e) } ); // User input
    setInterval( () => { this.game() }, 1000 / 8);              // Game loop 
  }

  userInput(e){
    // nothing here yet
  }

  game(){
     // nothing here yet
  }
}

Once you have this, you only have to fill in the gaps, and it is as easy as drawing an owl:

2. Playing field

Now let's go for something you will be able to see at last. To that end, there are two bits we will rescue from the snake game:

First, the canvas initialisation code:

    let canvas = document.getElementById(canvasId);
    this.context = canvas.getContext('2d');

Then the code to draw a single square on our imaginary grid:

  // Draw a single tile (using canvas primitives)
  drawTile(x, y, color){
    this.context.fillStyle = color;
    this.context.fillRect(
      x * this.size,  // x tiles to the rigth
      y * this.size,  // y tiles down
      this.size - 1,  // almost as wide as a tile
      this.size - 1); // almost as tall
  }

We are using the fillRect primitive, it can only draw rectangles, but our Tetris game will have a fat pixels aesthetic, so that will be enough for us.

We will create a new class, in charge of holding the game state and drawing the background screen.

class Field{
  constructor({width, height, size, canvasId}){
    this.width = width;   // number of tiles sideways 
    this.height = height; // number of tiles downward
    this.size = size;     // size of a tile in pixels

    this.init(canvasId);  // initialize the field
  }

  init(canvasId){
    // first, set up the canvas context:
    let canvas = document.getElementById(canvasId);
    this.context = canvas.getContext('2d');

    // then set up the grid
    this.initTileGrid();
  }

  // Create the original grid of tiles composed of void and walls
  initTileGrid(){
    this.tiles = []; // a list of columns
    for(let x = 0; x < this.width; x += 1) {
      this.tiles[x] = []; // a single column
      for(let y = 0; y < this.height; y +=1 ) {
        this.tiles[x][y] = this.isWall(x, y) ? 'w' : ' ';
      }
    }
  }

  // Are these x,y coordinates part of a wall?
  // use for drawing and for wall-collision detection  
  isWall(x, y){
    return (x === 0 ||          // left wall
      x === (this.width - 1) || // right wall
      y === (this.height-1));   // floor
  }

  // For every tile in the grid, drwa a square of the apropriate color
  draw(){
    for(let x = 0; x < this.width; x += 1) {
      for(let y = 0; y < this.height; y +=1 ) {
        this.drawTile(x, y, this.colorFor(this.tiles[x][y]));
      }
    }    
  }

  // Draw a single tile (using canvas primitives)
  drawTile(x, y, color){
    this.context.fillStyle = color;
    this.context.fillRect(
      x * this.size,  // x tiles to the right
      y * this.size,  // y tiles down
      this.size - 1,  // almost as wide as a tile
      this.size - 1); // almost as tall
  }

  // Relate grid cell content constants with tile colors
  colorFor(content){
    let color = { w: 'grey' }[content];
    return color || 'black';
  }
}

This is ready to roll, but the Game class is not yet referring to it, so we need to do this small changes:

class Game {
  constructor({ canvasId }){
    this.field = new Field({
      width: 12,         // number of tiles to the right
      height: 18,        // number of tiles downwards
      size: 20,          // side of the tile in pixels
      canvasId: canvasId // id of the cavnas tag
    });
    this.init();
  }

  // ... the rest remains unchanged
}

Once you have, you should be able to see something like this:

Things to observe:

We are using cartesian (that is 2D) coordinates, but we are starting the count at the top-left corner of the canvas, because that is what canvas functions do, and it saves us from some conversion math.

A single piece

A tetris piece or, as I learnt in the video, a tetronimo can be represented as a 4x4 binary matrix of full and empty spaces.

// If you squint you see the 'L' piece:
[[' ','L',' ',' '],
 [' ','L',' ',' '],
 [' ','L','L',' '],
 [' ',' ',' ',' ']]

But if we concatenate those 4 lists it can be simplified as a list:

[' ','L',' ',' ',' ','L',' ',' ',' ','L','L',' ',' ',' ',' ',' ']

where you use (x,y) => { list[4*y + x] } to see each position as a cell.
And javascript being weakly typed allows you to do this with a string as well:

' L   L   LL     '

The video uses A,B,C... letters to refer to (and draw) the pieces, I prefer to use the letters that remind me most of the tetromino's shape, thus the 'L' here.

Pieces have three main motions, sideways, downward and rotation. Sideways and downward motions can be easily figured adding units to the coordinates, so we will deal first with the more complex one, rotation.

Rotation:

Let's draw the numbered positions from our strings in the position they will have in the 4x4 grid, and then, figure out (or copy from the video ;-) the math to have a matrix rotation:

var grid = [
  0,  1,  2,  3,
  4,  5,  6,  7,
  8,  9,  10, 11,
  12, 13, 14, 15
];

var newGrid = [];
for (let i0 = 0; i0 < 16; i0++){
    // convert to x/y
    let x0 = i0 % 4;
    let y0 = Math.floor(i0 / 4);

    // find new x/y
    let x1 = 4 - y0 - 1;
    let y1 = x0;

    //convert back to index
    var i1 = y1 * 4 + x1;
    newGrid[i1] = grid[i0];
}

console.log(newGrid);
// [12, 8,  4, 0,
//  13, 9,  5, 1,
//  14, 10, 6, 2,
//  15, 11, 7, 3]

If you do this with a piece represented as a string you get:

var grid = '  I   I   I   I '; 
// Visual help: this is the above as a 4x4 grid:
// [" ", " ", "I", " ",
//  " ", " ", "I", " ",
//  " ", " ", "I", " ",
//  " ", " ", "I", " "]

var newGrid = [];
for (let i0 = 0; i0 < 16; i0++){
    // convert to x/y
    let x0 = i0 % 4;
    let y0 = Math.floor(i0 / 4);

    // find new x/y
    let x1 = 4 - y0 - 1;
    let y1 = x0;

    //convert back to index
    var i1 = y1 * 4 + x1;
    newGrid[i1] = grid[i0];
}

console.log(newGrid);
// [" ", " ", " ", " ",
//  " ", " ", " ", " ",
//  "I", "I", "I", "I",
//  " ", " ", " ", " "]

console.log(newGrid.join(''));
// "        IIII    "

Let's build a new Piece class with this logic in it:

class Piece{
  constructor({variant, x, y}){
    this.x = x;
    this.y = y;
    this.contents = this.variants()[variant];
  }
  variants(){
    return { // 16 chars = 4x4 char grid
      i: '  i   i   i   i ', // 4x1 column
      t: '  t  tt   t     ', // short 'T' shape
      l: ' l   l   ll     ', // L (short arm right)
      j: '  j   j  jj     ', // J (sort arm left)
      o: '     oo  oo     ', // square, centered or rotation would displace
      s: '  ss ss         ', // step climbing right
      z: ' zz   zz        '  // step climbing left
    };
  }

  rotate(){
    let newGrid = [];
    for (let i0 = 0; i0 < 16; i0++){
      // convert to x/y
      let x0 = i0 % 4;
      let y0 = Math.floor(i0 / 4);

      // find new x/y 
      let x1 = 4 - y0 - 1;
      let y1 = x0;

      //convert back to index
      var i1 = y1 * 4 + x1;
      newGrid[i1] = this.contents[i0];
    }
    this.contents = newGrid.join('');
  }

  reverse(){ // 1/4 left = 3/4 right
    rotate();
    rotate();
    rotate();
  }

  toString(){
    return [this.contents.slice(0 , 4),
     this.contents.slice(4 , 8),
     this.contents.slice(8 , 12),
     this.contents.slice(12, 16)].join("\n"); 
  }
}

let p = new Piece({variant: 'l', x: 5, y: 0})
console.log(`----\n${p.toString()}\n----`);
p.rotate();
console.log(`----\n${p.toString()}\n----`);
p.rotate();
console.log(`----\n${p.toString()}\n----`);
p.rotate();
console.log(`----\n${p.toString()}\n----`);

If you run this code, you get this output:


"----
 L  
 L  
 LL 

----"
"----

 LLL
 L  

----"
"----

 LL 
  L 
  L 
----"
"----

  L 
LLL 

----"

Can you see the 'L' piece rotating clockwise?

The .toString() method is not needed for the game logic but it is useful for debugging, feel free to leave it there if it helps you.

Next step: draw it onto the canvas. The drawing logic is on the Field so we are going to add a method to draw the current piece.

Changes to Field

Initialize the current Piece:

  init(canvasId){
    // (...) the rest of the method unchanged (...)
    this.currentPiece = new Piece({x: 4,y: 0});
  }

The draw method:

  // For every tile in the grid, draw a square of the apropriate color
  draw(){
    // (...) the rest of the method unchanged (...)
    this.drawPiece(this.currentPiece);
  }

And a new drawPiece function:

  drawPiece(piece){
    let tile = ' ';
    for(let x = 0; x < 4; x += 1){
      for(let y = 0; y < 4; y += 1){
        tile = piece.at(x,y) 
        if (tile !== ' '){
          this.drawTile(piece.x + x,
                        piece.y + y,
                        this.colorFor(tile));
        } // non empty
      } // column tiles
    } // piece columns
  }

As you see, we are still using the colorFor method to choose the color of the tiles, so now we need a coor for every piece, so we go to the Tetris page on wikipedia to choose them:

  // Relate grid cell content constants with tile colors
  colorFor(content){
    let color = {
      w: 'grey',
      i: 'lightblue',
      t: 'lightgreen',
      l: 'orange',
      j: 'blue',
      o: 'yellow',
      s: 'lime',
      z: 'red'
    }[content];
    return color || 'black';
  }

The final version of the Piece class has the ability to randomly choose a variant upon initialisation:


class Piece{
  constructor({x, y}){
    this.x = x;
    this.y = y;
    this.contents = this.chooseVariant();
  }

  // changed from variants to this, with the random logic
  chooseVariant(){
    // https://stackoverflow.com/questions/2532218/pick-random-property-from-a-javascript-object
    let variants = {
      i: '  i   i   i   i ', // 16 chars = 4x4 char grid
      t: '  t  tt   t     ',
      l: ' l   l   ll     ',
      j: '  j   j  jj     ',
      o: '     oo  oo     ', // centered or rotation would displace
      s: '  ss ss         ',
      z: ' zz   zz        '
    };
    let keys = Object.keys(variants);
    return variants[keys[ keys.length * Math.random() << 0]]; // << 0 is shorcut for Math.round
  }

  at(x, y){
    return this.contents[(y * 4) + (x % 4)];
  }

  rotate(){
    let newGrid = [];
    for (let i0 = 0; i0 < 16; i0++){
      // convert to x/y
      let x0 = i0 % 4;
      let y0 = Math.floor(i0 / 4);

      // find new x/y 
      let x1 = 4 - y0 - 1;
      let y1 = x0;

      // convert back to index
      var i1 = y1 * 4 + x1;
      newGrid[i1] = this.contents[i0];
    }
    this.contents = newGrid.join('');
  }

  reverse(){ // 1/4 left = 3/4 right
    rotate();
    rotate();
    rotate();
  }
}

Once you have this code in place, you should be able to see something like this:

Bear in mind it probably chose a different tetromino for you, and will choose a random one every time you run the code.

Movement and collision

Now that we have a Playing field, and a piece on it, it is time to get interactive, so we are going to listen to player input and react to it.

Also we have walls, and they would not be worth such name it stuff just went through, right?.

So this is the strategy for this section:

Read user input
Create a displaced or rotated version of the piece
Check if the virtual piece fits (does not collide)
- If it fits, it becomes the current piece
- If it does not, movement gets blocked (for now, we will see what else later)

Read user input

I am going to be totally lazy here and copy over from the snake game:

  // on Game class
  userInput(event){
    const arrows = { left: 37, up: 38, right: 39, down: 40};
    const actions = {
      [arrows.left]:  'moveLeft',
      [arrows.up]:    'rotate',
      [arrows.right]: 'moveRight',
      [arrows.down]:  'moveDown'
    }
    if (actions[event.keyCode] !== undefined){ // ignore unmapped keys
      this.field.handle(actions[event.keyCode]);
    }
  }

Create the virtual piece (we make it accept `contents` for this)

There is no deep cloning out of the box on ES6 so we just initialise a new Piece with the same properties and then apply the motion indicated by the user's input:

Piece class:

class Piece{
  constructor(options = {}) {
    const defaults = { x: 0 , y: 0, contents: null };
    Object.assign(this, defaults, options);

    // accept contents for piece copying, select random for new pieces:
    this.contents = this.contents || this.chooseVariant();
  }

  chooseVariant(){
    // unmodified
  }

  //// User actions:
  moveRight(){
    this.x += 1;
  }

  moveLeft(){
    this.x -= 1;
  }

  moveDown(){
    this.y += 1;
  }

  rotate(){ 
    // unmodified
  }

  // return a copy of the object:
  dup(){
    return new Piece({x: this.x, y: this.y, contents: this.contents});
  }

And now the handle method in the Field class:

  handle(action){
    // make a copy of the existing piece:
    let newPiece = this.currentPiece.dup();

    // effect the user selected change on the new piece:
    newPiece[action]();

    // temporal, to see the effect:
    this.currentPiece = newPiece;
    this.draw();
  }

After this, you should be able to move your piece sideways and downwards, but alas, it does not stop on walls.

Detect collision

This handle function is not very smart, so we are going to add a check to see if a piece can fit in the place we are trying to send it to, before effectively doing the move:

  handle(action){
    // make a copy of the existing piece:
    let newPiece = this.currentPiece.dup();

    newPiece[action](); // move or rotate according to userInput

    if (this.canFit(newPiece)){
      this.currentPiece = newPiece;
    } else {
      console.log('colision!');
      // touchDown?
    }
    this.draw();
  }

This is very similar to what we have before, but now, how do we know if the piece can indeed fit. We don't need 4x4 tiles free because tetronimos do not occuppy their full grid, to achieve the puzzle effect we only want to check if every tile on the piece grid is either empty on the piece or on the field, in either case there is no collision. Collosions happen when a non-empty cell from the piece is atop a non-empty cell of the field.

Let's translate all this jargon to code:

  canFit(piece){ // for every overlap tile between the piece and the field:
    for(let x = 0; x < 4; x++){
      for(let y = 0; y < 4; y++){
        if (piece.at(x, y) !== ' ' &&                      // piece is not empty
            this.tiles[piece.x + x][piece.y + y] != ' ' ){ // field is not empty
          return false; //there is collision
        }
      }
    }
    return true; // if there are no collisions, it can fit
  }

After this, you can still move your pieces, but no longer overlap them with the walls or floor. The console.log('collision!') will be executed every time you go over a wall or the floor, but the piece won't move.

Before going on, I noticed that the rotations had a strange symmetry. This is, the pieces rotating around different axis from what they do on the original game. First I fixed this on the square, going:

From this:    To this:
'oo  '        '    '
'oo  '        ' oo '
'    '        ' oo '
'    '        '    '

But that trick did not work for every piece. So I dug deeper, and I noticed I felt uncomfortable about the literal 4's sprinkled all over the code, so I thought: what if different pieces are different sizes?

So I made these changes to Piece:

Added a length and a side getters to Piece, to use instead of 16 and 4 throughout the code.
Edited every method using the Piece's length or side to use the new attributes.
Once everything was working again, I changed the pieces strings to the smallest possible grids with the better symmetry I could get.

Here are the changed methods in piece:

class Piece{
  constructor(options = {}) {
    const defaults = { x: 0 , y: 0, contents: null };
    Object.assign(this, defaults, options);
    this.contents = this.contents || this.chooseVariant();
  }

  chooseVariant(){
    // https://stackoverflow.com/questions/2532218/pick-random-property-from-a-javascript-object
    let variants = {
      i: '  i '+
         '  i '+
         '  i '+
         '  i ', // 16 chars = 4x4 char grid
      t: ' t '+ // 3x3
         'ttt'+
         '   ',
      l: 'l  '+
         'l  '+
         'll ',
      j: '  j'+
         '  j'+
         ' jj',
      o: 'oo'+ // 2x2
         'oo',
      s: ' ss'+
         'ss '+
         '   ',
      z: 'zz '+
         ' zz'+
         '   '
    };
    let keys = Object.keys(variants);
    this.variant = this.variant  || (keys[ keys.length * Math.random() << 0]);
    return variants[this.variant];
  }

  get length(){
    return this.contents.length;
  }

  get side(){
    return Math.sqrt(this.length);
  }

  at(x, y){
    return this.contents[(y * this.side + (x % this.side )) ];
  }

  // ... moveRight/Left/Down unmodified

  rotate(){
    let newGrid = [];
    for (let i0 = 0; i0 < this.length; i0++){
      // convert to x/y
      let x0 = i0 % this.side;
      let y0 = Math.floor(i0 / this.side);

      // find new x/y 
      let x1 = this.side - y0 - 1;
      let y1 = x0;

      // convert back to index
      var i1 = y1 * this.side + x1;
      newGrid[i1] = this.contents[i0];
    }
    this.contents = newGrid.join('');
  }

And here you have the changed methods outside of Piece, which are the two Field methods that received a Piece as argument, canFit and drawPiece:

// Field class
  canFit(piece){ // for every overlap tile between the piece and the field:
    for(let x = 0; x < piece.side; x++){
      for(let y = 0; y < piece.side; y++){
        if (piece.at(x, y) !== ' ' &&                      // piece is not empty
            this.tiles[piece.x + x][piece.y + y] != ' ' ){ // field is not empty
          return false; //there is collision
        }
      }
    }
    return true; // if there are no collisions, it can fit
  }

  //...

  drawPiece(piece){
    let tile = ' ';
    for(let x = 0; x < piece.side; x += 1){
      for(let y = 0; y < piece.side; y += 1){
        tile = piece.at(x,y); 
        if (tile !== ' '){
          this.drawTile(piece.x + x,
                        piece.y + y,
                        this.colorFor(tile));
        } // non empty
      } // column tiles
    } // piece columns
  }

Once you have this, you have the original rotation on all pieces but the 4x1 column.

Time to start piling pieces and clearing lines now.

If you read all this, first of all, thank you very much! I hope you are having so much fun reading and, I hope, following along, as I had figuring out how to explain it.

Second, you might be curious how does this continue, but if you want to know that, you will have to jump to Rocknrollesque's post #TODO: review the link.

I created my dev.to account inspired by her, and I wanted to return the favour, so I challenged her to finish this post, so that she had to create a dev.to blog of her own.

So go now to find about:

Touchdown and new piece

and

Clearing lines and scoring

Hiring Rails devs in Madrid (update: positions covered)

Oinak — Fri, 28 Aug 2020 12:05:32 +0000

About Us

At Returnly we help merchants turn product returns into new revenue streams. We are a Silicon Valley startup and we have recently opened an office in downtown Madrid (near Alonso Martinez subway station). We’re are a financial technology services company that builds award-winning products which make shoppers’ propensity to repurchase go through the roof. We’re backed by smart money VCs in Fintech and one of the most well-funded startups in the San Francisco Bay Area. Our mission is to de-risk online commerce and we’re building a team of amazingly talented people to build the next generation of retail fintech products.

What do we offer?

Vacation

We have 23 standard PTO (Paid Time Off) days, plus up to 2 days from the benefits (to be used on special dates).

Remoteness

We have an office, and we prefer seeing each other often, but we already had a healthy WFH culture before Covid19 came so when it happened, we just switched to every-day WFH. However, we would prefer if you live in or near Madrid so when we open the office again it won’t be a problem for you to enjoy it.

Schedule

We have a very flexible approach to working hours. You can stop to go to the gym, get your little ones to or from school, meditate or do whatever you need or want. There is a need for a certain amount of overlap with Pacific Coast working hours needed for meetings and collaboration that does not fit into asynchronous communications, however we try to prioritise those, and your main collaborators are based on Spain.A lot of people at Returnly have families, we understand the sometimes unpredictable nature of life and we support every one taking care of their loved ones and themselves, and we trust everyone to take advantage of this flexibility in a responsible way.

Growth

We do performance and compensation reviews, and we will try to help you become your better self, be it via mentoring, training, feedback or the possibility to dab on fields where you are not yet an expert.

Equipment

You will be provided with an apple laptop and whatever you need to do your job comfortably and productively. As we are now unable to enjoy our awesome offices, special provisions to help you set up at home will be addressed.

Benefits

Additionally, Returnly offers some benefits to all Spain employees, like private medical insurance, extra vacation days, weekly team lunch, etc.
Employees can choose some extra benefits since day one and they will earn more every year they remain at Returnly, benefits include things like gym membership, phone/Internet, transport, meal….

What will you do?

• Build and enhance a highly configurable system that is used by thousands of companies and millions of shoppers
• Work with a highly collaborative team, where you will solve challenging problems
• Review each other’s code and pair-program to spread knowledge and produce higher-quality code
• Drive quality by writing unit, integration, and performance tests in a continuous delivery environment
• Make decisions based on data and be pragmatic
• Work closely with Product and Leadership
• Help define and prioritize features
• Produce documentation that helps the team understand complex parts of the system
• Go beyond engineering by working closely with our support representatives where we help triage and debug technical support requests

In one month

You will have Returnly’s stack and tools installed on your machine and a general understanding of how everything works together.
You will have read most of Returnly’s documentation that is relevant to you.
You will be able to assume your own tasks even if completing them requires asking questions or collaborating with peers.
You will have deployed some code to production.

In three months

You will be able to work mostly unsupervised, to ask relevant questions about new tasks before starting them so that your workload flows in a mostly predictable manner.
You will have extended or enhanced some of existing documentation with new or more detailed info.

In six months

You will have added some sizable features to Returnly’s web apps and will be the go-to person about their implementation, or feasibility of future developments.
You will have authored some new parts of the documentation.

How will you do it?

We use Rails 5, RSpec, Sidekiq, Webpacker and React/Redux for the most interactive parts of the UI. These apps interact with both internal and external services to complete some of their tasks.
We do continuous integration, and we have personal QA environments that launch on demand for any branch in a production-like environment with most integrations available just as production.
We use a variation of Kanban with weekly check-ups to re-evaluate prioritisation and user stories grooming.
Every other week we check OKR alignment with the wider team and sometimes do small focused 3min demos to see what everyone is doing.

Your Team

You will work with a product owner, webapps developers, services developers, and a QA engineer in a cross-functional autonomous team that we call a Pod.
You will also have the chance to refine best-practices and propose technical work, refactorings and reliability enhancements in periodical work sessions with your stack-peers from every Pod.

Where

We have an incredible office at Calle Larra, Madrid, with shared kitchen, lunch space, bike parking, a sunny terrace, lockers, top notch video conference equipment, and surrounded by nice restaurants and numerous public transportation options. But alas, due to Covid19, we are now unable to use it safely so we are working from home for the time being. (We will review this later)

What are we looking for?

What do we need (T shape)

While we need someone with a deep knowledge on the main required skills for this position, we prefer people with a broad experience in neighbouring or related areas. Backend, testing, containers, graphic design, project management… The more you bring to the table the better.
We are a young company, where specialisation is still in process, and we believe that, the better you understand the people you are collaborating with, the easier it is going to be to have a smooth communication with them.

Strongly preferred

• 4+ years industry experience in Ruby/Rails
• Strong analytical and problem-solving skills; attention to detail
• Knowledge of web service technologies and REST best-practices
• Understanding of scalability challenges and performance of server-side code
• Ability to design and develop horizontally-scalable, resilient and efficient systems
• Deep understanding and experience with relational databases and SQL
• Courage and discipline to dig-in and refactor other people’s code and explore new technology and solutions
• Proven track record of shipping software in a delivery-focused environment
• Desire to improve broken processes and make your own job easier over time
• Ability to think creatively and critically and thrive in a fast-paced, dynamic, and often ambiguous work environment
• Strong interpersonal and communication skills, with the ability to communicate and influence effectively across various departments
• Written and spoken communication proficiency in English is needed to collaborate with a global team
• Data-driven mentality

Nice to have

• Deep understanding of distributed systems in a cloud environment, and event-driven architecture is a plus
• Understanding of and experience with NoSQL data stores is a plus
• B.S. degree equivalent (or higher) in Computer Science, Engineering or related field is a plus
• Prior history of driving impact in a high-growth eCommerce/technology startup is a plus
• Exposure to Amazon Web Services is a plus

Hiring process

• Meet & Greet
• Take-home exercise and/or Online test
• Technical Interview
• On-site interview (held via videocall due to Covid19)

Our values

Diversity: We are diverse, independent thinkers and still one team with one mission.
Openness and empathy: We learn and grow by listening to our customers and each other
Integrity: We always do what’s right for our customers, Returnly and ourselves - in that order.
Team: EQ is as important as IQ. We make time to help each other out.
Commitment: We are curious and fearless. We own risk, outcomes and everything in between.

We really love hearing from you, but before applying please check the following...
Read the values section above carefully and ask yourself if this is a good match for you personally. We want you to be an ambassador of these values!

> > > Apply here < < <

Please feel free to leave questions in the comments section.