Hasty Briefs - Daily Tech News Brief

Bilingual

Rust 1.87.0 and ten years of Rust
a year ago
- Rust 1.87.0 released on the 10-year anniversary of Rust 1.0.
- New features include anonymous pipes in the standard library and safe architecture intrinsics.
- Inline assembly (asm!) can now jump to labeled blocks within Rust code.
- Precise capturing in trait definitions using `impl Trait` return types is now stabilized.
- Several APIs have been stabilized, including `Vec::extract_if` and `String::extend_from_within`.
- The Tier 2 target `i586-pc-windows-msvc` has been removed.
- Users can update to Rust 1.87.0 via `rustup update stable`.
- Contributors are thanked for their work on Rust.
Initialization in C++ is bonkers (2017)
a year ago
- C++ initialization rules are complex and can lead to undefined behavior if not handled carefully.
- Three main types of initialization in C++: default-, value-, and zero-initialization, each with specific rules.
- Default-initialization calls the default constructor for classes, leaves scalar types uninitialized (indeterminate values).
- Value-initialization may involve zero-initialization first, especially for classes with non-user-provided default constructors.
- Zero-initialization sets scalar types to 0, class members to zero, and is applied to static/thread-local variables before other initializations.
- User-provided constructors affect initialization behavior; defaulting a constructor at declaration vs. definition changes its classification.
- Value-initialization of a class with a non-user-provided default constructor includes zero-initialization, ensuring members start as 0.
- Reading uninitialized variables is undefined behavior, emphasizing the importance of explicit initialization.
- C++ offers 18 forms of initialization, highlighting the language's complexity in this area.
- Best practice: always initialize variables to avoid undefined behavior and ensure predictable program execution.
The Teal Programming Language
a year ago
- Teal is a statically-typed dialect of Lua, adding type annotations for arrays, maps, records, interfaces, union types, and generics.
- It aims to be like TypeScript for Lua, maintaining Lua's minimalism, portability, and embeddability.
- Teal code is compiled into Lua using the `tl` compiler, which can be installed via LuaRocks (`luarocks install tl`).
- Pre-compiled binaries are available for Linux and Windows.
- For larger projects, Cyan is the recommended build tool for Teal.
- Development tools include vscode-teal for VS Code and teal-language-server for NeoVim.
- Teal has online documentation, recorded talks, and community forums (GitHub Discussions and Matrix chat).
- Teal is developed by Hisham Muhammad and contributors, written in Teal itself, and is MIT-licensed.
Crust – Rust that is Fun
a year ago
- Every function is unsafe.
- No references, only pointers.
- No cargo, build with rustc directly.
- No std, but libc is allowed.
- Only Edition 2021.
- All user structs and enums #[derive(Clone, Copy)].
- Everything is pub by default.
- The list of rules may change.
- Goal is to make programming in Rust fun.
- Currently used in the B Compiler Project.
Rust Life Improvement
a year ago
- Rust's Beta Channel offers performance improvements and benefits from more testers.
- Cargo provides shortcuts and configuration options for efficient Rust development.
- Clippy lints improve code quality by enforcing documentation and safe practices.
- Cargo-semver-checks ensures library compatibility before releases.
- Doctests are now fast, encouraging their use for documentation and testing.
- Insta enables snapshot testing with features for handling indeterminism.
- Mutation testing with cargo-mutants identifies untested code changes.
- rust-analyzer settings enhance the development experience.
- cargo sweep helps manage build artifacts to save disk space.
- Pattern matching in Rust is powerful, supporting destructuring and guards.
- Annotations like #[expect] and #[must_use] improve code maintainability.
- Box::leak can create static references for certain use cases.
Rust Turns 10
a year ago
- Rust celebrates its 10th anniversary since the 1.0 release.
- Amazon extensively uses Rust in AWS services and PrimeVideo.
- Rust is being adopted in surprising places, like Netherlands election software.
- Graydon Hoare, Rust's founder, set the vision and culture for the language.
- Rust's Code of Conduct emphasizes inclusivity, kindness, and recognizing trade-offs.
- Open-source collaboration has been crucial to Rust's evolution.
- The ACM SIGPLAN Software Award highlighted Rust's community-driven success.
- Rust's ability to evolve while maintaining stability is a key strength.
- Engaging with users reminds the team of Rust's impact and potential.
- Rust aims to empower developers to build foundational software without fear.
Vibe Check: Codex – OpenAI's New Coding Agent
a year ago
- OpenAI launched Codex, a new coding agent designed to function like a senior software engineer, capable of building features and fixing bugs autonomously.
- Codex is optimized for senior engineers, producing clean, minimal code and concise summaries, and is trained on large, messy codebases to improve real-world applicability.
- The tool encourages a workflow where users can manage multiple small, self-contained tasks simultaneously, turning them into easy-to-review pull requests.
- Codex differs from chat-based AI tools like ChatGPT, focusing on task completion rather than interactive dialogue, making it less flexible for follow-up requests.
- Despite its strengths, Codex lacks integrations with platforms like GitHub and Slack, adding friction to the workflow, and is not ideal for less experienced engineers or those who prefer interactive coding.
- OpenAI seems to be approaching programming from two angles: tight collaboration (via Windsurf) and autonomous delegation (via Codex), suggesting future flexibility in tool usage.
- Initial testing at Every showed Codex is useful for senior engineers managing existing codebases but less so for those working on new projects or preferring a more interactive approach.
Beej's Guide to Network Concepts
a year ago
- Brian 'Beej Jorgensen' Hall is the author.
- Document version is v1.0.32, last updated on May 6, 2025.
- Mentions Content-Type and Content-Length.
- Lists files: file1.txt and file2.html.
- References functions: get_next_word_packet() and extract_word().
- File extensions mentioned: .txt and .dat.
- References select() and send() functions.
- Mentions 'chatui' and the number '1'.
- CTRL-C is referenced.
What Every Programmer Should Know About Enumerative Combinatorics
a year ago
- Enumerative combinatorics is a branch of mathematics focused on counting elements of a set, useful for problems like determining unique user IDs in databases.
- Integer partitions represent ways to write an integer as a sum of positive integers, while integer compositions are ordered partitions.
- Closed-form formulas exist for counting integer compositions, but not for partitions, making compositions more tractable for exact counting.
- Weak compositions allow parts to be zero, and their count can be determined using binomial coefficients.
- C code is provided to generate and enumerate weak integer compositions, demonstrating practical implementation.
- Observations on enumerated sets reveal patterns in columns, such as strictly decreasing sequences and mirrored relationships between columns.
- The Hockey Stick Identity from combinatorics is useful for counting digits in columns of weak compositions.
- Binary search algorithms can efficiently index and retrieve specific weak compositions from an enumerated set.
Programming in Martin-Lof's Type Theory: An Introduction (1990)
a year ago
- The book 'Programming in Martin-Löf's Type Theory: An Introduction' is authored by Bengt Nordström, Kent Petersson, and Jan M. Smith.
- It was published by Oxford University Press in 1990 and is currently out of print.
- The book is available in Postscript and PDF formats from the Department of Computing Sciences, University of Göteborg / Chalmers.
- The Postscript version is 1.5 Mb and the PDF version is 1 Mb in size.
- The table of contents is also available in Postscript format.
Push Ifs Up and Fors Down
a year ago
- Push Ifs Up: Move conditional checks (ifs) to the caller to centralize control flow, reduce redundant checks, and simplify functions.
- Benefits of Pushing Ifs Up: Fewer overall checks, easier identification of dead branches, and centralized complex logic in one place.
- Dissolving Enum Refactor: A pattern where pulling up conditions reveals redundant or triplicated logic.
- Push Fors Down: Operate on batches of objects for performance gains, amortizing startup costs, and enabling vectorized processing.
- Performance Benefits: Batch processing can significantly improve performance, especially in hot paths handling many entities.
- Expressiveness: Batch operations can also enhance code expressiveness, as seen in libraries like jQuery.
- Composition: Combining 'push ifs up' and 'push fors down' can optimize both control flow and data processing.
- Example: FFT-based polynomial multiplication shows how batch processing can outperform individual evaluations.
- TigerBeetle Architecture: Uses batch processing in the data plane to amortize decision-making costs in the control plane.
OBNC – Oberon-07 Compiler
a year ago
- OBNC is a compiler for Oberon, translating Oberon code to C.
- It supports the final 2016 version of Oberon.
- The compiler is under GNU GPL, while libraries are under Mozilla Public License.
- Includes basic and extended libraries for additional functionalities.
- Requires POSIX OS and Boehm-Demers-Weiser GC for building.
- Pre-compiled versions available for MS Windows with dependencies included.
- Incompatibility note: Modules compiled with OBNC ≤0.15 need recompilation.
- Offers Gedit/Pluma plugins for syntax highlighting and uppercase conversion of keywords.
- Support via email, Stack Overflow, ETHZ mailing list, or Usenet newsgroup.
Racket – the Language-Oriented Programming Language – 8.17 is now available
a year ago
- Racket v8.17 introduces the new `drracket-core` package with fewer dependencies.
- Typed Racket now supports treelists.
- Package manager computes checksums for packages, enabling automatic upgrades.
- New `bitwise-first-bit-set` function returns the smallest set bit in a number.
- Updated `dynamic-require` function simplifies syntax bindings usage.
- Customizable module-path display in error messages via `error-module-path->string-handler`.
- Improved precision for numeric functions (`sin`, `cos`, etc.) on Windows using MSVCRT/UCRT libraries.
- Enhanced performance and reduced memory usage for `string-append` in Racket CS.
- TCP ports use `SO_KEEPALIVE` for connection responsiveness checks.
- Windows terminal now supports mouse events as virtual terminal characters.
- New `#:replace-malformed-surrogate?` keyword for handling malformed Unicode surrogates in JSON.
- http-client module no longer sends "Content-Length: 0" for body-less requests.
- Demodularizer (`compiler/demod`) can prune more unused assignments.
- Redex replaces judgment rendering forms with functions for better abstraction.
- DrRacket's language-dialog moves to preferences if no teaching languages are included.
- Math library improvements for block-diagonal matrices, `acos`, and `matrix-(cos-)angle`.
- Stepper functionality restored for `big-bang` programs.
- Numerous other repairs and documentation improvements.
FreeBASIC is a free/open source BASIC compiler for Windows DOS and Linux
a year ago
- FreeBASIC is a free/open source (GPL) BASIC compiler for Windows, DOS, and Linux.
- It offers high compatibility with QuickBASIC programs in 'QB' language mode.
- FreeBASIC supports procedural, object-oriented, and meta-programming paradigms.
- It can produce console, GUI executables, and libraries, with C and partial C++ support.
- The compiler is self-hosting and uses GNU binutils as backends.
- FreeBASIC includes thin bindings to popular libraries like OpenGL, SDL, and Windows API.
- Originally aimed to be a free alternative to QuickBASIC, it has evolved into a powerful tool.
- Supports modern platforms and APIs, extending QuickBASIC's capabilities.
Fortran for C Programmers
a year ago
- Fortran is designed for C/C++ programmers to quickly adapt, focusing on essential features and avoiding common pitfalls.
- Fortran standards have evolved through versions like '66, '77, '90, '95, 2003, 2008, and 2018, emphasizing forward compatibility.
- Fortran supports two source forms: fixed-form (.f) and free-form (.f90), with no reserved words and case insensitivity.
- Variables starting with I-N are implicitly INTEGER; others are REAL, but these rules can be modified.
- Arrays must be declared explicitly; parentheses denote both array references and function calls.
- Fortran includes many intrinsic functions, available without declaration, with names reflecting implicit typing rules.
- Modern Fortran uses modules for declaring types, data, and subprogram interfaces, alongside legacy mechanisms.
- Key Fortran terms include 'Association', 'Derived type' (similar to C++ class), and 'Generic' (overloaded function).
- Built-in data types: INTEGER, REAL, COMPLEX, LOGICAL, CHARACTER, with 'kind' parameters for non-portable byte sizes.
- User-defined types can be created, similar to C structs, with inheritance, destructors, and default initial values.
- Arrays in Fortran are multidimensional, with rank indicating dimensions, stored with the last subscript having the largest stride.
- ALLOCATABLE data is dynamically allocated, automatically deallocated when out of scope, similar to C++ std::vector.
- I/O is built into Fortran syntax, with formatted and unformatted options, and uses unit numbers similar to UNIX file descriptors.
- Fortran has FUNCTION and SUBROUTINE subprograms, with one level of nesting and internal procedures referencing host names.
- Modules support separate compilation and namespace management, with USE statements for accessing module objects.
- Argument passing is by reference, with INTENT(IN) for read-only arguments, and VALUE for pass-by-value.
- Overloading is supported via named interfaces, allowing generic names for subprograms based on argument types.
- Polymorphism is possible with CLASS, deferring actual types to runtime, similar to C++ virtual functions.
- Pointers in Fortran are objects, not types, implicitly dereferenced, and cannot point to other pointers or allocatable metadata.
- Preprocessing is implementation-dependent, often using C preprocessors, with varying support across compilers.
- Type-bound procedures provide an analog to C++ member functions, with the object passed as an additional argument.
- Pitfalls include static initializers for variables, statement functions, and differences in expression evaluation compared to C.
Static Types Are for Perfectionists
a year ago
- The author reflects on how childhood experiences shape technological preferences, arguing that upbringing and culture influence core beliefs about technology more than rational arguments.
- Key childhood traits include a fear of mistakes and counterdependence, leading to preferences for statically typed languages, deep system understanding, and minimal dependencies.
- The author's programming style evolved over time, moving from rigid conventions to a more authentic approach guided by personal aesthetics and feelings.
- The concept of 'authenticity spiral' is introduced, describing stages of mastery from learning fundamentals to transcending forms and achieving natural performance.
- Two implications are highlighted: the need to accept others' preferences without judgment and the importance of finding an environment that aligns with one's style for productivity and happiness.
- The author emphasizes that the right environment fosters growth and satisfaction, contrasting personal experiences at different companies to illustrate this point.
- The article concludes with a call for research on the intersection of psychology and computer science to explore how childhood experiences and neurodiversity affect technology preferences.
Every programming language has its 'killer' domain
a year ago
- Every programming language has a 'killer' domain where it excels.
- Statically typed languages like C, C++, Rust, Java, C#, Cobol, Go, and Swift have specific domains such as kernels, low-level systems programming, business applications, high-performance servers, and apps for Apple systems.
- Dynamically typed languages like Python, Julia, Fortran, Matlab, JavaScript, TypeScript, Ruby, PHP, Lua, and R dominate domains such as scientific computing, machine learning, web development, and statistics.
- Using a language outside its killer domain is often harder and sometimes infeasible.
Craft Basic (Windows 95 and up)
a year ago
- Craft Basic is a freeware version 1.7.1, last updated on 12/19/2023.
- The download size is 269kB, available via two URLs.
- Documentation is accessible through a provided link.
- Support is available through a dedicated forum.
- System requirements include Windows 95, with support for Win9X, Win2K, WinXP, Win10, and Win11.
Squirrel (Programming Language)
a year ago
- Squirrel is a high-level, imperative, object-oriented programming language designed for lightweight scripting in applications like video games.
- It features dynamic typing, delegation, classes, inheritance, higher-order functions, generators, coroutines, tail recursion, exception handling, and automatic memory management.
- Squirrel uses a C-like syntax and is influenced by languages like C++, JavaScript, Lua, and Python.
- It is used in various games and applications, including Left 4 Dead 2, Portal 2, Code::Blocks, and Electric Imp.
- The language was made public in 2003 under the zlib/libpng license and later switched to the MIT license in 2010.
- Squirrel is developed and maintained by Alberto Demichelis.
What Is the Difference Between a Block, a Proc, and a Lambda in Ruby? (2013)
a year ago
- Blocks, procs, and lambdas in Ruby are ways to group code for execution.
- Blocks are part of method syntax and not standalone objects, while procs are instances of the Proc class and can be assigned to variables.
- Only one block can be passed to a method, but multiple procs can be passed.
- Lambdas are a type of proc that check the number of arguments passed to them, unlike regular procs.
- Lambdas and procs handle the 'return' keyword differently; lambdas return from themselves, while procs return from the enclosing method.
- Closures in Ruby, like procs and lambdas, retain access to variables from the context in which they were created.
- The term 'lambda' comes from lambda calculus, emphasizing anonymous functions, while 'proc' is short for procedure, indicating a set of instructions for a task.

Hasty Briefsbeta

#programming

Rust 1.87.0 and ten years of Rust

Initialization in C++ is bonkers (2017)

The Teal Programming Language

Crust – Rust that is Fun

Rust Life Improvement

Rust Turns 10

Vibe Check: Codex – OpenAI's New Coding Agent

Beej's Guide to Network Concepts

What Every Programmer Should Know About Enumerative Combinatorics

Programming in Martin-Lof's Type Theory: An Introduction (1990)

Push Ifs Up and Fors Down

OBNC – Oberon-07 Compiler

Racket – the Language-Oriented Programming Language – 8.17 is now available

FreeBASIC is a free/open source BASIC compiler for Windows DOS and Linux

Fortran for C Programmers

Static Types Are for Perfectionists

Every programming language has its 'killer' domain

Craft Basic (Windows 95 and up)

Squirrel (Programming Language)

What Is the Difference Between a Block, a Proc, and a Lambda in Ruby? (2013)