If you declare use v5.36; (or a later version, like v5.38 or v5.40) at the top of your script, subroutine signatures are enabled automatically, and you no longer need to suppress any warnings.

A collection of (mostly) technical things every software developer should know about - mtdvio/every-programmer-should-know

This blog post is very long and almost entirely about the 1974 bestseller Zen and the Art of Motorcycle Maintenance by Robert M. Pirsig. It is also about AI—there will be some juicy takes, pinky swear—but those familiar with ZAMM should consider themselves warned.

adam@adamsilver.io - email 2026.03.11

Principle #1: Good design works for everyone

There are many reasons for this principle but my favourite is that designing for a minority makes things better for everyone.

• Large radio buttons don’t just help people with motor impairments; everyone finds them easier to click

Principle #2: Good design makes things obvious

Principle #3: Good design puts users in control

Expect users to get interrupted. People prefer to interact in different ways. And we should design for both an idealised work flow as well as when things don’t go to plan.

Principle #4: Good design is lightweight

A comprehensive guide to design system engineering (DSE): when it’s relevant, how AI changes things, and pointers for getting started. From Michael Abernethy, Principal Frontend Engineer at Rubrik

Five production-breaking patterns where quadratic complexity hides behind readable, idiomatic JavaScript. Why .find() inside .map() passes code review and fails at scale; and the one-line fixes that drop O(n^2) to O(n).

• Pattern 1: The innocent .includes() inside .filter()
• Pattern 2: Deduplication by comparison
• Pattern 3: The cascading .map().filter().map()
• Pattern 4: The recursive tree flattener
• Pattern 5: The SQL query in a loop (the N+1 problem)

Stateless (JWT)

How it works:

User logs in, server creates a JWT containing user data
Server signs the JWT with a secret key
Server sends JWT to client
Client sends JWT with every request
Server verifies the signature and trusts the data inside
Why it scales:

Any server can validate a JWT using the shared secret key
No database lookup needed per request
If you add 100 more servers, they all work immediately

Today, I will focus mostly on Time Complexity from the Perl point of view.

1. O(1) - Constant Time
2. O(n) - Linear Time
3. O(log n) - Logarithmic Time
4. O(n ^ 2) - Quadratic Time
5. O(n log n) - Linearithmic Time
6. O(sqrt n) - Square Root Time
7. O(n ^ 3) - Cube Time
8. O(2 ^ n) - Exponential Time
9. O(n!) - Factorial Time

100 Useful Command-Line Utilities
A Guide to 100 (ish) Useful Commands

Building a fully functional, code-editing agent in less than 400 lines.

Human-centered design has four major principles:

1. Understand and Address the Core Problems;
2. Be People-Centered;
3. Use a Systems Approach;
4. Use Rapid Iterations of Prototyping and Testing.

Building desktop applications has traditionally been a challenge in the Perl ecosystem. While we have... Tagged with perl, c, xs, programming.

A piece of "heredoc" data can appear anywhere in a Perl expression. It starts with an initial operator written either << or <<~. The second variant with an added tilde ~, available since Perl v5.26, introduces an indented heredoc, where initial spaces on the left of each line are automatically removed by the interpreter.

Empty string as delimiter

The delimiter string can also be .. an empty string! In that case the heredoc content ends at the next empty line; this is an elegant way to minimize noise around the data.

Several heredocs can start on the same line, as in this example:

my @blogs = $dbh->selectall_array(<<~END_OF_SQL, {}, split(/\n/, <<~END_OF_BIND_VALUES));

Watch someone backspace 40 characters instead of pressing CTRL+W, and you’ll understand why this list exists.

Hacker News:
https://news.ycombinator.com/item?id=47525243

The one skill that separates senior engineers from everyone else isn’t technical. It’s the ability to take ambiguous problems and make them concrete.

Senior engineers look at the big, messy, abstract thing and start digging:

• They ask questions nobody else thought to ask.
• They separate what matters from noise.
• They identify what should be done now vs. what to punt.

Summary of how to work with regular expressions in Python. Compares Python with Perl and points out some gotchas.

As software engineers we don’t just crank out code—in fact these days you could argue that’s what the LLMs are for. We need to deliver code that works—and we need to include proof that it works as well. Not doing that directly shifts the burden of the actual work to whoever is expected to review our code.

Why moving judgment to the edges wins in the long run

Quality is the degree to which a product or service meets or exceeds user expectations.

Building quality software is already hard. Centralized quality starts and ends with leadership-driven quality standards and reviews, where a single stakeholder reviews our work and decides whether it meets their standards. This has been the standard at every company I’ve worked with; design and engineering are both taught through critique and reviews from the earliest stages of production to the final delivery of a complete product. This approach can work brilliantly when executed with precision, but it creates a bottleneck: no matter how talented, a single person can only review so much.\

Decentralized quality means putting quality in the hands of workers, not managers.

1/13/20: Course overview + the shell
1/14/20: Shell Tools and Scripting
1/15/20: Editors (Vim)
1/16/20: Data Wrangling
1/21/20: Command-line Environment
1/22/20: Version Control (Git)
1/23/20: Debugging and Profiling
1/27/20: Metaprogramming
1/28/20: Security and Cryptography
1/29/20: Potpourri
1/30/20: Q&A

A Page in : Python Programming Exercises, Gently Explained