Akshay's Blog (Page 2)

Practical Stimulus: Capture User Input

Stimulus is a JavaScript library that works really well with the HTML-over-the-wire approach of building web applications. In this series of articles, we'll learn how to accomplish common front-end tasks using Stimulus. This post shows how to capture user input and display it on the screen.

Unix: A History and a Memoir

I recently read Brian Kernighan’s Unix: A History and a Memoir. If his name sounds familiar, Brian is also the author of The C Programming Language, along with Dennis Ritchie, the creator of C. It’s a fascinating book that gives an insider’s view of Bell Labs, a

How to Create a Form with Multiple Submit Buttons to Different URL Endpoints

I came upon an interesting problem at work yesterday. A 'search filters' form needed to have two endpoints to which it could submit: one to apply the filters, and another to save the filters as default. The first implementation was to create a Stimulus controller that intercepted the "save filters"

Generating Secure Tokens on Your ActiveRecord Models

You must have used the `has_secure_password` macro in Rails. Did you know Rails also provides a `has_secure_token` macro to generate unique tokens on your models? In this article, we'll learn how it works and we'll also see how Rails implements it behind the scenes.

A Beginner's Guide to Rails Parameters

Parameters in Rails let you access data sent by the browser, either in the URL or via form submission. In this article, we'll cover the basics of parameters, including what they are, how they work, and why they're important. We'll also learn how you can pass parameters when redirecting a request.

How to Render Markdown Views in Rails

This article shows how to create and render markdown views in Rails. This is useful if you have a few static marketing pages in your web application that you'd like to save and edit as markdown along with the rest of your code files.

Concerns in Rails: Everything You Need to Know

Concerns are an important concept in Rails that can be confusing to understand for those new to Rails as well as seasoned practitioners. This post explains what concerns are, how they work, and how & when you should use them to simplify your code, with practical, real-world examples.

How to Create Custom Flash Types in Rails

While reading the Rails codebase last week, I came across a useful method that lets you create custom flash types. In this post, we'll learn how to use it and also how it's implemented behind the scenes. In the process, we'll also learn a few metaprogramming tricks in Ruby.

Inline Routes in Rails

If you want to quickly try out some Rails feature or code in the browser without spinning up a whole new controller and a view, simply map the incoming request to a lambda Rack endpoint, i.e. a lambda that returns the status, headers, and response body.

Simplifying My Blogging Workflow with Ruby

This is the 100th post on this blog 🎉 I wanted to share how a simple Ruby script simplified my blogging workflow and dramatically increased the number of posts I write on my various blogs.

Did You Know that You Can Catch and Throw Stuff in Ruby?

Unlike traditional programming languages, Ruby's throw and catch are not used to raise and catch exceptions. Instead, they let you escape from deeply nested control flows. This post shows how `throw-catch` works in Ruby with practical, real-world examples, including their usage by the Warden gem.

Polymorphic Associations in Rails: Why, What, and How

Polymorphic associations in Rails allow a single model to belong to multiple models. This article covers them in-depth. We'll start with understanding the concept of polymorphism, learn what a polymorphic association is, why we need them, how they work, and how to use them in your Rails application.

Various Ways to Run Shell Commands in Ruby

Ruby provides multiple ways to conveniently execute external processes from the code. In this article, we'll learn all the ways you can run shell commands in Ruby and also consider various circumstances under which you'd choose one over the other.

Ruby's Switch Statement is More Flexible Than You Thought

Ruby's switch statement is very versatile and flexible, especially due to the dynamic nature of Ruby. In this post, we'll see how you can use it in various ways. We'll also learn why it works the way it works. Hint: it uses the `===` operator (method) under the hood.

Can You Spot the Error?

I recently encountered this error and in the process of debugging, learned some useful stuff about `self` and how assignment works in Ruby. See if you can figure it out yourself. Can you spot the error in this simple Ruby snippet?

A List of Books to Learn Programming with Ruby and Rails

This post provides a curated list of books to learn to code in Ruby and build web applications with Rails. It also gives a step-by-step path you can follow to learn enough before moving to the next step. If you ever wanted to learn to program but didn't know where to start, this post is for you.

How to Access Hash Values with Methods Using OrderedOptions

Have you ever wanted to create a hash where you could access the values like methods on an object? The OrderedOptions class in Rails lets you do just that. This post shows you how. We'll also explore how Rails implements this feature using Ruby's metaprogramming features.

Middleware in Rails: What It Is, How It Works, and Examples

In this post, We'll learn about Rails middleware: what it is, why we need it, how it works, and why it's so important. If you have a fuzzy understanding of middleware, this post will make it concrete. I'll also show you how to create and test custom middleware for your Rails app.

The Definitive Guide to Rack for Rails Developers

The word Rack actually refers to two things: a protocol and a gem. This article explains pretty much everything you need to know about Rack as a Rails developer. We will start by understanding the problem Rack solves and move to more advanced concepts like middleware and the Rack DSL.

How to Access Rails Models in a Rake Task

This article shows how you can access your application models inside rake tasks by adding the `environment` task as a dependency. We'll also go one level deeper and learn exactly how it works behind the scenes.

Readonly Attributes in Rails

In this article, we'll learn how to mark certain attributes as readonly on your active record models, to prevent them from any future updates after the record is created and saved to the database. We'll also learn how Rails implements this feature behind the scenes.

Sessions in Rails: Everything You Need to Know

In this post, we’ll learn about Rails sessions, including what is a session, why we need them, and why they're so important. I’ll also take you behind the scenes and show you how Rails implements sessions and where the `session` method actually comes from. Hint: it’s not in the Rails codebase.

Understanding the Attribute Assignment API in Rails

In this post, we will explore the `AttributeAssignment` module in Rails, which allows you to set an object's attributes by passing in a hash, a feature commonly used by Active Record models. We'll also learn a little metaprogramming along the way.

Progressive Application Development with Hotwire

This is the day when you fall in love with Hotwire. We're going to build a simple counter. But we're not going to build it once and be done with it. Instead, we'll build and progressively enhance it with all three frameworks in Hotwire: Turbo Drive, Turbo Frames, and Turbo Streams.

Understanding the Rails Router: Why, What, and How

The router is the entry point of your Rails application. It acts as the gatekeeper for all incoming HTTP requests, inspecting and sending them to a controller action; even filtering and rejecting them if necessary. In this article, we’ll do a deep dive into the Rails Router to understand it better.

Configuring Rails Environments

Despite its strong opinions and powerful conventions, Rails is a highly flexible and configurable framework. If you don’t like something, there’s almost certainly a way to change it. This article provides a brief overview of configuring Rails applications and environments.

Turbo Streams: How They Work and Differ From Turbo Frames

No, you don’t need WebSockets to use Turbo Streams. You can simply use them to deliver multiple page updates with a single HTML response. This article teaches the basics of Turbo Streams to build a SPA without writing a single line of JavaScript. No Rails needed, either!

You Don't Need Rails to Start Using Hotwire

Although Hotwire is closely tied to Ruby on Rails, you might be surprised to know that you don't really need Rails to learn, play, and experiment with Hotwire. In this article, I will show you how a simple static website can use Turbo Drive and Frames to make it more dynamic and responsive.

A Brief Introduction to Hotwire

Hotwire, which stands for HTML Over the Wire, provides a different way to build modern web applications without using too much JavaScript. This article provides a quick introduction to Hotwire and its component frameworks, such as Turbo Drive, Frames, and Streams.

How Rails Authenticity Tokens Protect Against CSRF Vulnerability

Rails protects your web application from CSRF attack by including an authenticity token in the HTML forms. This token is also stored in the user's session. Upon receiving a request, Rails compares these two tokens to decide if the request is verified.

Cross-Site Request Forgery (CSRF) Attack: What It Is, How It Works, and How to Prevent It

CSRF vulnerability tricks authenticated users of an application to perform a dangerous activity on that application, simply by clicking a link. This post explains how CSRF works with a practical example, and shows how to protect against it, both as a user and a developer building web applications.

Docked Rails: Setup a Ruby on Rails Application on Docker 🐳

Setting up a new Ruby on Rails application with all the dependencies doesn't have to be complicated. Docked is a new command line tool that simplifies the process of creating a new Rails app using Docker.

Nested Modules in Ruby

Ruby provides two different ways to define nested modules. This post explains the difference between them and how to decide which one to use. It also explains the `Module.nesting` method which returns the list of modules nested when called.

The Difference Between load, autoload, require, and require_relative in Ruby 📖

Loading external files can get tricky in Ruby, but it doesn't have to be. This post explains the usage of Ruby's load, require, and require_relative methods, and when to use each.

Open GitHub Repositories in VS Code In-Browser

GitHub allows you to open any repository in an in-browser VS Code by just pressing the `.` key on your keyboard.

Method Shorthand in Ruby

While reading the docs, I learned that Ruby (3.0 and up) provides a shorthand syntax for one-line methods, similar to computed properties in C#. Personally, I don't plan to use them in my code, except in tests. I prefer the standard syntax. The shorthand also looks confusing with the

📖 Understanding the Instrumentation API in Rails

The instrumentation API in ActiveSupport serves a dual purpose. You can use it to implement the publish-subscribe pattern, as well as benchmark how long it took to execute some action.

Array Inquiry in Rails

The ArrayInquirer class provided by the Active Support framework in Rails provides a readable way to check the contents of an array. This post explores how you can implement this using metaprogramming in Ruby.

How to Check If Value Exists in an Array in Ruby (and Rails)

In this post, we'll learn two different ways to check if a value is included in an Array.

Tracking TODO and FIXME Comments with Rails Notes Command

This post shows how you can use the notes command in Rails to search through your codebase for comments starting with a specific keyword. By default, it searches the codebase for FIXME, OPTIMIZE, and TODO comments, but you can also configure it to use custom keywords.

What Happens When You Call render? Let's Understand the Rails Rendering Process

This article explains the Rails rendering process in the context of returning JSON data from the controller. Hopefully, it will make it clear what really happens when you call the render method from the controller.

Regular Expressions in Ruby

Regular expressions can be both terribly awkward and extremely useful. In this introductory post, we will learn the basics of regular expressions in Ruby programming language and how to use them for routine programming tasks.

The Rails Config File

You must have used a ~/.bashrc or ~/.zshrc file to configure your environment. Did you know Ruby on Rails has a ~/.railsrc file that configures your Rails applications?

Let's Learn Ruby on Rails + Hotwire by Building a To-Do List

In this article, we'll learn Ruby on Rails and Hotwire by building a to-do list from scratch. It shows how to build single-page web applications using traditional web architecture (server-rendered HTML), without the complexity of modern JavaScript frameworks like React.

Hiding Sensitive Information from Logs Using Parameter Filtering in Rails

This article explains why you shouldn't log confidential or user-identifiable information and how to filter it using parameter filtering in Rails. We'll also learn how Rails implements this feature internally.

A Brief Introduction to Rails Initializers

After loading the framework and any gems in your application, Rails runs the initializers under the `config/initializers` directory. This article explains how initializers work and how they're implemented.

Building a Web Application Without Rails: Rendering Views Dynamically using ERB

This is the fourth article in the series on building awesome web applications with Ruby and Rails. We continue our journey to build a web application without using Rails to better understand how Rails works. Today, we'll learn how to render views dynamically with the ERB gem used by Rails.

How self Keyword Works in Ruby

Ruby's self keyword can be pretty confusing to understand, especially if you're new to Ruby. Not understanding it often leads to subtle programming bugs that can be difficult to debug. This post explains how it works under common, everyday situations.

Can You Build a Web Application in Ruby Without Rails? Yes, You Can!

This is the third article in the series on building awesome web applications with Rails. It shows how to build a simple web app in Ruby from scratch, without using Rails.

Difference Between the Length, Size, and Count Methods in Rails

You can use the length, size, and count methods to find the number of elements in a collection. This post explores the difference between these methods and explains how you should choose which method to use according to your situation.

Setting Up Development Environment for Rails

This is the second article in the series on building awesome web applications with Ruby on Rails. It shows how to set up a kick-ass development environment for building Rails apps.

Define New Routes Using the Member and Collection Blocks

This post shows how to define new routes using the member and collection blocks provided by the Rails router.

How &:method Shortcut Works in Ruby

This post shows you how Ruby's `&:method` shortcut works behind the scenes. It's a clever trick that was added first in ActiveSupport and became an official feature in Ruby 1.8.7.

Building Web Applications with Ruby on Rails

This is the first article in the series on building awesome web applications with Ruby on Rails. It explores why you should build for the web and use a web framework, especially Rails.

Understanding Blocks and the Difference in Proc and Lambda

If you've been programming in Ruby for a while, you've definitely come across blocks or one of their flavors via a Proc or lambda. Though they seem confusing, they're not that difficult to understand. This blog post explains the concept of blocks and the differences between Proc and lambda. Blocks

Compare Strings Using Inquiry

How to Access a Hash with both String and Symbol Keys in Rails

Sometimes, you receive a hash key as a method parameter or via user input, and you want to make your hash understand that key as-is, without worrying if it's a string or a symbol. A good example is the params hash in Rails. You can access it using either a

How to Compress a String in Ruby (and Rails)

You can compress large strings using the Zlib module provided by Ruby's standard library.

Configure Classes Using the Configurable Concern in Rails

Sometimes, you need a config-like property on a class, such as a logger. Rails provides the Configurable concern that lets you accomplish this. It provides a config method that allows you to access (read and write) configuration options using the method-like syntax. class Invoice include ActiveSupport::Configurable config_accessor :type

How to Access Variables Outside Scopes in Ruby

In C# and Java, variables from the outer scope are visible to the inner scope. In Ruby, scopes are sharply separated, and nested visibility is not allowed. As soon as the control enters a new scope, i.e. a class, module, or a method, the previous bindings are replaced by

Ruby is a Meritocracy

I recently read Russ Olsen's book Design Patterns in Ruby. In it, the author makes a wonderful distinction between statically vs. dynamically typed languages, which is different from all other comparisons I've seen.

How to Benchmark Rails Views

This post explores the Benchmarkable module provided by Active Support to measure the execution time for rendering Rails views.

Autoloading Modules in Rails

Autoloading modules allows you to speed up the initialization of your library by lazily loading the code you need. This post explores how autoload method works.

How to Benchmark Ruby Code

The Benchmark module in the Ruby standard library helps you measure and report the time used to execute your code. This post explores three useful methods in this module, which allow you to measure and compare the execution times of code as well as warm up the code to stabilize

How to Debug Rails Source Code

Reading the Rails source code is a great way to understand how a feature works in Rails. However, stepping through the specific Rails method you're interested in is even better. You can inspect the local variables, follow the conditional path, and learn exactly what's happening behind the scenes. This post

Understanding Authenticity Tokens in Rails

This post explores CSRF vulnerability and how Rails mitigates it using authenticity tokens. We will will learn why they're needed, how they're generated, how Rails uses them to verify the requests, and how to disable them for specific requests.

Metaprogramming in Ruby

Metaprogramming in Ruby enables you to produce elegant, clean, and beautiful programs as well as unreadable, complex code that’s not maintainable. This book teaches you the powerful metaprogramming concepts in Ruby, and how to use them judiciously.

How to Get an Object's Class Name in Rails

This post explores a few different ways in which you can get an object's class name in both Ruby and Rails.

The Difference Between nil?, empty?, and blank? in Ruby

In ruby, you can use the nil? method on an instance to check if it’s nil. However, ruby also provides empty? and there’s a blank? method in Rails. For a new ruby programmer, it can get quite confusing. This post tries to explain which method to use when.

A Deep Dive Into Database Migrations in Rails

Like source code, database schema changes and evolves over time. Migrations are a feature of Active Record that allows you to manage the database schema changes gracefully, without writing any SQL. This post contains my notes on Active Record migrations from the official Rails guides. Key Points * Think of each

Attributes API in Rails

Sometimes, you want to set default values on your ActiveRecord objects and convert them to a different type. Rails provides a handy attribute method that lets us do that, and much more. In this post, we will try to understand how to use the attributes API to achieve this. First,

How to Get the Current Absolute URL in Rails

Every Rails controller includes two accessor methods pointing to the request and the response objects associated with the current HTTP request cycle. The request method returns an instance of the ActionDispatch::Request class, which wraps the HTTP request and provides a nice API to inspect the request. Use original_url

How to Rename a Database Column in Rails

Solution 1: Undo Last Migration If it is a simple typo in the last migration, use the db:rollback command to undo the last change. Then open the previous migration file, fix your typo, and rerun the migration. Make sure that no new data is inserted in the table or

How to Check if a Variable is Defined in Ruby

Ruby provides a handy defined?(expression) keyword that tests if the expression refers to anything recognizable. The expression can be an object, a variable that’s initialized, method name, etc. If Ruby can’t resolve the expression, it returns nil. Otherwise, it returns a string describing the expression. Here are

Metal Controller in Rails

The ActionController::Base is the great-grandfather of all Rails controllers, but doesn't get much attention. In this post, we will examine this Metal class and how it works.

Active Job: How Does It Work?

In this article, I explain the journey of a background job, from its creation to execution. We will learn how it’s configured and enqueued, and how an adapter invokes it. We will also see the different ways to configure a job.

Up and Running with Minitest

I love minitest. Minitest is simple. There’re a few ways to write tests, and they are so intuitive. I learned it last year, when I got into Ruby, and since then I haven’t really felt the need to dive into the docs that frequently. It just works. That

Ruby Shortcut to Call a Method with Each Array Item as Parameter

As a Ruby programmer, you probably know the &: shortcut to call a method on each item in an array. For example, this snippet will call the to_s method on :foo and :bar. [:foo, :bar].each(&:to_s) The above code is similar to: [:foo, :bar].each do |item| item.

CDPATH: Easily Navigate Directories in the Terminal

You know about the PATH environment variable. Did you know about CDPATH? If you’ve been typing long cd commands like me, this post is for you. I came across this gem this morning, while reading Daniel Barrett’s Efficient Linux at the Command Line. It instructs the cd command

How to Manage Environment Variables in Rails

Now you might think it’s so easy to access them using the ENV hash. Why do we need a different way? Well, a very common problem when working on multiple Rails applications on the same machine during development is that these applications might have environment variables with the same

Why You Need Strong Parameters in Rails

In 2012, GitHub was compromised by Mass Assignment. A GitHub user used mass assignment that gave him administrator privileges to none other than the Ruby on Rails project. In this post, I will explain this vulnerability and how you can use the Rails strong parameters API to address it.

Useful Linux Commands

Learning the Linux command line, like becoming an accomplished pianist, is not something that we pick up in an afternoon. It takes years of practice. The Linux Command Line, William E. Shotts Since I switched to Ruby on Rails from .NET, I find myself increasingly using the terminal every day.

Running a Single Test with Spaces in Minitest

In Rails, if you want to run a specific test without the others in the file, you can pass the method’s name to the --name flag. def test_controller_name # assert ... end > ruby -I test test/controller/renderer_test.rb --name test_controller_name But, Rails also provides a

How to Convert a Ruby Object to Hash

Let’s say you have a Product object with properties @name = "Table" & @price = 10. What’s the best way in Rails to convert this object to the Hash { name: "Table", price: 10 }? Here're a few different ways to achieve this. The as_json Method (Rails) The as_json method converts

Useful Ruby Gems

Although Rails provides great defaults out-of-the-box, you can easily extend it with Ruby gems. Here are some gems that I find myself using every time I start a new Rails project. Semantic Logger Semantic Logger is a feature-rich logging framework, and replacement for existing Ruby & Rails loggers. gem "amazing_print"

How to Access Route Helpers from Rails Console

This post shows a simple way to check the output of URL and path helpers directly from the Rails console. We will also see how to access these helpers in your models.

Why Turbo Uses Event Capturing

I was reading the source of the Turbo library and came across following code in link_click_observer.ts, which executes whenever the session starts (when the page loads) and Turbo starts observing the links and forms: start() { if (!this.started) { addEventListener("click", this.clickCaptured, true) this.started = true } } clickCaptured

Why Choose `let` Over instance variables in RSpec

Repetitive setup code in tests makes it difficult to refactor the tests. It also distracts and shifts our focus from the business logic that we’re trying to test with the setup details. This post explains three ways to reduce the setup duplication in your tests. Here’s a simple

Inline Edits using Turbo Frames

This post explains how to use Turbo Frames to make your web application behave like a Single-Page Application without using any JavaScript.

Turbo Drive Essentials

I spent the last night reading up on the Turbo Drive, a part of Hotwire front-end framework that Rails 7 ships with. The core value proposition of Hotwire is that all the logic lives on the server, and the browser deals just with the final HTML. This post tries to

Launching Multiple Processes with a Single Command in Rails

An application doesn’t exist in isolation. Usually, it depends on other processes to work correctly, such as a database, JavaScript / CSS compilers, Redis, etc. So far, whenever I started the Rails app, I launched these supporting processes in multiple terminal windows. This week, I learned a new way to

class_eval vs. instance_eval in Ruby

This post explains the difference between class_eval and instance_eval methods in Ruby. If you keep getting confused between them when reading or writing Ruby code, it should clarify things a little. Consider the Greeting class, which forms the basis of other examples. class_eval class_eval evaluates the

How to Setup Tailwind 3 on Rails

Update: Tailwind documentation has since added the installation steps with Rails. Even though the official Tailwind documentation has installation instructions for various client-side frameworks, it is missing one for Rails. Most of the tutorials work with the older versions of Tailwind. With version 3 released a few days ago, I

Couldn't Find Handler For: puma, thin, falcon, webrick

This morning, I was trying to learn Rack and how Rails uses it. So I created a new gem using the bundle gem command. Then I added a config.ru file with the following code. class App def call(env) ['200', {'Content-Type' => 'text/html'}, ['Hello World']] end end run App.

All the Database Tasks in Rails

Once you start programming in Rails, you inevitably come across db:migrate, which applies the migration to your database. Then you make a mistake and learn about db:rollback to revert the previous migration. After programming for a while, you stumble upon db:reset, to drop and recreate your database,

How to Drop a Table in Rails

So you created a migration to add a table that you thought you were going to need. You also ran that migration so that table is in your database. Now, you don’t need it anymore and want to drop it from the database. How do you remove that table?

How to Debug Ruby Code

For a long time, I delayed learning Ruby as I didn’t know how to debug Ruby code. Coming from a .NET background, I was used to debugging C# in Visual Studio, with its powerful support of stepping in and out, dragging breakpoints, changing variables on the fly, and a

How to Test Rails Source Code

One of the best ways to understand any codebase is to read the tests, and Rails is no exception. In this post, we will learn “how to run the tests” included in the Rails codebase. Specifically, we will learn how to: 1. Run the entire Rails test suite 2. Run

Group Related Code with Functions in Ruby

Functions are one of the most important concepts in programming. You can use functions to group together multiple instructions, multiple lines of code, and give them a name. For example, you can make a function that sends an email. For example, let's call it send_email and we define it

Control Statements in Ruby: Conditions and Loops

Conditions are a part of control flow. Whenever we make a decision, we’re using a conditional. If this, then that. You get the idea. We can decide to do something, or something else, based on a conditional. For example, age = 15 if (age > 15) print 'you can drive' end

Include and Extend

Here’s a neat trick I learned today. Typically, when a class includes a module, the module methods become instance methods on the including class. However, with just a little metaprogramming, a module can provide both instance and class methods to the including class. Here’s how that works. module

Proc vs. Lambda

Though they might look the same, the Proc and Lambdas have few differences. The first key difference is that the return keyword means different things. In a lambda, return just returns from the lambda. In a proc, return behaves differently. Rather than return from the proc, it returns from the

What is Binding in Ruby

A Binding is a whole scope packaged as an object. It allows you to encapsulate and carry the scope around. Later, you can execute a piece of code in the context of that binding, using eval. The Kernel#binding method returns the current binding object. A binding object encapsulates the

Named Key-Value Pairs Form a Hash in Ruby

Modifying Objects in Place

Every time you create or copy something in memory, you add work for GC. Here are some tips from the book Ruby Performance Optimization to write code without using too much memory. Modify strings in-place. Instead of making a changed copy, you change the original string. Look for “bang!” functions,

Class Metaprogramming in Ruby

A Ruby class definition is just regular code that runs. When you use the class keyword to create a class, you aren’t just dictating how objects will behave in the future. You are actually running code. You can put any code in a class definition, and it returns the

A Collection of Items Makes an Array in Ruby

Arrays represent a list of elements. They are very common in programming and are one of the fundamental building blocks of programs. In this article, we'll learn how they work in Ruby. Arrays are ordered lists of values grouped under a common name. So far we have seen variables which

Bloc, Proc, and a Lambda

There are at least three places in Ruby where you can package code to be executed later. In a block, a proc/lambda, and a method. Block A block is a chunk of code you can associate with method invocations, almost as if they were parameters. You can use code

Rails Middleware

Here’s a list of middleware Rails uses in a development environment. You can view the middleware by running the bin/rails middleware command from your application directory. Rack::MiniProfiler Displays speed badge for every HTML page. Designed to work both in production and in development. ActionDispatch::HostAuthorization Guards from

Strings that won't change: Symbols in Ruby

Symbols are simply strings that are guaranteed to be unique. Instead of quotes, symbols are indicated by adding a colon : character behind the word. For example, :gmail is a symbol. If you create another :gmail it will represent the same symbol you created earlier. A symbol looks like a variable,

Characters Make Strings in Ruby

A string is simply a list of characters, for example 'hello world' and 'abcd'. The characters don’t necessarily have to mean anything. You can assign a string to a variable, as follows: author = 'James Clear' book = 'Atomic Habits' In real programs, you may use strings to insert and display

Code that won' Run: Comments in Ruby

Sometimes, you want to add helpful notes and instructions to your code for others, even you. Trust me, when you come back to a piece of code you wrote six months ago, it's often hard to figure out what it does. Comments are a useful feature in all programming language

What's In a Name? Variables

In real life, you assign names to things and people to identify them. Programming is not different. Instead of things and people, we have bits of memory, and we refer to them by something called a variable. Why variable? because it's not fixed. A variable can point to different things

Caching in Rails

These are the notes I took while reading the Rails caching guide. Caching is one of the most effective ways to boost an application’s performance. It stores content generated during the request-response cycle to reuse it when responding to similar requests. Rails supports caching out of the box, and

Your First Ruby Program

In this lesson, we'll install a code editor and write our very first Ruby program.

A Brief Introduction to Rake

Rake is a task runner written in Ruby. It performs repetitive tasks, such as 1. Making database backup 2. Running tests 3. Watch for file changes and compile the changed files In the words of late Jim Weirich, the creator of rake, The essence of rake is to take a

How to Install Ruby

To use Ruby, we first have to install it on our computer. In this section, we’ll install the latest version of Ruby. If you’re on a Mac, it already comes with Ruby. However, it’s most likely an older version of Ruby. There are many ways to install

A Brief Introduction to Ruby

If you want to learn programming, Ruby is one of the best programming languages to start with. This article provides a short and sweet introduction to Ruby.

Latest

Subscribe to Akshay's Blog