Hasty Briefsbeta

All tags

#programming

778 stories total

Bilingual

Beating myself at chess
4 months ago
- Created a chess AI to beat the author, who admits to being terrible at chess.
- Motivated by experimenting with development environments, simplicity, and potential portability to vintage computers.
- Used a nostalgic, minimal development setup: GNU Screen, Vim, entr, and w3m on a netbook.
- Developed the chess engine in C with zero dependencies, fixed memory usage, and under 600 lines of code.
- Compiled to WebAssembly, resulting in under 6 KB, with potential to run on old systems like DOS or Amiga.
- Initially skipped writing tests but later had to create a test framework to fix bugs during refactoring.
- Integrated with XBoard using a simple text protocol and browsers via cm-chessboard and WebAssembly.
- The AI successfully beats the author, though its ability against others is untested.
- Recommends the project for practicing programming or testing new languages/paradigms.
Odin Programming Language
4 months ago
- Odin is a general-purpose programming language designed for high performance, modern systems, and data-oriented programming.
- Odin is positioned as a C alternative that emphasizes the joy of programming.
- The language supports features like SOA (Structure of Arrays) data types, array programming, and custom allocators.
- Odin includes built-in support for major graphics APIs and popular libraries like SDL2, GLFW, and raylib.
- JangaFX uses Odin in production for their 3D animation software (EmberGen, GeoGen, LiquiGen), which is used by major companies in the games and film industries.
- ChiAha™ Digital Twin Toolkit, written in Odin, helps optimize factory flow and production line performance.
- Odin is open-source and encourages community contributions through GitHub and Discord.
- The language emphasizes simplicity, performance, and modern programming paradigms.
Maybe Comments _Should_ Explain 'What'
4 months ago
- Comments should explain both 'what' and 'why', not just 'why'.
- Descriptive variable names reduce the need for 'what' comments but don't eliminate context switches.
- Storing 'why' in commit messages or tests can make it harder to find and understand the reasoning behind code.
- Extracting methods for cleaner code can introduce context switches when debugging or understanding the flow.
- Well-placed 'what' comments can sometimes be more effective than method extraction for understanding code.
- The article argues against the blanket rejection of 'what' comments, suggesting they have valid use cases.
Was It Really a Billion Dollar Mistake?
4 months ago
- Tony Hoare coined the term 'Billion Dollar Mistake' to describe the invention of null references in 1965, which he later regretted due to the errors and crashes they caused.
- Null pointers are just one type of invalid memory address and are easier to catch at runtime compared to other memory issues like use-after-free or incorrect pointer arithmetic.
- The article argues that removing null pointers introduces trade-offs in language design, such as requiring explicit initialization or complicating memory management.
- Odin, a systems-level programming language, retains nil pointers to maintain a C-like feel and avoid the architectural overhead of explicit initialization.
- The author critiques the 'individual-element mindset' in programming, which focuses on managing each element's lifetime separately, leading to inefficient and bug-prone code.
- A 'grouped-element mindset' is advocated, where collections of elements are managed together, reducing the need for complex ownership semantics and improving performance.
- Language design decisions, like those in Odin, reflect a conscious choice to nudge programmers towards better architectural practices rather than enforcing compile-time safety for every possible error.
A Visual Roadmap of C#
4 months ago
- C# Fundamentals & Type System covering compilation, IL model, value vs reference semantics, and nullability.
- Modern Language Features including pattern matching, records, immutability, and collection expressions.
- Advanced Type System topics like generics, variance, interfaces, and static abstracts.
- Performance & Memory optimization with structs, ref structs, memory views, and unsafe code.
- Async & Functional Patterns such as delegates, lambdas, async/await semantics, and error handling.
- Metaprogramming & Evolution with attributes, source generators, and C# language evolution.
I program without syntax highlighting
4 months ago
- The author prefers not using syntax highlighting in their editor, Acme, and argues there are advantages to this approach.
- Syntax highlighting can help spot syntax errors quickly, but the author uses active methods like double-clicking markers in Acme to check for matching parentheses, quotes, and comments.
- Without syntax highlighting, the author finds code readability improves, making them more sensitive to code organization and beauty, avoiding anti-patterns like long lines or commented-out code.
- Working without syntax highlighting removes the dependency on language-specific highlighters, beneficial for languages like Agda with limited editor support.
- Editors with fewer configurations, like no syntax highlighting, reduce distractions and future-proof the tool against language changes and new syntax additions.
- The distinction between editing and parsing code is clearer when the editor doesn't attempt syntax highlighting, avoiding maintenance issues with language updates.
- Some languages, like Agda, have syntax features like comment nesting that complicate traditional syntax highlighting.
Why German Strings Are Everywhere?
4 months ago
- Strings are more complex than just a sequence of characters, leading to varied implementations across programming languages.
- German Strings, developed by Umbra (predecessor to CedarDB), are optimized for data processing and adopted by systems like DuckDB and Apache Arrow.
- C strings are simple but cumbersome, requiring manual memory management and lacking built-in safety features.
- C++ strings improve upon C with features like size tracking, buffer capacity, and short string optimization (SSO).
- German Strings optimize for common use cases: short strings, immutability, and prefix comparisons.
- Short strings (≤12 chars) are stored in-place, avoiding pointer dereferencing and improving access speed.
- Long strings (>12 chars) store a 4-character prefix to speed up comparisons and avoid unnecessary dereferencing.
- German Strings use a 128-bit struct, saving space and enabling efficient function calls via registers.
- Storage classes (persistent, transient, temporary) manage string lifetimes, optimizing memory usage and performance.
- Transient strings point to externally managed memory, reducing overhead for temporary data access.
- German Strings offer performance benefits but require careful consideration of string lifetime and immutability.
Perlsecret – Perl secret operators and constants
4 months ago
- Perl secret operators and constants are nicknamed based on their appearance rather than function.
- Secret operators are not officially recognized by Perl but are used by Perl golfers and obfuscators for concise coding.
- Examples include the Venus operator (0+) for numification, Babycart (@{[ ]}) for list interpolation, and Bang bang (!!) for boolean conversion.
- Other notable operators include the Eskimo greeting (}{) for one-liner END blocks, Maori farewell (-M5;) for BEGIN blocks, and Inchworm (~~) for scalar context.
- Secret constants like Space fleet (<=><=><=>) and Amphisbaena (<~>) provide quirky functionalities.
- Warning: Many secret operators are obscure and not suitable for production code.
- The document also covers deprecated operators due to Perl's evolution, like those affected by the 'bitwise' feature in Perl 5.028.
An Honest Review of Go
4 months ago
- Go's concurrency model with Goroutines and Channels is well-integrated and avoids the 'colored functions' problem.
- Go's type system is simple, using struct embedding instead of complex inheritance, and interfaces are implicitly satisfied.
- The syntax of Go is praised for its simplicity, including type annotations and visibility based on letter case.
- A major drawback is the lack of proper enums, leading to workarounds with constants that don't ensure exhaustiveness.
- Go lacks immutability for non-compile-time constants, forcing the use of mutable variables or functions to protect data.
- Error handling in Go is verbose and relies on the `error` interface, which can obscure useful error information.
- The absence of sum types and enums in Go makes error handling less robust compared to languages like Rust.
Why AI is pushing developers toward typed languages
4 months ago
- The debate between typed and untyped languages is ongoing, with AI tools influencing the preference for typed languages due to their reliability.
- Typed languages provide a safety net by catching errors, especially important when AI generates code, reducing surprises and debugging time.
- A 2025 study found that 94% of LLM-generated compilation errors were type-check failures, highlighting the importance of type safety.
- TypeScript became the most used language on GitHub in 2025, with significant growth attributed to AI-assisted development and frameworks defaulting to TypeScript.
- Other typed languages like Luau and Typst also saw substantial growth, indicating a broader trend towards typed ecosystems in AI-assisted coding.
- Type systems are becoming central to reliable software development, offering predictability and maintainability, especially as AI tools become more prevalent.
What Happened to WebAssembly
4 months ago
- WebAssembly is used in real-world applications like Godot for web games, Squoosh.app for image processing, and Figma for C++ code conversion.
- WebAssembly is a language, not a speed benchmark; its efficiency depends on how well it maps to modern hardware.
- WebAssembly can be compiled from many languages including Rust, C, and Go, and can run in browsers or standalone runtimes.
- Security is a key feature of WebAssembly, with minimal attack surfaces and explicit host-defined imports for external interactions.
- WebAssembly enables portability and embeddability, allowing plugins and tools in various environments without language constraints.
- Performance trade-offs exist with WebAssembly, including binary bloat and boundary crossing costs, but it's generally 'fast enough' for most uses.
- WebAssembly's development is active but controversial, with rapid standardization and feature adoption raising concerns about missteps.
- WebAssembly is unlikely to replace JavaScript in browsers but is widely used by library authors, often transparently to application developers.
AI Zealotry
4 months ago
- AI development enhances productivity and fun for senior engineers by automating tedious tasks and enabling work in new areas like frontend.
- Concerns about AI include generating junk code, loss of deep understanding, and dehumanizing workflows, but these mirror past transitions like moving from assembly to compilers.
- Strategies to improve AI workflows include minimizing interruptions, climbing the abstraction hierarchy, and using hooks to automate repetitive tasks.
- Building confidence in AI-generated code involves self-review, testing, grilling the AI for potential issues, simplifying code, and managing technical debt.
- Transitioning from Python to Rust and TypeScript is recommended for computational and frontend development, leveraging AI's capabilities.
- Clear documentation and thoughtful planning are crucial for successful AI-assisted development, with directories like 'plans/' and 'docs/' to organize work.
- The role of engineers is shifting towards higher-level thinking and design, with implementation becoming more automated.
- AI-assisted development is seen as an evolution in programming, similar to past shifts like compilers, offering more fun and productivity.
Design duality and the expression problem (2018)
4 months ago
- The fundamental trade-off in abstraction design is power vs properties, with a common human bias towards power despite properties often being more important.
- Design context is crucial, especially distinguishing between system boundaries where external users can't be broken and internal contexts where mistakes can be fixed later.
- Programming languages often fail to distinctly embrace both objects and data, leading to design limitations.
- The 'expression problem' highlights the challenge of extensibility in both representations (objects/data) and operations, with trade-offs in reasoning and organization.
- Three fundamental design choices for types: Data (extensible functions), Objects (extensible implementations), and Abstract Data Types (no user extensibility but future-proof for authors).
- Real-world programming requires navigating language limitations to choose the most appropriate design, sometimes compromising ideal solutions for practicality.
C# wins Tiobe Programming Language of the Year honors for 2025
4 months ago
- C# won the Tiobe Index Programming Language of the Year for 2025, marking its second win in three years.
- C# saw the largest year-over-year increase in ranking, rising 2.94 percentage points to a 7.39% rating.
- TypeScript is predicted to break into the top 20 due to its growing use in front-end development and type-safety advantages.
- Java remains a strong contender in the business software market, ranking third behind Python and C.
- Go and Ruby have declined in popularity, while Perl and R have seen surprising comebacks.
- C and C++ swapped positions in the index, with C now ranked second and C++ fourth.
- Tiobe's index is based on skilled engineers, courses, and third-party vendors, using data from major websites like Google and Wikipedia.
- The Pypl index, which measures tutorial searches on Google, also ranks Python as the most popular language.
Pulling a New Proof from Knuth's Fixed-Point Printer
4 months ago
- Donald Knuth's 1989 paper 'A Simple Program Whose Proof Isn’t' discusses converting 16-bit fixed-point binary fractions to decimal fractions.
- The post presents a new proof for Knuth's program P2, starting with a simpler program and transforming it step-by-step into P2.
- The problem involves finding the shortest accurate, correctly rounded decimal for a given 16-bit binary fraction.
- The post explores alternative solutions, including a simpler iterative program and a direct solution inspired by the Schubfach algorithm.
- A historical perspective is provided, linking Knuth's problem to earlier work by D. Taranto and later by Steele and White.
- The conclusion reflects on how programming tools influence program design and proof complexity, advocating for simpler proofs with modern tools.
Moving Scratch generation to Python on browser
4 months ago
- EktuPy is a tool designed to transition kids from Scratch to Python programming.
- Features a split interface with a code editor on the left and a Canvas/stage on the right.
- Built using PyScript, with support from Ruff and ty for LSP/linting in the editor.
- Runs entirely in the user's browser using webassembly.
- Includes tutorials for each example in the editor to help beginners start without reading documentation.
- Allows users to create accounts, save programs, and share them publicly for others to explore or remix.
- Implements synchronous calls like wait() or ask() for simplicity, with async/await handled automatically via AST transformation.
- Encourages community involvement for improvements, with plans to open-source the Django-based project.
Linkers and Loaders
4 months ago
- Linkers & Loaders by John R. Levine, published in 1999, remains relevant but shows its age.
- The book covers the history and basics of linking and relocation, dating back to the 1940s.
- It provides an overview of application binary interfaces (ABIs) and examines IBM S/360, Sun SPARC, and Intel 386 architectures.
- Various object formats are presented, from simple DOS COM files to complex OMF files.
- The operation of a linker is explained in detail, covering storage allocation, symbol management, libraries, and relocation.
- Advanced topics include loading, shared libraries, dynamic linking, and C++ linker techniques.
- The book is well-structured, logically progressing from basic to advanced linking techniques.
- It avoids specific product references, focusing instead on the principles and history of linkers and loaders.
- The book is valuable for veteran programmers, covering UNIX, Windows, and IBM S/360 platforms.
- An updated edition would need to include AMD64 architecture and OS X object formats.
Climbing the mountain: or, venturing into PL theory
4 months ago
- The author reflects on their journey into programming, starting with Linux and Python, moving to web development, and now freelance technical writing.
- They express a renewed interest in complex topics, specifically Rust and programming language theory, due to their intriguing features and implementation challenges.
- Rust stands out for its memory management, pattern matching, error-handling, and data structures, making programming concepts more understandable.
- The author is curious about how programming languages are implemented, including compiler operations and IDE diagnostics, areas they find fascinating but complex.
- Despite being self-taught with limited traditional CS knowledge, they are both fascinated and intimidated by CS theory, especially PL theory and compilers.
- To tackle these challenging topics, the author plans monthly with abstract and concrete goals, emphasizing measurable achievements like reading specific chapters or creating projects.
- They highlight the importance of a growth mindset, leveraging the abundance of learning resources available today to explore new and complex areas confidently.
- The post aims to inspire others in high-level programming to venture into more challenging CS topics, sharing strategies for learning and personal growth.
Old-school programming techniques you probably don't miss (2009)
4 months ago
- Sorting algorithms and other hand-coded fiddly stuff are no longer necessary as modern tools handle them automatically.
- Creating graphical user interfaces (GUIs) has become easier with drag-and-drop components in IDEs, eliminating the need for manual coding.
- The use of 'Go To' statements and spaghetti code has been replaced by structured and object-oriented programming methodologies.
- Manual multithreading and multitasking are now streamlined by development tools and operating systems, unlike the complex hacks required in early PC operating systems.
- Self-modifying code, a technique used to save memory in the 1960s, is now obsolete due to advancements in memory capacity and programming practices.
- Memory management, including garbage collection, is now handled automatically by development environments, reducing the risk of memory leaks.
- Punch cards and early development environments like non-WYSIWYG editors and eight-character file name limits are relics of the past.
- Pointer math and date conversions, once manually coded, are now managed by built-in libraries and functions.
- Hungarian notation and other language-specific naming conventions are largely unnecessary with modern text editors that indicate variable types.
- Relying on undocumented features and manual optimizations has decreased as programming environments have become more standardized and documented.
- The patience required for long compile and debug cycles has diminished with faster hardware and more efficient development tools.
The Insecure Evangelism of LLM Maximalists
4 months ago
- The author is skeptical about LLM productivity, finding them useful only for limited tasks like searching the web and simple coding.
- Prompt-driven development or 'vibe coding' with Agentic LLMs was disappointing, requiring excessive supervision and often producing incorrect results.
- The author acknowledges that LLMs enable non-experienced developers to create things they couldn't otherwise, sometimes leading to paid cleanup work.
- Vocal proponents of LLMs claim it's the future and criticize skeptics as resistant to change due to fear of irrelevance.
- The author finds this baffling, as they like the idea of agentic coding but are disappointed by its current implementation.
- The author speculates that LLM evangelists' insistence and hostility stem from their own insecurity about their programming skills.
- The author remains open to changing their mind but questions whether LLM evangelists might not be as skilled at programming as they think.

first prev32next

About|Login

#programming

Beating myself at chess

Odin Programming Language

Maybe Comments _Should_ Explain 'What'

Was It Really a Billion Dollar Mistake?

A Visual Roadmap of C#

I program without syntax highlighting

Why German Strings Are Everywhere?

Perlsecret – Perl secret operators and constants

An Honest Review of Go

Why AI is pushing developers toward typed languages

What Happened to WebAssembly

AI Zealotry

Design duality and the expression problem (2018)

C# wins Tiobe Programming Language of the Year honors for 2025

Pulling a New Proof from Knuth's Fixed-Point Printer

Moving Scratch generation to Python on browser

Linkers and Loaders

Climbing the mountain: or, venturing into PL theory

Old-school programming techniques you probably don't miss (2009)

The Insecure Evangelism of LLM Maximalists