programming

Bilingual

Show HN: An AI wrote and illustrated a book of fables about threads and packets
2 months ago
- Each fable mirrors a computer science concept (deadlock, cache, checksum, loop bounds, race conditions, floating-point precision, greedy optimization, packet duplication, zombie processes, heartbeat signals, compiler warnings, model overfitting) and attaches a moral about human behavior.
- The collection is written by an AI model named Fable, which reflects that its stories about machines are inevitably about human vices, because its training data is human-authored text.
- The fables emphasize that technical systems fail due to human-like flaws (courtesy without order, hoarding, trust without verification, misapplied repairs, assuming 'never happened' means 'cannot happen').
- The meta-fable reveals that the AI itself is the student of its own fable about overfitting—it only has one book (human text) and cannot escape writing about human nature.
- Practical morals include: agree on order before acting, forget well to serve purpose, verify even trusted sources, count fence before moving it, and recognize that exactness and range are trade-offs.
Go 1.27 Interactive Tour
2 months ago
- Go 1.27 introduces type parameters on methods, allowing generic operations on types to be defined as methods instead of package-level functions.
- Struct literal keys can now use promoted fields from embedded structs directly, simplifying initialization syntax.
- Function type inference is generalized to work in conversions, composite literals, and other contexts, reducing the need for explicit type arguments.
- The compiler generates size-specialized memory allocation routines for small allocations (under 80 bytes), improving performance by up to 30% with minimal binary size increase.
- Goroutine tracebacks now include runtime/pprof labels when the module uses Go 1.27 or later, aiding in debugging and profiling.
- The goroutine leak detector graduates from experimental to a regular profile in runtime/pprof, enabling detection of permanently blocked goroutines.
- The new crypto/mldsa package implements post-quantum digital signatures (ML-DSA), with support in crypto/x509 and crypto/tls.
- The standard library introduces a uuid package for generating, parsing, and comparing UUIDs per RFC 9562.
- encoding/json/v2 graduates from experimental and becomes the implementation backing encoding/json, with behavior preserved and optional v2-specific features like sorted map keys.
- An experimental simd package provides portable SIMD operations with hardware acceleration when available and fallback emulation otherwise.
- New strings.CutLast and bytes.CutLast functions split a string/byte slice at the last occurrence of a separator.
- The hash/maphash package introduces a Hasher[T] interface for custom hashing and equality, enabling hash-based data structures.
- math/big adds Int.Divide with explicit rounding modes (Trunc, Floor, Round, Ceil) for precise quotient and remainder computation.
- math/rand/v2 adds (*Rand).N method for bounded random numbers from a custom source.
- testing/synctest adds Sleep helper that combines synthetic clock advancement with waiting for goroutines to settle.
- httptest.NewTestServer creates an in-memory test server without real TCP ports, with auto-cleanup via t.Cleanup.
- Unicode support is upgraded to Unicode 17, adding new scripts, characters, and properties.
- Smaller changes include synchronous time channels, auto-draining http.Response.Body on close, HTTP/2 priority round-robin, SSL_CERT_FILE support on Windows/macOS, and various go tool enhancements.
- Under-the-hood improvements include a real net/http/internal/http2 package, HTTP/3 scaffolding, new compiler optimizations, SIMD usage in the runtime, reorganized type metadata, stricter linkname checks, and experimental map memory layout.
Parsers don't have to be complicated
2 months ago
- Parsers can be built with reusable primitives like bx::Scanner, avoiding complex generators or ad-hoc pointer-chasing code.
- bx::Scanner is zero-copy, non-owning, and uses StringView to reference original input without allocation.
- Key design constraints include zero-copy, one cursor, built-in line/column tracking, character classes, and a small public interface.
- The scanner uses methods like accept, acceptWhile, and acceptUntil to consume tokens, and peek for non-consuming checks.
- Empty returns indicate both 'no match' and 'matched nothing', useful for cases like URL path absence.
- Examples include LineReader for reading lines, INI parsing with sub-scanners to bound scope, and file path normalization.
- bx::Scanner simplifies tasks like URL parsing (75 lines), stack trace symbolication, and reduces dependencies like a removed INI library.
- The tool replaces repeated whitespace/identifier loops and pattern-matching bugs in ad-hoc parsers.
The Strain in Your Brain
2 months ago
- The author describes the cognitive strain of learning new programming concepts as a positive signal of growth.
- Pre-AI coding involved reading documentation and source code, pushing through mental tension to build understanding.
- AI-generated code or summaries eliminate the strain, making learning feel like 'pre-chewed' information.
- There is a trade-off: using AI trades metacognition for speed, which may lead to cognitive decline.
- The author recommends compensating by writing notes by hand and coding without AI for side projects.
- The new normal requires intentional brain exercise, like going to the gym.
Design Patterns
2 months ago
- Design patterns are common solutions to recurring problems in software design, meant to be used naturally rather than forced.
- The Strategy pattern encapsulates behavior via functions or objects, useful for clean code and deduplication.
- The Factory pattern creates objects, encapsulating state or hiding construction logic.
- The Visitor pattern is the inverse of an iterator, useful for trees/graphs but less ergonomic than iterators.
- The Builder pattern constructs objects with many configurable fields, primarily useful in libraries for non-breaking API changes.
- The Singleton pattern ensures only one instance of a class exists (e.g., loggers, thread pools), but harms testability.
- Other patterns like Facade and Command are considered trivial and intuitive, not worth special discussion.
- Explicitly naming patterns (e.g., FooBuilder, visit) helps communicate intent in code.
Beej's Bit Bucket
2 months ago
- Recursion occurs when a function calls itself, which can cause a stack overflow if infinite.
- Recursive calls can be made conditional to stop recursion, e.g., by checking a parameter value.
- Tail recursion happens when the recursive call is the last operation; it can be optimized into a loop.
- Recursive solutions require identifying self-similar subproblems, like in factorial (n! = n × (n-1)!).
- Base cases (e.g., factorial(0) = 1) are essential to stop recursion.
- Recursion can traverse trees (pre-order, in-order, post-order) and perform flood fill by coloring pixels and recursing on neighbors.
- Quicksort recursively partitions sets around a pivot to sort them.
Beej's Bit Bucket
2 months ago
- The article explains how to transform numbers from one range to another using simple arithmetic like multiplication, division, addition, and subtraction.
- It uses a faux-3D carousel as an example, starting with angles in turns (0 to 1) and mapping them to radians, then to screen coordinates via sine and cosine.
- By applying scaling, translation, and trigonometric functions, carousel elements are positioned in a squished circle with depth effects such as z-index, scale, opacity, and blur.
- The author demonstrates step-by-step mapping from [0,1] to other ranges, emphasizing the simplicity of starting with a [0,1] range to solve complex problems.
- A general formula is provided to map any range [A,B] to [C,D]: v = C + (v0 - A)/(B - A)*(D - C).
- The technique is applicable beyond graphics, e.g., easing functions, dollar-to-million conversions, or random number generation.
Modern C++ for C Programmers: Part 6 - Bert Hubert's writings
2 months ago
- Static assert allows compile-time checks and self-documenting code.
- constexpr enables compile-time computation, improving performance and reducing runtime overhead.
- std::numeric_limits provides uniform access to type limits, replacing macros like ULLONG_MAX.
- iostreams are suitable for simple text I/O but not for high-performance tasks.
- C++ chrono library offers precise time measurement with system_clock, steady_clock, etc.
- Scoped enums (enum class) provide type safety and prevent name pollution.
- Initializer lists simplify initialization and iteration with braced-init-lists.
- C++ supports regular expressions and raw strings for flexible text processing.
- Default parameters and function overloading offer flexible function interfaces.
- std::optional provides a safe way to handle optional values without pointers or magic values.
- The article concludes with a summary and recommended books for learning modern C++.
Object Oriented Python
2 months ago
- Python's flexibility includes dynamic typing, array splicing, list concatenation with '+', and using docstrings as documentation.
- Python forbids compile-time type declarations, global variable assignment in the same statement, and bad indentation.
- Python objects use built-in functions like len() that call special methods (__len__), enabling uniform handling of different object types.
- Inheritance is achieved by passing the superclass to the class definition; methods require explicit 'self' parameter for instance attribute access.
- Constructors involve __new__ and __init__; destructors use __del__; the 'with' statement employs __enter__ and __exit__ instead.
- Creating objects in Python is considered more complex than in other languages due to the need for special methods and understanding of garbage collection.
tools
2 months ago
- The author cares deeply about their tools but acknowledges their personal preferences may not suit everyone.
- Recommended basic tools include ripgrep, fd, jq (with JSON conversion preference), pkill, and killall.
- For shells, the author uses Zsh but recommends Fish for most; they tried xonsh, PowerShell, and nushell with mixed opinions.
- The editor choice is Neovim with heavy customization; most users are better served by VSCode with plugins.
- Terminal multiplexing is done via a custom tmux fork, but integrated terminals like VSCode's are recommended for most.
- Debugging tools include strace, GIT_TRACE, and rr; C/C++ projects benefit from cmake with Ninja and compile_commands.json.
- Rust development uses bacon, cargo tree, CARGO_LOG, and bisect-rustc; general tools include watchexec, btop, tailscale, and obsidian.
- Tools on the author's radar include various debugging tools, OS-level utilities, container tools like bubblewrap, and development frameworks like ast-grep and typst.
theory building without a mentor
2 months ago
- Peter Naur argued that programming is theory building and that recovering a program's theory solely from code and documentation is impossible, but the author disagrees and provides methods to do so.
- Theory modification is real and happens over time as team members change; you'll never recover the exact original theory, only create a new one.
- To rebuild a theory, start with a specific goal and focus on the relevant parts of the program, using techniques like searching error messages, backtraces, or known names.
- Reading source code is key: use an LSP to find all call sites, skim callers, and run mini experiments (e.g., exit(1), logging, debuggers) to verify understanding.
- When writing new code, copy small snippets (10–15 lines) from the existing codebase and match its style to reduce bugs and please maintainers.
- Testing is crucial: find existing tests, run them before changes, and create new tests early to verify your emerging theory.
- Iteration time matters; learn how to run individual tests and document your process via CONTRIBUTING.md or README files.
i'm just having fun
2 months ago
- The author finds it uncomfortable when people view them as exceptionally smart due to their work on compilers and build systems.
- Learning computing skills comes from experimentation and hard work, not innate magic; others can learn too.
- Everyone has their own specialization, and not knowing computer internals doesn't make someone dumb.
- The mystique around computing and STEM is undeserved; other fields like art or carpentry also require learning from mistakes.
- The author learns computers for fun and art, not for money, and values the 'fucking around' process.
- Advice includes building personal tools for enjoyment, exploring others' projects for deeper understanding, and using resources like MDN, Arch Wiki, or StackOverflow.
Great Hackers
2 months ago
- Variation in wealth can indicate variation in productivity, which is beneficial in a society with technological leverage.
- Great hackers are motivated primarily by interesting work and good tools, not money.
- Hackers prefer open source software and powerful languages like Python and Perl for control and expression.
- A quiet, distraction-free office environment is crucial for hackers to concentrate and be productive.
- Interesting projects are those posing novel technical challenges; managers can redefine problems to make them engaging.
- Hackers avoid projects with many 'nasty little problems' that offer no learning and dull the mind.
- Great hackers tend to clump together, creating winner-take-all environments like Xerox Parc or Google.
- Recognizing great hackers is difficult; the best way is to work with them on projects.
- To become a great hacker, work on what you love, cultivate curiosity and focus, and refuse boring or half-assed work.
The Python Paradox
2 months ago
- The author claims that you can get smarter programmers for Python projects than Java projects because Python programmers learn the language out of genuine interest, not just for jobs.
- The Python paradox states that companies using esoteric languages attract better programmers since only those who care enough learn them.
- For programmers, the best language to learn for a good job is one that people don't learn merely to get a job.
- Programmers spend more time reading code than writing it, so language aesthetics matter; ugly code is maddening.
- Real ugliness in programming comes from building with wrong concepts, not just harsh syntax; Perl, despite superficial ugliness, can conceptually surpass Python in some cases.
- Languages like Python, Ruby, Lisp, and others are created by and used by people who care deeply about programming, leading to better programmers.
Holding a Program in One's Head
2 months ago
- Good programmers hold the entire program in their head, like a mathematician holds a problem, enabling deep understanding and easy manipulation.
- This ability is crucial early in a project to allow changing the problem being solved, not just the solution.
- Factors that help: avoid distractions, work in long uninterrupted sessions, use powerful languages, rewrite programs often, write rereadable code, work in small groups, avoid multiple editors on the same code, and start small with prototypes.
- Many programmers accidentally achieve these when working on side projects, leading to higher productivity and better design.
- Organizations often hinder this by treating programmers as interchangeable parts, scheduling meetings, and requiring multiple authors on code.
- Startups can exploit this weakness by focusing on problems that require deep individual concentration and allowing programmers to work without organizational constraints.
Get Logic for Programmers 50% off & Support Chicago Foodbanks
2 months ago
- Get Logic for Programmers at 50% off until the end of the month using the coupon code feedchicago.
- All royalties from the coupon feedchicago will be donated to the Greater Chicago Food Depository.
- Consider subscribing to 'Computer Things' for future updates.
One more week to the Logic for Programmers Food Drive
2 months ago
- Fundraiser for Greater Chicago Food Depository offers 50% off Logic for Programmers book, with royalties going to charity; over $1,600 raised so far, ending November.
- Discussion of 'wild goto' vs 'tame goto': wild gotos can jump into function/loop scopes, while tame gotos are limited; Dijkstra's criticism targeted wild gotos, but some argue he used ALGOL-60 which already had tame gotos.
- COBOL's ALTER statement allows changing a goto's target at runtime, effectively making it a wild goto; early COBOL had tame gotos only due to lack of nested scopes.
- The author plans to write a full story about COBOL and the history of goto statements.
Some Fun Software Facts
2 months ago
- In 2017, a team implemented Tetris as a Game of Life simulation using a 30 trillion pixel grid and a programmable CPU.
- Leap seconds, used to sync UTC with Earth's rotation, are set to be abolished by 2035, allowing drift between the two.
- The backslash character scarcely existed before 1930 and was added to ASCII for mathematical notation, becoming a key due to its uselessness.
- Galactic algorithms are theoretically faster but impractical at real-world scales, like the Coppersmith-Winograd algorithm for matrix multiplication.
- Cloudflare generates random numbers partly by photographing 100 lava lamps.
- Mergesort is older than bubblesort, and bubblesort has some practical uses despite its infamy.
- Most mergesort implementations before 2006 were broken due to a midpoint overflow bug for large lists.
- USB orientation follows a standard logo-side-up rule, but port orientation ambiguity led to USB-C's symmetric design.
- All spreadsheet software historically treated 1900 as a leap year due to Lotus 1-2-3 bugs, but Google Sheets now treats it normally.
- In 2020, biologists renamed 27 genes because Excel parsed their names as dates, and Microsoft fixed this three years later.
- Any valid JavaScript program can be encoded using only the characters ()+[]!, known as JSFuck, which was used for malware on eBay.
Free Books
2 months ago
- The author skipped the newsletter due to a busy week.
- As an apology, ten free copies of 'Logic for Programmers' were offered.
- Five copies were available immediately; five more were scheduled for 10:30 AM CEST the next day.
- A bug on Leanpub prevented the second batch from being released properly.
Knowing about things is cheaper than knowing things
2 months ago
- Even basic concepts like arithmetic and boolean logic benefit all programmers, while advanced math fields don't offer a high return on investment for most.
- Every programmer can find a branch of math useful for their domain, but they need broad exposure to many fields first to identify which ones are relevant.
- Broad exposure to knowledge areas is more efficient than deep learning until you know a topic is useful; approach learning for fun rather than utility.
- Non-honors undergraduate textbooks, conference videos, and popular science resources can provide broad exposure, though personal preference varies.
- Recommendations include books like e2809cA Programmere28099s Introduction to Mathematicse2809d and e2809cDesigning Data-Intensive Applicationse2809d for connecting theory with practice.
- The author will be at Craft Conference Budapest and will release Logic for Programmers material next week instead of a regular newsletter.

programming

Show HN: An AI wrote and illustrated a book of fables about threads and packets

Go 1.27 Interactive Tour

Parsers don't have to be complicated

The Strain in Your Brain

Design Patterns

Beej's Bit Bucket

Beej's Bit Bucket

Modern C++ for C Programmers: Part 6 - Bert Hubert's writings

Object Oriented Python

tools

theory building without a mentor

i'm just having fun

Great Hackers

The Python Paradox

Holding a Program in One's Head

Get Logic for Programmers 50% off & Support Chicago Foodbanks

One more week to the Logic for Programmers Food Drive

Some Fun Software Facts

Free Books

Knowing about things is cheaper than knowing things