Understanding the key differences between rendering methods for Single Page Applications

Understanding how JavaScript works behind the scenes and handles asynchronous functions

Building and scaling a design system with Figma, React and Storybook

An attempt to put together some debugging experiences, techniques and tools for frontend

An amazing alternative solution to websockets

Understanding and examining the pros and cons of the parallax scrolling strategies that can be used

Fetch secrets from AWS secrets manager and inject them securely into your Github actions

A unified approach towards monitoring health of your infra and applications

Ways of integrating Sentry with Strapi

Making requests to Strapi endpoints as an authenticated user

Understanding and exploring the applications built with tagged templates

Deploying to Netlify from a private, self-hosted GitLab instance

Local plugin development in strapi

A guide on how to publish your generated artifacts using Gitlab CI/CD pipeline.

Setup and write test cases in react using Jest and React testing library

Difference in batch updates before and after React18

Redis can be used as an LRU cache with right kind of eviction policy. We can have some fun figuring out how this actually works

Learn to run rails test on Gitlab CI pipeline

Fetch movie rating from several API without hitting rate limits on failure retries

Ways of implementing keys and cases in which index can be used as key and vice-versa

Understand Agents in Elixir with a real world use case of refreshing OAuth2 access token

Learn tips about working on an Elixir App

Achieve high availability for vault server with auto unseal using KMS

Understand some of the scenarios of deploying a Phoenix application using Elixir Releases

Learn to solve a business use case with Elixir Recursion

Build a React app with graphql.

Auto Deploy to Heroku Using Gitlab CI

Learn how to encrypt & store Kubernetes secrets in Git

Build a full-blown GraphQL service which will let you query, change and create records in the database using elixir's web framework: Phoenix

Build a full-blown GraphQL service which will let you query, change and create records in the database

Learn to extract data from a QR code in Elixir

Use web workers to spawn computationally expensive background tasks without interrupting the user interface workflows

Learn to overlap an image over QR code using Mogrify in Elixir

Approaches for clean rails translation files as application grows

Adopting and incorporating a gradual type system for Ruby

Learn to switch an existing Phoenix app from Brunch to Webpack

Learn about KeyError#initialize method which accepts :message, :receiver and :key as options to set message, receiver and key on KeyError object.

Learn about KeyError#receiver which returns receiver associated with the KeyError object & KeyError#key returns the key which caused the exception

Learn about options which Expection#full_message accepts

Make better authorization for your application.

Learn about freezing middleware with rack-freeze

Introducing Interceptor - A browser extension that mocks backend responses and how to use it.

Learn more about ruby by contributing to RubySpec

Learn how to connect to a production Elixir node from the local shell and use the debugger GUI to set breakpoints and debug.

Deploy Elixir/Phoenix apps using Distillery plugin

Supporting API conventions for client like reactjs can be quite tricky. This post talks about approach to make APIs accessible using snakecase or camelCase.

Deploying a Rails app with Webpack asset management on Heroku can be tricky. However, Heroku provides lifecycle hooks on its NodeJs buildpack that will help make this easier.

Erlang is a powerful concurrent programming language that has Processes as a first class citizen. These are isolated by default. Just like in Unix, these processes can communicate using Signals. In this post we will see how to achieve that in Elixir.

Elixir, built on the battle-tested Erlang VM, is a language that has concurrency as its core ideas. I will introduce a monitoring utility shipped with the VM that helps us visualize HTTP requests.

Rails 5 has a new feature added to ActiveRecord that makes working with batch data much more efficient. The `Model.in_batches` function passes a batch of records wrapped inside an ActiveRecord collection.

Autoprefixer is a tool that adds vendor prefixes to CSS based on the usage patterns and current state of support. This results in clean code and smaller CSS files.

Ruby's TracePoint API is very powerful for building custom profilers. As the final post of the DIY CPU profiler series, this post will introduce how to get method runtime statistics and generate relevant graphs.

Ruby's TracePoint API is very powerful for building custom profilers. In this post I will talk about hooking into Ruby code execution life cycle using this API

Ruby's TracePoint API is very powerful for building custom profilers. In this post I will talk about Wall time and CPU time, and how to measure them for Ruby programs.

Ruby's TracePoint API is very powerful and allows us to write custom profiling code without slowing down the execution of programs. In this post, I will introduce CPU profiling and 2 strategies to write one.

Traditionally, Rails 3.x and above come with Sprockets and asset management functions. However, using a JavaScript or CSS library with Sprockets means we'd have to roll them into gems with a specific directory heirarchy. Instead, we can leverage Bower to handle that for us.

JSON schema can help bring order to handling complex JSON interactions in APIs. For instance, you can avoid checking the types of incoming JSON and rely on JSON schema to do the validation. This post talks about similar usecases.

Interacting with complex web forms tends to become hairy pretty quickly. Using Form or Service objects to abstract out the complexity can help wrangle complexity. This post talks about how we use them to make code simpler.

CSS Box Model is one of the fundamental concepts layout inside a browser. In this post you'll learn about the box-sizing property.

There is a proliferation of high resolution screens on mobile devices, and non-optimized images tend to look ugly on them. This post introduces ways to use optimized images for use in HTML on high DPI screens.

In this post, I will talk about how Rails 3.x reloads code in the development environment.

Invoker is a utility we wrote to ease setting up of local development environments and top level .dev domains. Read on to know how to use it.

Ruby 2.0 and above has in-built support for DTrace hooks. This lets us profile Ruby programs. In this post, I'll go into the details of the features of DTrace.

Ruby 2.0 and above has in-built support for DTrace hooks. This lets us profile Ruby programs. In this post, I'll introduce DTrace and how to add DTrace probes to a Ruby program.

This post talks about using the Backbone library with a Rails backend, and goes through some challenges and gotchas encountered during the process.

A nearly step-by-step guide to upgrade to Mountain Lion, and setting up a Ruby development environment

The problem with kitchen sink libraries is feature creep. Sometimes all we need are small libraries that are easily readable.