Artem's Notes

Typography and the Art of Reading

2025-02-10T00:00:00+00:00

Good typography is invisible. You don’t notice it when it’s done well — you just read. The letters dissolve into meaning, and meaning dissolves into understanding. But bad typography? That’s a splinter in your mind. 

The Foundations of Readable Text</h2>
Every decision in typesetting is a decision about cognition. Line length, letter spacing, the weight of a stroke — these aren’t aesthetic luxuries. They’re cognitive infrastructure. (Research in cognitive psychology suggests that line lengths between 50–75 characters optimize reading speed and comprehension. Longer lines increase saccade distance; shorter lines cause too many line breaks.)
The best typographers understand this intuitively. They know that a paragraph set in 10px Helvetica on a 1400px-wide container isn’t just ugly — it’s hostile. It forces the reader’s eyes to work harder, and working harder means thinking less about the content.
Choosing a Typeface</h3>
Not all typefaces are created equal, and the choice matters more than most designers admit. A few principles:

Serif for long-form reading. The serifs guide the eye along the baseline, reducing fatigue.</li>
Monospace for data and code. Fixed-width characters align vertically, making patterns visible.</li>
Sans-serif for UI elements. Clean, compact, and legible at small sizes.</li>
Match the tone. A legal brief in Comic Sans is a crime. A children’s book in Garamond is a missed opportunity.</li> </ul>

“Typography is the craft of endowing human language with a durable visual form.” — Robert Bringhurst, The Elements of Typographic Style </blockquote>
The Vertical Rhythm</h3>
Vertical rhythm is the secret weapon of good page design. When your line heights, margins, and padding all dance to the same beat, the page breathes. (Vertical rhythm is established by setting all vertical spacing as multiples of the base line height. If your body text has a line height of 24px, your headings, margins, and padding should all be multiples of 24px.)
Here’s how you might calculate a modular scale in code:
def modular_scale(base: float, ratio: float, steps: int) -> list[float]: """Generate a modular type scale.""" return [base * (ratio ** i) for i in range(steps)] # Major Third scale from 16px scale = modular_scale(16, 1.25, 8) for i, size in enumerate(scale): print(f"Step {i}: {size:.2f}px")</code></pre> The output gives you a harmonious set of sizes where each step feels proportionally right relative to the others. Typography on the Web</h2> The web has come a long way since the days of font-family: Arial</code>. We now have: Variable fonts that let you adjust weight, width, and optical size on a continuous axis</li> Fluid typography using clamp()</code> to scale smoothly between viewport sizes</li> Subpixel rendering improvements across browsers</li> Font loading APIs that prevent layout shifts</li> </ol> But with great power comes great responsibility. Just because you can use 14 different weights doesn’t mean you should. (A good rule of thumb: stick to two weights (regular and bold) and two styles (roman and italic). That gives you four variants — more than enough for most projects.) The clamp()</code> Function</h4> The clamp()</code> function is perhaps the most elegant tool in modern CSS typography. It lets you set a minimum, a preferred (fluid) value, and a maximum: // Not CSS, but the math behind clamp() is interesting: fn fluid_value(min_size: f64, max_size: f64, min_vw: f64, max_vw: f64) -> String { let slope = (max_size - min_size) / (max_vw - min_vw); let intercept = min_size - slope * min_vw; format!( "clamp({}rem, {}vw + {}rem, {}rem)", min_size / 16.0, slope * 100.0, intercept / 16.0, max_size / 16.0, ) }</code></pre> Note</div> Fluid typography isn't just about font sizes. You should also scale your spacing, line heights, and layout widths fluidly. The Utopia calculator is an excellent tool for generating these values. </div> The Mathematics of Beauty</h2> There’s a deep connection between typography and mathematics. The golden ratio appears in classical book proportions. The Fibonacci sequence echoes in modular scales. Even Euler’s identity has a certain typographic elegance: $e^{i\pi} + 1 = 0 </div> Five fundamental constants — e, i, π, 1, and 0 — united in a single, breathtaking equation. If mathematics is the language of the universe, typography is its calligraphy. Final Thoughts</h2> Good typography doesn’t call attention to itself. It serves the reader, not the designer. The next time you sit down to design a page, remember: you’re not decorating — you’re building a reading experience. And a great reading experience? That’s the closest thing we have to telepathy.$



Getting Started with Rust
2025-01-28T00:00:00+00:00
Rust is one of those languages that makes you a better programmer even if you never ship a line of Rust code. The concepts it teaches — ownership, borrowing, lifetimes — change how you think about all</em> code.</p>
</span>
Why Rust?</h2>
The pitch is simple: memory safety without garbage collection, performance without footguns, and concurrency without data races. But the real reason to learn Rust is more subtle: it makes you think</em> before you allocate, mutate, or share. (This "forced thinking" is what some people find frustrating about Rust. But it's also what makes Rust code so reliable once it compiles. The compiler is essentially a very pedantic code reviewer.)</p>
Your First Program</h2>
Let’s start with something more interesting than “Hello, World”:</p>
use</span> std</span>::</span>collections</span>::</span>HashMap</span>;</span></span>
</span>
fn</span> word_count</span>(</span>text</span>:</span> &</span>str</span>)</span> -></span> HashMap</span><</span>&</span>str</span>,</span> usize</span>></span> {</span></span>
    let</span> mut</span> counts</span> =</span> HashMap</span>::</span>new</span>(</span>)</span>;</span></span>
    for</span> word</span> in</span> text</span>.</span>split_whitespace</span>(</span>)</span> {</span></span>
        let</span> word</span> =</span> word</span>.</span>trim_matches</span>(</span>|</span>c</span>:</span> char</span>|</span> !</span>c</span>.</span>is_alphanumeric</span>(</span>)</span>)</span>;</span></span>
        *</span>counts</span>.</span>entry</span>(</span>word</span>)</span>.</span>or_insert</span>(</span>0</span>)</span> +=</span> 1</span>;</span></span>
    }</span></span>
    counts</span></span>
}</span></span>
</span>
fn</span> main</span>(</span>)</span> {</span></span>
    let</span> text</span> =</span> "</span>the quick brown fox jumps over the lazy dog the fox</span>"</span>;</span></span>
    let</span> counts</span> =</span> word_count</span>(</span>text</span>)</span>;</span></span>
</span>
    let</span> mut</span> sorted</span>:</span> Vec</span><</span>_</span>></span> =</span> counts</span>.</span>iter</span>(</span>)</span>.</span>collect</span>(</span>)</span>;</span></span>
    sorted</span>.</span>sort_by</span>(</span>|</span>a</span>,</span> b</span>|</span> b</span>.</span>1</span>.</span>cmp</span>(</span>a</span>.</span>1</span>)</span>)</span>;</span></span>
</span>
    for</span> (</span>word</span>,</span> count</span>)</span> in</span> sorted</span> {</span></span>
        println!</span>(</span>"</span>{</span>word:>10</span>}</span>: </span>{</span>count</span>}</span>"</span>)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
Notice a few things: &str</code> means we’re borrowing the string (not owning it), mut</code> explicitly marks mutable state, and the compiler ensures we can’t accidentally create dangling references.</p>
Understanding Ownership</h2>
Ownership is Rust’s central innovation. The rules are deceptively simple:</p>

Each value has exactly one owner</em></li>
When the owner goes out of scope, the value is dropped</li>
You can borrow</em> a value (immutably or mutably), but not both at once</li>
</ol>
Here’s where it gets interesting:</p>
fn</span> take_ownership</span>(</span>s</span>:</span> String</span>)</span> {</span></span>
    println!</span>(</span>"</span>I own this now: </span>{</span>s</span>}</span>"</span>)</span>;</span></span>
    //</span> s is dropped here</span></span>
}</span></span>
</span>
fn</span> borrow_only</span>(</span>s</span>:</span> &</span>str</span>)</span> {</span></span>
    println!</span>(</span>"</span>Just looking: </span>{</span>s</span>}</span>"</span>)</span>;</span></span>
    //</span> s is NOT dropped — we only borrowed it</span></span>
}</span></span>
</span>
fn</span> main</span>(</span>)</span> {</span></span>
    let</span> greeting</span> =</span> String</span>::</span>from</span>(</span>"</span>hello</span>"</span>)</span>;</span></span>
</span>
    borrow_only</span>(</span>&</span>greeting</span>)</span>;</span>    //</span> Fine — we still own greeting</span></span>
    println!</span>(</span>"</span>{</span>greeting</span>}</span>"</span>)</span>;</span>     //</span> Fine — greeting is still valid</span></span>
</span>
    take_ownership</span>(</span>greeting</span>)</span>;</span>   //</span> Ownership moves into the function</span></span>
    //</span> println!("{greeting}");  // ERROR: greeting has been moved!</span></span>
}</span></span></code></pre>
  Warning</div>
  The borrow checker is your friend, not your enemy. When you fight it, you lose. When you listen to it, you write better code. If the compiler rejects your code, it's almost always catching a real bug — even if it doesn't feel like it at first.
</div>
Error Handling</h2>
Rust doesn’t have exceptions. Instead, it uses the Result</code> type — which forces you to handle errors explicitly:</p>
use</span> std</span>::</span>fs</span>;</span></span>
use</span> std</span>::</span>io</span>;</span></span>
</span>
fn</span> read_config</span>(</span>path</span>:</span> &</span>str</span>)</span> -></span> Result</span><</span>String</span>,</span> io</span>::</span>Error</span>></span> {</span></span>
    fs</span>::</span>read_to_string</span>(</span>path</span>)</span></span>
}</span></span>
</span>
fn</span> main</span>(</span>)</span> {</span></span>
    match</span> read_config</span>(</span>"</span>config.toml</span>"</span>)</span> {</span></span>
        Ok</span>(</span>contents</span>)</span> =></span> println!</span>(</span>"</span>Config loaded: </span>{</span>}</span> bytes</span>"</span>,</span> contents</span>.</span>len</span>(</span>)</span>)</span>,</span></span>
        Err</span>(</span>e</span>)</span> =></span> eprintln!</span>(</span>"</span>Failed to read config: </span>{</span>e</span>}</span>"</span>)</span>,</span></span>
    }</span></span>
}</span></span></code></pre>
No null pointer exceptions. No uncaught exceptions crashing your program at 3 AM. Just honest, explicit error handling.</p>
Where to Go Next</h2>
Once you’re comfortable with the basics:</p>

The Rust Book</strong> — the official guide, and genuinely one of the best programming books ever written</li>
Rustlings</strong> — small exercises to practice concepts</li>
Advent of Code</strong> — solve puzzles in Rust to build fluency</li>
A small CLI tool</strong> — nothing teaches like building something real</li>
</ul>
Rust has a steep learning curve, but it’s not a cliff. It’s more like a mountain with excellent trail markers. Take it one step at a time, and enjoy the view.</p>