Hasty Briefsbeta

All tags

#programming

778 stories total

Bilingual

Parsing Chemistry
6 months ago
- The chemparse project in Python parses chemical formula strings into dictionaries mapping elements to counts.
- Supported formula variants include simple formulas, fractional stoichiometry, groups, nested groups, and square brackets.
- A similar functionality is built in Factor using EBNF syntax for parsing expression grammar.
- Steps include parsing symbols, numbers, and pairs (symbols with optional numbers).
- The implementation involves flattening parsed elements into an associative array mapping elements to counts.
- Unit tests demonstrate support for various formula features like H2O, C1.5O3, (CH3)2, ((CH3)2)3, and K4[Fe(SCN)6].
- The code is available on GitHub.
Actor Programming Language
6 months ago
- Actor is an object-oriented programming language and environment similar to Smalltalk.
- It was developed by The Whitewater Group, Inc. and later Genesis Development Systems.
- Actor is a completely Windows-native environment and was among the early applications written for Windows.
- Actor 2 ran under Microsoft Windows 2, and Actor 1.0 runs under Windows 1.
- Actor Professional 4.0 is for Windows 3.0, and Actor Professional 4.1 is for Windows 3.1.
- Download details include versions 4.01 (1992) and 4.1 (1993) with file sizes of 4.64MB and 7.14MB respectively.
You Should Write An Agent
6 months ago
- Some concepts, like boiling water, are easy to understand in the abstract, while others, like riding a bicycle, require hands-on experience.
- LLM agents are a big idea in computing, and whether you love or hate them, you should understand them to form an informed opinion.
- Building an LLM agent is surprisingly easy, as demonstrated by a simple Python script that interacts with the OpenAI API.
- LLM agents can be enhanced with tools, such as a ping function, allowing them to perform more complex tasks autonomously.
- Context engineering is a real and important aspect of working with LLM agents, as managing the context window is crucial for performance.
- LLM agents can be designed with sub-agents, each with different tools and contexts, enabling more sophisticated interactions.
- The field of LLM agents is still evolving, with many open engineering problems, such as balancing unpredictability and structured programming.
- Building your own LLM agent can provide valuable insights and allow for customization, rather than relying on pre-built solutions like Claude Code or Cursor.
Comparison Traits – Understanding Equality and Ordering in Rust
6 months ago
- Rust's comparison traits include PartialEq, Eq, PartialOrd, and Ord, which model equality and ordering.
- PartialEq and PartialOrd allow for incomparable cases (e.g., floats with NaN), while Eq and Ord require total order and equivalence.
- Ord implies Eq and provides a blanket PartialOrd, and Eq implies PartialEq.
- Floats cannot implement Eq or Ord due to NaN violating reflexivity and totality.
- Deriving PartialEq, Eq, PartialOrd, and Ord is useful for generating law-abiding implementations.
- Comparisons are used in operators, sorting, and collections like BTreeMap and HashMap.
- Performance considerations include preferring small, fixed-size keys and optimizing field order in derived Ord.
- Custom types may require manual implementation of comparison traits to match domain-specific semantics.
- Floats require special handling, such as using total_cmp for deterministic sorting.
- Understanding partial vs. total comparisons is crucial for robust and idiomatic Rust code.
Myna: Monospace typeface designed for symbol-heavy programming languages
6 months ago
- Myna is a monospace font designed to treat symbols as first-class glyphs, ensuring harmony in editors.
- Features include Symbol-First Design, Near-Perfect Alignment, Balanced Weight, Minimalist Forms, and Clear Distinction.
- Designed for programming with clean sigils for Perl, elegant operators for Haskell, and clear symbols for C.
- Current release is a single weight without ligatures, with potential for future feature expansions.
- Installation instructions provided for Linux and macOS.
- Licensed under SIL Open Font License, Version 1.1.
- Encourages community contributions for bug reports and feature requests.
Why is Zig so Cool?
6 months ago
- Zig is described as a revolutionary programming language, offering a new way to write programs beyond just replacing C or C++.
- The Zig compiler's ability to compile C code and cross-compile for different architectures is highlighted as a unique and impactful feature.
- Installation of the Zig compiler is straightforward, with detailed steps provided for Windows, including setting environment variables.
- Zig's variable declaration syntax is explained, emphasizing type inference and the use of `pub` for accessibility.
- The article introduces Zig's anonymous struct literals and struct declarations, showcasing their use in initializing structures.
- Bitfields and pointers in Zig are discussed, with examples showing how to declare and manipulate them.
- Zig's array initialization and manipulation are covered, including the use of loops and pointer arithmetic.
- The article explains how Zig can execute code at compile time, using examples like array initialization with labelled breaks.
- Functions in Zig are static by default, with `pub` making them accessible outside their file. The concept of inlining functions is introduced.
- Structs can have functions in Zig, with examples provided for implementing a stack, including constructor and method definitions.
- Building executable programs in Zig requires a `main` function, with commands provided for compilation.
- Zig's test blocks allow for independent testing of modules without needing an executable, showcasing a practical example.
- Debugging in Zig is simplified with `@breakpoint()`, allowing for variable inspection without bloating the executable with debug symbols.
- Low-level programming features in Zig are explored, including bit manipulation for Sudoku grid validation and error handling.
- The article concludes by emphasizing Zig's robustness, performance, and unique features like compile-time execution, comparing it favorably to interpreted languages.
Make yourself a Voxel Engine THIS weekend
6 months ago
- Introduction to creating a voxel engine from scratch.
- Requirements: Own programming language and rendering API.
- Starting with rendering a single cube and expanding to a voxel world.
- Optimizing performance by using meshes and chunks.
- Implementing world generation with flat terrain.
- Adding voxel types (Dirt, Stone) for variety.
- Optimizing mesh generation by only drawing visible faces.
- Adding interactivity with raycasting for block placement and removal.
- Implementing AABB collision for player movement.
- Replacing HashMap with a 3D array for voxel storage for better performance.
- Challenges for further development: gravity, procedural terrain, save/loading, etc.
C++ move semantics from scratch (2022)
6 months ago
- Move semantics in C++ are introduced to solve inefficiencies in copying large data structures by enabling 'stealing' data from one object to another.
- Rvalue references (&&) are introduced in C++11 to distinguish between objects that can be moved from (temporary or about to be destroyed) and those that cannot (lvalue references).
- The std::move function is a utility that casts an object to an rvalue reference, signaling that it can be moved from, but it doesn't perform the move itself.
- Move semantics are convention-based; the language encourages moving from rvalue references and copying from lvalue references, but this is not enforced by the compiler.
- Use-after-move is a common pitfall in C++ where an object is used after its resources have been moved, leading to undefined behavior.
- Alternatives to C++ move semantics include C's explicit move functions and Rust's move-by-default with explicit copies, which offer different trade-offs in safety and complexity.
Syntax and Semantics of Programming Languages
6 months ago
- The text lists chapters and appendices of a book titled 'Syntax and Semantics of Programming Languages'.
- It includes chapters 1 through 13, two appendices (A and B), and additional sections like Title Pages, Preface, Table of Contents, Bibliography, and Index.
- Mentions Acrobat (pdf) viewers and a link to Ken Slonneger's Home Page.
Forth – is it still relevant?
6 months ago
- Forth lost out to C due to broader appeal, standardization, and support ecosystem.
- Bill Muench created eForth for simplicity and educational purposes.
- Dictionary is modeled as an array of words for easier search and execution.
- Data and Return Stacks are implemented as arrays with push, pop, and indexing methods.
- No vocabulary or meta-compilation to focus on core concepts.
- Multi-threading and message passing introduced in version 5.0.
- Thread pool size defaults to the number of cores.
- Message passing uses pthread mutex for synchronization.
- Core implementation of eForth is in C/C++ for cross-platform support.
- Code objects represent Forth words with fields for name, execution token, and parameters.
- Polymorphic classes extend Code for literals, variables, strings, and branching.
- Inner interpreter executes words recursively or via lambda functions.
- Outer interpreter searches dictionary and handles compilation or execution.
- Array implementation differs from traditional Forth memory access.
- Dynamic arrays enable expanding variables and self-morphing code.
- Modern Forth implementations aim to be more accessible with fewer lines of code.
- Multi-threading support includes task creation, starting, joining, and message passing.
- Performance benchmarks compare different threading and memory models.
- Memory management considerations for C++ standard libraries on resource-constrained devices.
- Refactoring efforts focus on cross-platform compatibility and performance optimization.
Zig and the design choices within
6 months ago
- Zig is not memory safe and does not attempt to be, which is a significant drawback in modern programming languages.
- Statistics show that memory safety issues account for up to 70% of security bugs, highlighting the importance of memory safety.
- Zig's approach to generics is unconventional and lacks standardization, leading to potential readability issues.
- Zig's comptime feature is powerful but overly complex, with limited practical benefits over simpler alternatives.
- Casting in Zig is cumbersome, especially for float to int conversions, which can also invoke undefined behavior.
- Result location semantics in Zig have counterintuitive behaviors, particularly with struct member swaps.
- The Zig compiler is slower than Clang, though a new backend shows promise for improved performance.
- Zig's build system is confusing and lacks sufficient documentation, despite its innovative use of the language itself.
- Zig lacks a first-class language server, which limits its usability and adoption.
- Zig's community can be unwelcoming, with a tendency to dismiss concerns without proper consideration.
Writing a C Compiler, in Zig
6 months ago
- Series of articles written while creating paella, inspired by Nora Sandler's 'Writing a C Compiler'.
- Purpose was to learn Zig and procrastinate job searching during unemployment.
- No major edits made, only broken links fixed.
- Chapters cover various programming concepts from Unary to Linking.
- Future writeups may be added if the book project continues.
The joy of rediscovering Perl – Eskild Hustvedt
6 months ago
- The author rediscovered Perl programming and found it delightful.
- Perl was the author's first programming language, learned from 'Learning Perl' (3rd edition).
- Perl was chosen due to its use in Mandrake Linux, which the author contributed to.
- The author's first long-term programming job involved Perl.
- Over time, the author drifted towards other languages like JavaScript but still used Perl for scripts.
- Recent NPM issues made the author miss Perl's dependency management via distro package managers.
- The author decided to write a static site generator in Perl, finding it enjoyable.
- Perl's features like 'strict' mode and 'state' variables make coding safer and more convenient.
- Perl has evolved with new features like subroutine signatures and built-in try/catch.
- Perl is fast at both runtime and compile time, important for client-side programs.
- The author's Perl-based static site generator, BoringSSG, is progressing well.
- Perl has improved over the years while retaining its core strengths.
- The author recommends revisiting Perl or other past favorite languages for renewed coding joy.
Welcome, the entire land - "Hello, world!" in hieroglyphics
6 months ago
- Attended dConstruct web conference in Brighton, UK, and spent time with friends.
- Visited the Royal Pavilion, a British folly inspired by Indian architecture.
- Noticed an Egyptian exhibit titled 'The Egyptians' with accurate hieroglyph translation.
- Realized a friend could read ancient hieroglyphs, sparking an idea for a t-shirt.
- Proposed a 'Hello World' t-shirt in hieroglyphs, despite the lack of an 'L' glyph.
- Collaborated with Egyptologists to translate 'Hello World' into 'Welcome, the entire land'.
- Designed and printed the hieroglyphic phrase on a t-shirt as a unique geeky project.
- Shared the design publicly, encouraging others to use it freely.
Collapse OS – Why Forth?
6 months ago
- Collapse OS was initially written in Z80 assembler, but feedback suggested Forth as an alternative.
- Forth aligns well with Collapse OS's design goals, particularly in terms of compactness and simplicity.
- Forth is not necessarily more expressive or faster than C, but it excels in compactness and high-level constructs.
- Forth's compactness allows Collapse OS to achieve self-hosting with minimal resources, similar to its Z80 assembler counterpart.
- Forth encourages simplicity and minimalism, which helps in managing complexity and reducing cognitive load.
- Reading Forth code can be challenging due to its high cognitive load, but writing it promotes simplicity and discipline.
- Forth's culture of simplicity and constraints contrasts with modern trends of increasing complexity in technology.
- Forth's expressiveness can rival or surpass C, especially with compile-time tooling, without significant runtime costs.
- The author's perspective on Forth evolved over time, appreciating its strengths in expressiveness and simplicity.
.NET 10
6 months ago
- .NET 10 is launched as the most productive, modern, secure, intelligent, and performant release yet.
- It is a Long Term Support (LTS) release with support until November 10, 2028.
- Key improvements include JIT compiler enhancements, hardware acceleration, and runtime optimizations.
- C# 14 introduces features like field-backed properties, extension properties, and first-class Span<T> conversions.
- F# 10 focuses on clarity, consistency, and performance with language improvements and core library updates.
- .NET 10 libraries enhance security with post-quantum cryptography and improve networking with WebSocketStream.
- Aspire 13 simplifies building observable, production-ready distributed apps with modern workflows.
- AI capabilities are expanded with the Microsoft Agent Framework, AI building blocks, and Model Context Protocol (MCP).
- ASP.NET Core improvements include automatic memory pool eviction, passkey support, and enhanced Blazor state management.
- Entity Framework Core 10 introduces vector search, enhanced JSON support, and complex type handling.
- Windows development is enhanced with WinUI 3, WPF, and WinForms improvements.
- Visual Studio 2026 integrates AI-powered development tools, debugging enhancements, and modern UI updates.
- GitHub Copilot and C# Dev Kit for VS Code provide AI-assisted coding and streamlined development experiences.
- The .NET 10 SDK includes CLI enhancements, SLNX solution format, and NuGet security improvements.
Nimony v0.2 – early preview of Nim 3.0's compiler
6 months ago
- Nimony v0.2 is an early preview compiler for a Nim variant aimed at becoming Nim 3.0.
- Focuses on Aufbruch mode: destructor-based memory management (ARC), value-centric semantics, predictable code generation, and plugin-based metaprogramming.
- Supports basic programs with a working core, targeting developers interested in testing fundamentals.
- Example program: a Tic-Tac-Toe game with AI in 250 lines using raylib for graphics.
- Several standard library modules ported, providing a well-rounded set of functionality.
- Many language features work, including methods and dynamic polymorphism, with quick bug fixes.
- Common issue: type resolution errors, though not blocking program development.
- Missing case-insensitive identifiers, noted due to odd AST node kind capitalization.
- AI chatbots (e.g., GPT5-high) used to understand current capabilities and guide testing.
- Templates and complex constants may not work, but plugins offer a solid alternative.
- Encourages community involvement: testing, bug reports, questions, PRs, and contributions via Open Collective.
Creating minimal music with code in any programming language
6 months ago
- The article demonstrates how to create minimal music with code using a simple C program that plays melodies from text notation.
- Digital sound is explained as an array of bytes representing sampled sound wave amplitudes, with discussions on sample rates and amplitude quantization.
- Different oscillator waveforms (sawtooth, square, sine) are introduced and implemented in C to produce musical notes.
- A method to simulate string sounds using random data arrays and smoothing is described.
- Step sequencers are used to play melodies by changing note pitches over time, with an example riff provided.
- The article includes a deobfuscated version of the initial C melody player, explaining its functionality.
- Bytebeat, a niche music genre using terse C expressions, is introduced with an example.
- Simple sound effects like low-pass filters and delay lines are demonstrated to enhance audio output.
- The article concludes with hints at future topics like 1-bit sound and invites reader contributions.
Just call clone (or alias)
6 months ago
- Proposal introduces 'just call clone (or alias)' to simplify Rust's ergonomic ref-counting.
- Compiler will remove redundant clone/alias calls and automatically capture them in move closures.
- Aims to simplify the mental model for fixing 'use of moved value' errors by standardizing on clone/alias calls.
- Introduces 'last-use transformation' to optimize away unnecessary clones/aliases, replacing them with moves where possible.
- Designed to be a zero-cost abstraction, ensuring no performance penalty for unused features and optimal performance for used ones.
- Addresses concerns around explicit capture clauses and the subtlety of when aliases are created in closures/futures.
- Includes a detailed FAQ covering potential edge cases, execution order subtleties, and the impact on destructor timing.
- Proposal emphasizes the balance between low-level control and ergonomic usability, targeting both new and experienced Rust users.
Learn Prolog Now
6 months ago
- Learn Prolog Now! is an introductory course to Prolog programming, available online since 2001 and now in a revised book form.
- The course aims to be self-contained and clear, suitable for beginners and self-study, with exercises to help learn Prolog basics.
- Emphasizes practical aspects of Prolog, recommending the use of a Prolog interpreter and completing Practical Sessions for better learning.
- Encourages active programming beyond the course materials to improve skills.
- Invites feedback from users, whether they are self-learning or teaching others, for future improvements.

first prev24next

About|Login

#programming

Parsing Chemistry

Actor Programming Language

You Should Write An Agent

Comparison Traits – Understanding Equality and Ordering in Rust

Myna: Monospace typeface designed for symbol-heavy programming languages

Why is Zig so Cool?

Make yourself a Voxel Engine THIS weekend

C++ move semantics from scratch (2022)

Syntax and Semantics of Programming Languages

Forth – is it still relevant?

Zig and the design choices within

Writing a C Compiler, in Zig

The joy of rediscovering Perl – Eskild Hustvedt

Welcome, the entire land - "Hello, world!" in hieroglyphics

Collapse OS – Why Forth?

.NET 10

Nimony v0.2 – early preview of Nim 3.0's compiler

Creating minimal music with code in any programming language

Just call clone (or alias)

Learn Prolog Now