Ruby Explained: The Language That Puts Developer Happiness First

Introduction

Ruby was designed with one unusual priority: the happiness of the programmer. Its creator, Yukihiro Matsumoto, believed code should be a joy to read and write, and that philosophy shaped a language that often reads like plain English. Ruby is best known through Ruby on Rails, the web framework that launched companies like Shopify, GitHub, and Airbnb — but the language itself is worth learning for its ideas alone.

Everything is an object

In Ruby, there are almost no special cases: numbers, strings, even true and false are objects with methods you can call.

5.times { |i| puts "Hello #{i}" }
# Hello 0
# Hello 1
# Hello 2
# Hello 3
# Hello 4
"hello".upcase       # => "HELLO"
[3, 1, 2].sort       # => [1, 2, 3]

5.times calls a method on the number 5 itself, and the block { |i| ... } is a chunk of code passed to that method — Ruby's most distinctive feature. Blocks let you write loops, filters, and callbacks without ceremony, and once you are used to them, other languages' loop syntax feels clumsy.

Reading like English

Ruby removes punctuation other languages require: parentheses are often optional, and method names can end in ? (asking a question) or ! (warning that something changes in place):

name = "sara"
name.empty?        # => false
name.capitalize!   # name is now "Sara"
[1, 2, 3].include?(2)  # => true

empty? asks a question, capitalize! warns you it changes the string itself, and include? reads as a sentence. This is deliberate: Ruby code is meant to be read aloud and understood.

Rails: convention over configuration

Ruby on Rails, Ruby's famous web framework, applies the same philosophy at a larger scale: sensible defaults mean you write very little setup code. A blog with posts, comments, and pages takes a handful of commands and a few dozen lines in Rails, where other frameworks might take hundreds. "Convention over configuration" — follow the framework's expected layout, and it handles the rest — is an idea Rails made mainstream, and nearly every modern framework has borrowed it since.

Takeaway

Everything is an object, blocks make iteration feel natural, and method names read like sentences. Ruby's lesson is that a language's design philosophy matters: optimise for the person reading the code, and the code gets better for everyone.

Comments

Post a Comment

Popular posts from this blog

Swift Explained: Apple's Language for iPhone, Mac, and More

Introduction Swift is Apple's language for its platforms: iPhone, iPad, Mac, Apple Watch, and Apple TV. Introduced in 2014 to replace the older Objective-C, it was designed to be safe, fast, and — unusually for a systems language — genuinely pleasant to read and write. Even if you never ship an app, Swift teaches one idea every developer should understand: optionals. Optionals: saying "this might be missing" Most bugs in app development come from one cause: code assuming a value exists when it does not. Swift makes that assumption impossible to hide. A value that might be missing is wrapped in an Optional, and you must unwrap it before use. var nickname: String? = nil nickname = "Waqas" if let name = nickname { print("Hello, \(name)!") } else { print("No nickname set.") } String? means "a String, or nothing". The if let unwraps it safely: inside the block, name is guaranteed to exist. There is no way to accidentally us...
Read more

Flutter Explained: One Codebase, Every Screen

Introduction Flutter is Google's framework for building apps from a single codebase: write once in Dart, and ship to iOS, Android, web, Windows, macOS, and Linux. It powers apps from Google Pay to the New York Times crossword app. Its core idea is simple and radical: everything on screen is a widget, and the interface is rebuilt from data whenever that data changes. Everything is a widget In Flutter, there are no separate concepts for layout, styling, and controls — everything is a widget, nested inside other widgets like HTML elements, but in code: import 'package:flutter/material.dart'; class Greeting extends StatelessWidget { @override Widget build(BuildContext context) { return Center( child: Text( 'Hello, Sara!', style: TextStyle(fontSize: 24, color: Colors.teal), ), ); } } Center positions its child, Text displays words, TextStyle styles them — each a widget, composed by nesting. Layout widgets (like Row, Column, ...
Read more

Go Explained: Simple Code That Runs Fast

Introduction Go was built at Google for a specific frustration: large programs that were slow to build and hard to read. The answer was a language that is deliberately small — fewer features, but the right ones, done well. If you know one programming language already, Go will feel familiar within an hour. The interesting parts are not the syntax, but two ideas: goroutines and channels. Goroutines: cheap concurrency Most languages make running things at the same time feel heavy — threads, thread pools, and careful setup. A goroutine is Go's lightweight version: you start one by writing go in front of a function call. package main import ( "fmt" "time" ) func say(text string) { for i := 0; i < 3; i++ { fmt.Println(text) time.Sleep(100 * time.Millisecond) } } func main() { go say("hello") say("world") time.Sleep(500 * time.Millisecond) } The go say("hello") line does not wait — it st...
Read more