Let’s talk about why measurement is non-negotiable—and how skipping this step is like prescribing medicine without diagnosing the illness.

The Pitfalls of Optimizing Blindly

1. You’re Probably Wrong About the Bottleneck

Human intuition about performance is notoriously unreliable. What feels slow—say, a loop iterating over an array—might not be the culprit at all. In Rails, common performance pitfalls often lie in layers developers don’t directly interact with: inefficient database queries (N+1 issues), memory bloat, poorly configured caching, or even garbage collection overhead. Without profiling, you’re playing a guessing game.

2. You Risk Solving the Wrong Problem

I once saw a team spend days rewriting a module to reduce its time complexity only to realize its execution was finishing in milliseconds in the first place. The real performance issue was a heavy IO operation down the line. By not measuring, they solved a problem that didn’t matter—and ignored the one that did.

3. You Might Make Things Worse

Premature optimizations can introduce subtle bugs, reduce code readability, or even degrade performance. For example, adding aggressive caching without understanding the data access patterns might lead to stale data or increased memory pressure.

The Rails Tools You Should Be Using

Ruby on Rails provides a robust toolkit for measuring performance. Here’s where to start:

1. Profiling Tools

• rack-mini-profiler: A gem that displays performance diagnostics directly in your browser. It highlights slow database queries, render times, and more.

• ruby-prof: For deep method-level profiling. These tools help identify CPU bottlenecks.

• bullet: Catches N+1 query issues before they become problems.

• memory_profiler: For analyzing where memory is being allocated.

2. Benchmarking

Use Ruby’s Benchmark module or the benchmark-ips gem to measure code execution time. For example:

Benchmark.ips do |x|
  x.report("original") { SomeModel.expensive_method }
  x.report("optimized") { SomeModel.optimized_expensive_method }
  x.compare!
end

3. Database Query Analysis

Check your Rails server logs for slow queries, or use your database’s slow query logs to identify high-cost SQL statements. Tools like explain can reveal missing indexes or inefficient query plans.

A Practical Workflow for Performance Fixes

1. Reproduce the Issue
   Can you reliably trigger the slowdown? If not, you’re not ready to fix it.

2. Establish a Baseline
   Measure the current performance. For example: “This CSV processor takes 10 seconds to process 100k lines”

3. Profile, Don’t Assume
   Run profiling tools to identify the root cause. Is it CPU-bound Ruby code? Database latency? Garbage collection? Network calls?

4. Target the Bottleneck
   Focus your efforts on the slowest part of the system. If a database query takes 80% of the request time, optimizing Ruby code won’t help.

5. Validate the Fix
   Re-measure after your changes. Did the bottleneck improve? Did you inadvertently shift the bottleneck elsewhere?

A Rails-Specific Example: The N+1 Trap

Imagine a view rendering a list of User records, each with an address. A developer notices the page is slow and assumes the issue is rendering speed. They "optimize" by preloading data:

# Before (triggers N+1 queries)
@users = User.all

# After (fixes N+1 but adds unnecessary overhead)
@users = User.includes(:address, :profile, :orders, :preferences).all

But without measuring, they might over-include associations, bloating memory and query time. A better approach:

1. Use rack-mini-profiler or bullet to confirm N+1 queries.

2. Measure the query time with and without includes.

3. Use includes selectively: User.includes(:address) if addresses are the only association needed.

When Not to Optimize

Not every slow line of code needs fixing. Ask:

• Does this impact user experience or business goals?

• Is the code on a hot path (e.g., called thousands of times per minute)?

• Is the current performance "good enough" for the use case?

If a method runs once a day and takes 2 seconds, your time is better spent elsewhere.

The Bottom Line

Performance work is science, not art. Guessing wastes time; measuring saves it. In Rails, where layers like ActiveRecord abstractions and middleware can obscure bottlenecks, profiling is your flashlight in the dark. Before you refactor, cache, or rewrite, ask: What does the data say?

Your future self—and your team—will thank you.

What is less?

less is a terminal pager designed to view and navigate through files or command output efficiently. Introduced in 1984 as a successor to more, it earned its name because it does “more” by requiring “less” effort (and because, unlike more, it allows backward movement in files). While more was limited to forward-only scrolling, less broke boundaries by enabling bidirectional navigation, robust searching, and seamless handling of massive files.

Key features of less

1. Scroll Freely, Forward and Backward
   With less, you’re not stuck moving in one direction. Use the arrow keys (or vim motion keys if you prefer), Page Up/Page Down (or f and b like vim again), or even the spacebar to scroll. Want to jump to the end? Press G. Return to the top? Press g.

2. Search Like a Pro
   Tap / to start a forward search or ? for a backward search. less highlights matches and lets you cycle through them with n (next match) or N (previous match).

3. Handle Massive Files with Ease
   Unlike text editors that load entire files into memory, less opens files incrementally. This makes it perfect for log files that are gigabytes in size—no freezing or lag.

4. Follow Real-Time Updates
   Watching a growing log file? Press F to enter “follow mode,” and less will tail the file in real time, similar to tail -f. Exit follow mode with Ctrl+C.

5. Line Numbers and Wrapping
   Toggle line numbers with -N (e.g., less -N file.txt or type -N after opening the file) or disable line wrapping with -S to avoid messy output.

6. Show colors from your logs

   If you open a file with colored strings, then you can show those colors using the -R option.

7. Integrate with Pipelines
   Pipe output from commands like grep, awk, or journalctl directly into less for easier analysis:

    grep "ERROR" app.log | less
   

Why ditch more for less?

The original more command is still around, but it lacks many of less’s features. For example:

• No backward scrolling: Once you scroll past a page in more, you can’t go back.

• Limited navigation: more lacks search highlights, jump-to-end shortcuts, or follow mode.

• Basic functionality: It’s just… less.

Even the manual page for more admits its shortcomings, often stating, “more has fewer features than less.”

Getting started with less

Most Linux and macOS systems include less by default.

But, in case you don’t have it readily installed it is usually available in your OS’s package manager. In Ubuntu, you can run this to install less

sudo apt install less

To open a file:

less filename.txt

Essential Commands:

• q: Quit.

• /pattern: Search for “pattern.”

• :n and :p: Navigate between multiple files (if opened with less file1 file2).

• -i: Ignore case in searches (use less -i file).

• v: Open the file in your default text editor (e.g., Vim).

Advanced tips

• View Compressed Files
  Use less with tools like zless to view compressed files without manual extraction.

• Customize Display
  Set environment variables in your shell config (e.g., ~/.bashrc) to tweak less’s behavior. For example:

    export LESS="-i -N -S -R"
  

  This ignores case in searches, enables line numbers, chops long lines, and shows colors.

• Avoid Binary Files
  If you accidentally open a binary, less will warn you. Press q to exit, then use tools like strings or xxd instead.

Conclusion

In an era of bloated GUIs, less remains a lightweight, powerful tool for anyone working in the terminal. Its versatility, speed, and intuitive navigation make it indispensable for debugging logs, reading documentation, or exploring data. So next time you reflexively type cat or more, give less a try. After all, why settle for “more” when you can have… less?

Pro Tip: Type man less to view its manual—ironically, you’ll be reading it in less itself. Now that’s meta!

1. Throw Every CSS Property You Know At It

Why use one CSS property when 17 might do the trick? Combine margin: auto;, position: absolute;, transform: translate(-50%, -50%);, display: table-cell;, and vertical-align: middle; into a single class. Bonus points if you add float: left; "just in case." Watch in awe as your div teleports to Narnia, crashes the browser, or—in rare cases—centers itself… but only on your local library’s 2003 Dell PC running IE8.

2. Use Margins Like a Gambling Addict

“margin: 0 auto; should work, right?” you whisper, as you refresh the page for the 45th time. But wait! You forgot to set a width on the div. No problem! Just apply margin: 12% 34% 56% 78%; and pray to the CSS overlords that math isn’t real. When the div inevitably ends up halfway off-screen, blame the user’s font size.

3. Embrace the Power of Tables

Who needs flexbox or grid when you can resurrect the undead corpse of 1990s web design? Wrap your div in 17 nested <table> tags, apply align="center", and watch as observers slowly back away from your code. For extra chaos, use <marquee> to make the centered div scroll diagonally. Accessibility? Never heard of her.

4. Position: Absolute; and Guess

Set position: absolute; and then randomly assign top:, left:, right:, and bottom: values like you’re playing CSS bingo. “Maybe left: 47%; will do it?” Spoiler: It won’t. But hey, at least your div now hangs off the edge of the page like a modern art masterpiece.

5. Flexbox Overcomplication

Flexbox is supposed to make centering easy, but where’s the fun in that? Apply display: flex; to the parent, then add justify-content: space-between;, align-items: stretch;, and flex-direction: column-reverse;. When the div still isn’t centered, add transform: rotate(180deg); and declare, “It’s a feature.”

6. The !important Hammer

When all else fails, smash that !important button like it’s the last cupcake at a developer meetup. margin-left: 50% !important; width: 200px !important; position: static !important; Watch as your stylesheet becomes a ticking time bomb of specificity wars. Future you will love debugging this.

7. JavaScript: Because CSS is Too Mainstream

Why write CSS when you can write 30 lines of JavaScript to calculate the viewport width, divide by π, and dynamically inject inline styles? Sure, your div now centers… after a 3-second lag. But at least you’ve justified using React for a static HTML page.

8. Beg and Bribe the Div

Sometimes, kindness wins. Add a CSS comment: /* Please center yourself, I beg you */. If that fails, try whispering sweet nothings to your monitor or offering the div a samosa.

9. Sweep it under the DOM

If all else fails, display: none; and pretend it was never there. Because you need to only center what is present in this material world.

In Conclusion

Centering a div is a spiritual journey that teaches patience, humility, and the importance of Googling “how to center a div” for the 900th time. But if you must know one of the "right" ways (boo, boring!), here’s the secret incantation:

.parent {  
  display: flex;  
  justify-content: center; /* sorcery */  
  align-items: center;     /* dark magic */  
}

…but beware: this method is so straightforward, it might accidentally leave you with free time. And then what? Learn another CSS property? Touch grass? Unthinkable.

—Written by a developer who once centered a div on the first try (it was a hallucination).

Home Row Motion Keys

If you have used Vim before, you will attest to the fact that using Vim's motion keys (h, j, k, l) on the home row is much quicker and reduces the strain on your wrists. For those of you who haven't used Vim, let me introduce you to the pleasures of such a setup.

The setup I'm about to introduce uses the same Vim motions to control all the actions you would normally do with your arrow keys -- move left, move right, select one word, select the top line, or any arrow key action you can name. By the end of this article, you can pull the arrow keys out of your keyboard and throw them away!

For those of you new to touch-typing and Vim, allow me to give a quick introduction to the home row and Vim's motion keys. The home row is the center row on a keyboard. Your left-hand fingers rest on a, s, d, and f, while your right-hand fingers rest on j, k, l, and ; keys. In Vim, the motion keys replacing the arrow keys are as follows:

• ← : h

• ↓ : j

• ↑ : k

• → : l

The Setup

As you know, holding down on Ctrl key allows us to modify the behavior of other keys. For example, pressing the C key directly will type out the letter "c", whereas if you hold Ctrl and then press the C key will copy the selected area.

We can leverage our knowledge of such modifier keys and create our super-keyboard. Instead of relying only on the standard modifier keys (Ctrl, Alt, Super, Fn), we can create our own modifier keys!

f-mode

When you are resting your hand on the home row like a touch typist would, your left index finger should be resting on the F key. Why not use this key as a modifier key instead of its normal function of using it to type "f"? You might argue that the F key is very important to you as you cannot pay respects without it.

Fortunately, most key remappers allow us to map the same key to multiple functions depending on whether it is being held or tapped. For example, below is a keyd configuration that overloads the Capslock key to become Ctrl when held for more than 200ms, but remain as Capslock when just tapped:

capslock = overloadt(control, capslock, 200)

In this manner, we can overload the F key to act as a modifier called nav when being held and act as plain old F when being tapped.

f = overloadt(nav, f, 200)

Just like how the Ctrl modifier modifies the C key's behavior, our custom nav modifier can modify other keys to give our custom behavior. In this setup, I have made the nav modifier to modify as below:

• H: left

• J: down

• K: up

• L: right

• Y: Home

• O: End

[nav]

h = left
j = down
k = up
l = right
y = home
o = end

So, if you hold down your F key and then tap K, you will now mimic the up arrow action! We've replicated the arrow key motions from the comfort of our home row. No more stretching your wrist to access the arrow keys!us

d-mode

"Wait, I can move by holding down F and pressing one of the Vim motion keys (h, j, k, l). But how do I replicate the Shift+Arrow key functionality?" you ask.

If you haven't used the Shift+Arrow combination, here's what it does. In a text editor, if you press Shift + Left Arrow, you can select the character to the left of your cursor.

Here's how we replicate this in our setup. Just like how nav was a new modifier we created, we will also create another modifier called select_nav which will be activated by holding down the D key.

d = overloadt(select_nav, d, 200)

The same directional definitions in the f-mode are used here: (H = left, J = down, ..).

[select_nav]

h = S-left
k = S-up
j = S-down
l = S-right
y = S-home
o = S-end

a-mode and s-mode

If you want to take this even further, we also have the a-mode (word_nav) and s-mode (select_word_nav).

a-mode allows us to move directionally word-by-word instead of character-by-character.

a = overloadt(word_nav, a, 200)

[word_nav]

h = C-left
k = C-up
j = C-down
l = C-right
y = C-home
o = C-end

And s-mode allows us to select directionally word-by-word.

s = overloadt(select_word_nav, s, 200)

[select_word_nav]

h = C-S-left
k = C-S-up
j = C-S-down
l = C-S-right
y = C-S-home
o = C-S-end

Installation

As we will be remapping the keys, we will be installing a key-remapping solution. For Linux, my choice (after much experimentation) is keyd (the examples above are keyd configs).

Note: If anyone using Mac OS X is interested, please comment below as I do have a similar setup using Karabiner-Elements that I can share.

To use, follow the below steps:

• Install keyd service using the following commands:

git clone https://github.com/rvaiya/keyd
cd keyd
make && sudo make install
sudo systemctl enable keyd && sudo systemctl start keyd

This installs the keyd service and enables it to activate on startup.

• Now, we need to configure the key remappings. Paste the following in /etc/keyd/default.conf. You can also star this gist with the keyd.conf code.

[ids]

*

[global]

chord_timeout = 100

[main]

# Layer keys that act as themselves if not held for more than 200ms.
f = overloadt(nav, f, 200)
d = overloadt(select_nav, d, 200)
s = overloadt(select_word_nav, s, 200)
a = overloadt(word_nav, a, 200)

[nav]

h = left
k = up
j = down
l = right
y = home
o = end

[select_nav]

h = S-left
k = S-up
j = S-down
l = S-right
y = S-home
o = S-end

[select_word_nav]

h = C-S-left
k = C-S-up
j = C-S-down
l = C-S-right
y = C-S-home
o = C-S-end

[word_nav]

h = C-left
k = C-up
j = C-down
l = C-right
y = C-home
o = C-end

# Mapping the custom modifier keys to themselves to make those actions 
# instantaneous instead of waiting for the timeout
[shift]

f = F
d = D
s = S
a = A

[control]

f = C-f
d = C-d
s = C-s
a = C-a

[control+shift]

f = C-S-f
d = C-S-d
s = C-S-s
a = C-s-a

• Run sudo keyd reload to reload the new config and voila! You can now pull out your arrow keys as promised!