See our books for programmers (Rails, React.js, blogging, remote)

Composable RSpec matchers

All the ways to generate routing paths in Rails

Rails components — neither engines nor gems

Physical separation in Rails apps

How mutation testing causes deeper thinking about your code + constructor for an included module in Ruby

What I learnt from Jason Fried about running a remote/async software company

Making tmux work for you

How to setup development work with RailsEventStore and mutant

DATABASE_URL examples for Rails DB connection strings

Why we follow the Rails repo structure in Rails Event Store

Interview with Sergii Makagon about hanami-events, domain-driven design, remote work, blogging and more

inject vs each_with_object

Testing deprecations warnings with RSpec

The === (case equality) operator in Ruby

What I learned from reading spreadsheet_architect code

That one time I used recursion to solve a problem

My fruitless, previous attempts at not losing history of changes in Rails apps

My first 10 minutes with Eventide

When DDD clicked for me

How to quickly add graphs and charts to Rails app

nil?, empty?, blank? in Ruby on Rails - what's the difference actually?

Monitoring Sidekiq queues with middlewares

Non-coding activities in a software project

How to keep yourself motivated for blogging?

Handle sidekiq processing when one job saturates your workers and the rest queue up

How to safely store API keys in Rails apps

The easiest posts to write for a programming blog

Using influxdb with ruby

Tracking dead code in Rails apps with metrics

What I learnt today from reading gems' code

Dogfooding Process Manager

Test critical paths in your app with ease thanks to Dependency Injection

Acceptance testing using actors/personas

Testing cookies in Rails

Handling SVG images with Refile and Imgix

Passive aggresive events - code smell

Self-hosting Event Store on Digital Ocean

The vision behind Rails, DDD and the RailsEventStore ecosystem

What's inside the Rails DDD workshop application?

Conditionality is filtering. Don't filter control flow, filter data.

All Rails service objects as one Ruby class

Reliable notifications between two apps or microservices

Why classes eventually reach 50 columns and hundreds of methods

Prototypes in Ruby and the strange story of dup

Ruby code I no longer write

A potential problem with PStore and Rails

How to unit test classes which depend on Rails models?

yield default object

Fluent Interfaces in Ruby ecosystem

Why Smalltalk instead of Ruby

Run your tests on production!

On upcoming immutable string literals in Ruby

Event sourced domain objects in less than 150 LOC

Why would you even want to listen about DDD?

Safer Rails database migrations with Soundcloud's Large Hadron Migrator

Patterns for dealing with uncertainty

Recovering unbootable NixOS instance using Hetzner rescue mode

Testable Javascript with pure functions

Async/Remote: make work a better place

Educate about DDD/CQRS/Event Sourcing at the Facebook group

Dealing with randomly failing tests from a team perspective

One request can be multiple commands

Ruby exceptions are 4400 times faster than ActiveRecord::Base#create

Rails and adapter objects: different implementations in production and tests

The typical Ruby bugs with changing the last line in a method

Overcommunication is required for async/remote work

Running bash command from Ruby (with your bash_profile)

The esthetics of a Ruby service object

Developers as DDD bounded contexts representatives

Hourly Billing is Nuts

The freelancer in you that wants to be FREE

To blog or to write code?

How we save money by using DDD and Process Managers in our Rails app

Minimal decoupled subsystems in your rails app

Command bus in a Rails application

Phases of refactoring complex Rails apps

Two dimensions of a Rails developer's growth

respond_to |format| is useful even without multiple formats

The quotes from the Post Rails Book Bundle books

Implementing & Testing SOAP API clients in Ruby

Always present association

Domain Events Schema Definitions

Cover all test cases with #permutation

API of the future

Rails Refactoring Podcast #6 - Frontend Friendly Rails

Mutation testing of Rails views

Is Rails a good fit for writing rich frontend applications?

Use ES2015 with Rails today - what & how

See how we create books. Live

Porting a Rails frontend from CoffeeScript to ES6 and JSX - examples

One more step to DDD in a legacy rails app

The story behind our Rails TDD & DDD video class

70% off the Rails / TDD / DDD / mutant video class until 11pm 19.05.2016 CEST

Domain Events over Active Record Callbacks

The anatomy of Domain Event

Packaging ruby programs in NixOS

How I hunted the most odd ruby bug

Custom type-casting with ActiveRecord, Virtus and dry-types

2 years after the first event - The Saga Pattern

Creating new content types in Rails 4.2

Using anonymous modules and prepend to work with generated code

The smart way to check health of a Rails app

How and why should you use JSON API in your Rails API?

Private classes in Ruby

Testing aggregates with commands and events

How to teach React.js properly? A quick preview of wroc_love.rb workshop agenda

Rails: MVP vs prototype

How RSpec helped me with resolving random spec failures

From legacy to DDD: What are those events anyway?

Where and why I'm still using Rails

Drop this before validation and just use a setter method

One event to rule them all

Loading all data when starting Flux SPA

From legacy to DDD: Start with publishing events

Stable Circle CI builds with PhantomJS for larger Rails-backed frontend apps

A single Rails API endpoint to accept all changes to the app state

In-Memory Fake Adapters

Monitoring services and adapters in your Rails app with Honeybadger, NewRelic and #prepend

A Simple feature toggle for a Rails app

Arkency React.js resources

Slack-driven blogposts

Creating custom Heroku buildpack for Webpack and Ruby on Rails integration

Rolling back complex apps

Run it in a background job, after a commit, from a service object

Advantages of working on a legacy application

Do you have a framework for dealing with emergencies?

Testing Event Sourced application - the read side

Sanitizing html input: youtube iframes, css inline styles and customization

CQRS example in the Rails app

Testing race conditions in your Rails app

How can Rails developers benefit from reading the Arkency books?

Three most telling files in legacy Rails apps

Null Object pattern in practice

Testing an Event Sourced application

Am I ignored in my async team?

Arkency goes React

Subscribing for events in rails_event_store

Thanks to repositories...

How good are your Ruby tests? Testing your tests with mutant

You can use CoffeeScript classes with React - pros and cons

Start using ES6 with Rails today

Using domain events as success/failure messages

Introducing Read Models in your legacy application

Building a React.js event log in a Rails admin panel

One year of React.js in Arkency

How to store emoji in a Rails app with a MySQL database

Building an Event Sourced application using rails_event_store

Extract a service object using SimpleDelegator

Mutation testing and continuous integration

On my radar: RethinkDB + React.js + Rails

Why I want to introduce mutation testing to the rails_event_store gem

Beautiful confirm window with React

Bring CommonJS to your asset pipeline

The Event Store for Rails developers

Rails meets React.js is out: What you can find inside?

How to store large files on MongoDB?

Gulp - a modern approach to asset pipeline for Rails developers

Implementing Game Dashboard With React.js

How to use Greg's Event Store from ruby

Stream pagination in Greg's Event Store

Why saving data using MongoHQ takes so long?

Tracking down unused templates

Your solid tool for event sourcing - EventStore examples

Explaining Greg's Event Store

Why use Event Sourcing

Fast introduction to Event Sourcing for Ruby programmers

Blogging: your English is good enough, but

Configurable dependencies in Angular.js

You get feature toggle for free in event-driven systems

You don't need to wait for your backend: Decisions and Consequences

Extract a service object in any framework

Use your gettext translations in your React components

Blogging - start from the middle

How to get anything done? - 4 tips

How to split routes.rb into smaller parts?

The reasons why programmers don't blog

My favorite ActiveSupport features

The Beginners Guide to jQuery.Deferred and Promises for Ruby programmers

Adding videos embedded in a page to a sitemap

upgrade capybara-webkit to 1.4 and save your time

Ruby Exceptions Equality

It's easy to miss a higher level concept in an app

The categories of validations

Does everyone in your team write good code?

Beyond the Rails Way

rails-refactoring.com podcast #1

Don't forget about eager_load when extending autoload paths

Frontend performance tips for web developers

You can move React.js root component around

How to start using Arrays in Rails with PostgreSQL

How to persist hashes in Rails applications with PostgreSQL

Unit tests vs class tests

Instantiating Service Objects

React.js and Dynamic Children - Why the Keys are Important

Behind the scenes

How to start using UUID in ActiveRecord with PostgreSQL

React.js and Google Charts

Adapters 101

Concurrency patterns in RubyMotion

How we structure our front-end Rails apps with React.js

Burnout - do you need to change your job?

Truncating UTF8 Input For Apple Push Notifications (APNS) in Ruby

SSH authentication in 4 flavors

RubyMotion app with Facebook SDK

Using ruby Range with custom classes

Ruby background processes with upstart user jobs

Hidden features of Ruby you may not know about

6 front-end techniques for Rails developers. Part I: From big ball of mud to separated concerns

Why we use React.js in our Rails projects

4 ways to early return from a rails controller

Code style matters

Developer matters

RubyMine basic navigation features (that make you move around code fast)

Microservices - 72 resources

Service objects as a way of testing Rails apps (without factory_girl)

From Rails to RubyMotion: basic toolkit

Create, run and manage your Ruby background processes with upstart

My journey to Arkency world

Real-time Web Apps

Take most out of async textual standups

Effective async communication

Async & remote - toolbox

Would you love to work remotely (and asynchronously)?

Mastering Rails Validations - Objectify

Mastering Rails Validations: Contexts

The biggest obstacle to start with Continuous Deployment - database migrations

Zero uptime deploy

Don't call controller from background job, please. Do it differently!

2 ways to deal with big and complicated features

Sitemaps with a bit of Metal

Rails Refactoring: the aha! moments

Pretty, short urls for every route in your Rails app

37 signals was not lying, you win by being remote

Stop including Enumerable, return Enumerator instead

Rails and SOA: Do I really need to have this big app?

CoffeeScript acceptance tests

3 ways to do eager loading (preloading) in Rails 3 & 4 & 5

Chronos vs Kairos: Find out how you think about time when working on a project

Developers oriented project management: What our new book is all about?

Developers oriented project management: Take the first task

Developers oriented project management: Leave tasks unassigned

Services - what are they and why we need them?

Developers oriented project management: Story of size 1

Throw away Sprockets, use UNIX!

Developers oriented project management

Testing client-side views in Rails apps

Single Table Inheritance - Problems and solutions

CoffeeScript tests for Rails apps

Ruby and AOP: Decouple your code even more

Are we abusing at_exit?

Implementing worker threads in Rails

How to track ActiveRecord model statistics

The A Team

Is it cute or ugly?

Naming in OOP

Introducing hexagonal.js

Web is no longer request-reply

Black-box Ruby tests

Rails API - my simple approach

You don't inject for tests

Blogging for developers

Google Analytics for developers

Why we don't use ORM

Not Rails

One app, one user, one ruby

Sending async data from Rails into the world (II)

Sending async data from Rails into the world

JavaScript objects philosophy

Filepicker and Aviary - Image uploading on steroids