Hasty Briefsbeta

All tags

#programming

778 stories total

Bilingual

Zig language and toolchain packaged as a deb for Debian and Ubuntu amd64/ARM64
10 months ago
- Zig is a general-purpose programming language for robust, optimal, and reusable software.
- Debian packaging for Zig is available in this repository.
- Repository installation involves adding a source and key, then installing via apt.
- Direct installation involves downloading a .deb file and installing it.
- Available packages for Debian Unstable (Sid) include amd64 and arm64 versions.
- Packages are built using the Open Build Service.
A compact bitset implementation used in Ocarina of Time save files
10 months ago
- A no-frills, zero-overhead flag system inspired by The Legend of Zelda: Ocarina of Time.
- Implemented in C/C++ and Rust for efficient flag storage.
- Stores hundreds or thousands of one-bit flags in a save file without wasting bytes.
- Uses an array of uint16_t words for space efficiency (1 word = 16 flags).
- Header-only in C, tiny dependency in Rust; no heap or allocation required.
- Zero-cost abstractions with branch-free bit-twiddling for performance.
- Scalable from 1 to 4096 words (65,536 flags).
- Intuitive indexing for debugging (e.g., 0x12 maps to word 1, bit 2).
- Includes functions for setting, clearing, and checking flags.
- Works with C99 or later compilers and Rust via Cargo.
Crypto 101 – Introductory course on cryptography
10 months ago
- Crypto 101 is a free introductory course on cryptography for programmers of all skill levels.
- Covers essential cryptographic concepts like block ciphers, stream ciphers, hash functions, MACs, public key encryption, key agreement protocols, and signature algorithms.
- Teaches how to exploit cryptographic flaws using programming skills.
- Includes practical applications such as forging cookies, password recovery, and backdooring random number generators.
- Available in multiple DRM-free formats.
- Originated from a PyCon 2013 presentation and expanded into a book focusing on breaking cryptography.
The First Time I Was Almost Fired from Apple
10 months ago
- The author was hired by Apple in 1995 during a tumultuous period for the company.
- Initially working on QuickdrawGX, the author later transitioned to the ColorSync team due to project changes.
- Tasked with adapting the Color Picker for PowerPC chips, the author rewrote assembly code in C.
- The author created additional color pickers (HSV, HTML, crayon, CMYK) based on personal interest and market needs.
- An Easter egg involving T.S. Eliot's poetry almost got the author fired, highlighting a lack of corporate awareness.
- Despite the mishap, the author retained their job and became more cautious about corporate policies.
- The crayon color picker included playful Easter eggs, like worn-down crayons and anagrams of team members' names.
- The author reflects on their early professional missteps and the learning curve at Apple.
Ziglings: Learn Zig by fixing broken programs
10 months ago
- Ziglings is a series of broken programs designed to teach Zig programming by fixing them.
- The project is inspired by rustlings, Ruby Koans, and the Little LISPer/Schemer books.
- Intended for beginners with no prior systems programming experience.
- Each exercise is self-contained and explained, with additional resources recommended.
- Requires a development build of the Zig compiler (version 0.15.0-dev or higher).
- Clone the repository and run 'zig build' to start.
- Ziglings tracks development builds of Zig, not stable releases.
- Advanced usage includes running specific exercises, skipping checks, and debugging.
- Covers core Zig language features and some standard library functionalities.
- Contributions are welcome for improving explanations, exercises, and idiomatic usage.
Uncommon Uses of Python in Commonly Used Libraries (2022)
10 months ago
- Python's `super()` function is essential for cooperative multiple inheritance, especially in base classes.
- Mixin classes provide reusable functionality without state, ideal for optional features across multiple classes.
- Relative imports (using `.`) ensure Python searches the current package first, preventing module conflicts.
- Non-empty `__init__.py` files can simplify APIs, refactor code without breaking changes, and initialize package-wide resources.
- Class methods are used when needing class-level operations, while static methods serve as utility functions within a class's namespace.
- `conftest.py` in pytest not only provides fixtures but also helps in modifying `sys.path` for module recognition.
- Design principles in libraries like scikit-learn emphasize consistency and composition, while PyTorch focuses on pragmatic performance and simplicity.
Best Way to Advertise a Programming Language
10 months ago
- The best way to advertise a programming language is by writing useful programs that appeal to a wide audience.
- Common Lisp and Haskell, despite their merits, lack a significant number of widely-used programs, which affects their popularity.
- GitHub stars and project utility are key indicators of a language's practical adoption.
- Examples of notable Common Lisp projects include Nyxt (web browser) and pgloader (PostgreSQL migration tool).
- Haskell has projects like pandoc (markup converter) and ShellCheck (shell script analyzer), but many are niche tools or compilers.
- Python and Zig have more widely-used programs, demonstrating practical adoption beyond theoretical benefits.
- Shipping real software demonstrates a language's viability and can serve as effective evangelism.
- Language popularity is influenced by marketing, education, and institutional support, not just technical superiority.
Haxe 5.0 preview.1 has been officially released
10 months ago
- Haxe 5.0.0-preview.1 is officially released as a pre-release version.
- This version is not stable and has known issues, but testing is encouraged to aid the final Haxe 5 release.
- Users encountering version string errors should update or remove the older haxelib version.
- Several removals and breaking changes are noted, including moving sys.db, php.Web, and neko.Web to hx4compat lib.
- General improvements and bugfixes include enabling parallelism and resolving various technical issues.
# [derive(Clone)] Is Broken
10 months ago
- The code examples discuss Rust's `#[derive(Clone)]` and its overly restrictive requirements.
- The first example shows a `WrapArc<T>` struct that should compile but doesn't due to Rust's `Clone` derive requirements.
- The second example demonstrates a similar issue with `PartialEq` and `Eq` traits.
- The core problem is that Rust's built-in derive traits require all generic parameters to implement the trait, even when unused.
- Two solutions are proposed: a long-term RFC process or a quick custom macro approach.
- The author suggests implementing a less restrictive derive macro in the `derive_more` crate or creating a new crate.
Code and Trust: Vibrators to Pacemakers
10 months ago
- Comparison of vibrator and pacemaker control programs, highlighting their structural similarities despite different purposes.
- Discussion on the complexity and critical nature of pacemaker programming, including fault tolerance and regulatory standards (ISO 14971, IEC 62304, etc.).
- Exploration of trust in code authorship, contrasting individual programmers like djb with FDA-audited companies, and the potential role of AI in future programming.
- Concerns about AI's role in critical systems (e.g., pacemakers, car brakes) and the challenges of ensuring safety and trust in AI-generated code.
- Advocacy for radical transparency in code, specifications, and processes as a prerequisite for trust in AI-generated or audited systems.
Jank Programming Language
10 months ago
- jank is a general-purpose programming language and a dialect of Clojure.
- It embraces interactive, value-oriented development with native compilation via an LLVM-based JIT.
- jank maintains strong compatibility with Clojure, including its code-as-data philosophy and macro system.
- It offers functional-first programming with immutable data structures and supports mutability via STM and agents.
- jank allows seamless integration with C++ code within Clojure source files.
- It provides fast startup times, low memory usage, and supports both JIT and AOT compilation.
- jank features high-quality error reporting and supports Clojure JVM and ClojureScript compatibility.
- It includes powerful data manipulation capabilities, such as reduce, zipmap, and merge-with.
- jank supports imperative-style loops with the loop macro while remaining purely functional.
- Vars in jank allow dynamic redefinition, useful for testing and side-effect management.
A software conference that advocates for quality
10 months ago
- Casey Muratori will speak about programming history.
- Dennis Gustafsson will discuss parallelizing the physics engine.
- Bill Hall will talk about tools of the trade.
- Vjekoslav Krajačić will present 'File Pilot: Inside the Engine'.
- Ryan Fleury will cover 'Cracking the Code: Realtime Debugger Visualization Architecture'.
- Eskil Steenberg will give two talks: 'You should finish your software' and a 'Security rant'.
- Wassim Alhajomar will discuss programming vehicles in games.
- Sander J. Skjegstad will talk about dynamic phase alignment in audio.
- Ted Bendixson will present 'Most of your projects are stupid. Please make some actual games.'.
- Demetri Spanos will discuss 'Foliated Distance Fields: Scalable Rendering of Glyphs with Gradients'.
- Cameron Reikes will cover 'Deep Learning and Computer Vision for Game Developers'.
- Sam H. Smith will talk about 'AST-Free Compilers and Sea of Nodes'.
- Andrew Reece will present 'Assuming as Much as Possible'.
- Physical attendance is invite-only; tickets will not be publicly available.
- Talks will be livestreamed and recorded, available for free.
- Event location: a charming small town.
- Attendees will receive a guide with necessary information; Sam, Sander, and Charlie are contacts.
Dict Unpacking in Python
10 months ago
- Introduces a humorous Python package called 'dict-unpacking-at-home' for dictionary unpacking.
- Instructions include adding a specific coding declaration to enable dictionary unpacking syntax.
- Demonstrates basic and nested dictionary unpacking with examples.
- Mentions a known issue with line numbers in stacktraces and a branch with a fix.
- Strongly advises against using the package in serious projects.
- Notes the package's popularity with almost a million monthly downloads and 30M+ total.
Difftastic: A structural diff that understands syntax
10 months ago
- Difftastic is a structural diff tool that compares files based on syntax.
- Supports over 30 programming languages; falls back to textual diff for unrecognized extensions.
- Understands nesting, alignment, and line-wrapping in code comparisons.
- Performance issues with large files or many changes; high memory usage.
- Side-by-side display can sometimes be confusing.
- Regular updates fix crashes; not suitable for generating patches.
- Does not support AST merging or handling unordered data types.
- Can check for syntactic changes without full diffing (faster).
- Supports merge conflict markers for diffing conflicting files.
- Uses Dijkstra's algorithm for structural diffing; open-source under MIT license.
"high level" languages are easier to optimize
10 months ago
- High-level languages are easier to optimize compared to low-level languages.
- Low-level languages are hard to optimize due to complex alias analysis and memory allocation issues.
- Haskell's referential transparency allows for easier optimizations like stream fusion.
- Functional languages like Futhark can outperform C in specific domains by using unboxed values and strict constraints.
- SQL's declarative nature allows for significant performance improvements over time without changing the source code.
- Raw pointers are sometimes necessary for specific memory optimizations but are rarely needed in general-purpose programming.
- Rust is a step in the right direction by making raw pointers opt-in and supporting functional paradigms for optimization.
- Meta-languages that allow switching between languages can help in choosing the right tool for the job, improving performance.
Working through 'Writing A C Compiler'
10 months ago
- The author decided to create a C compiler for the Hack processor from the nand2tetris book.
- Found the book 'Writing a C Compiler' by No Starch Press and decided to work through it chapter by chapter.
- The book is praised for its step-by-step approach, starting with a simple compiler in Chapter 1 that can handle basic return statements.
- Each subsequent chapter adds more features, like unary operators in Chapter 2.
- The book provides a large test suite for each chapter, allowing testing of various stages like lexer, parser, semantic analysis, etc.
- The author has forked the original test suite and made some changes for Windows support.
- The author is implementing the compiler in Rust and plans to blog about each chapter.
- The book is highly recommended despite some minor criticisms that may be mentioned in future posts.
A Mental Model for C++ Coroutine
10 months ago
- C++ coroutine is a specification defining customization points for library writers, not a ready-to-use library or trait.
- Coroutines generalize functions by supporting suspend, resume, and destroy operations in addition to call and return.
- Example coroutine 'add' demonstrates suspending at 'co_await' and resuming after 'co_sleep(1)' completes.
- C++ coroutine's flexibility allows customization of operations like call, return, suspend, resume, and destroy.
- The 'promise_type' within the coroutine's return type (e.g., 'Task<T>') is key for customizing coroutine behavior.
- Awaiter and Awaitable concepts enable customization of suspend and resume operations, with 'await_suspend' and 'await_resume' methods.
- 'final_suspend' allows customization at the coroutine's end, often used to resume awaiting coroutines.
- 'await_transform' provides a way to transform expressions into awaitables, ensuring all awaitables are coroutines.
Zig's New Async I/O
10 months ago
- Zig introduces a new I/O interface where the caller provides the I/O implementation, similar to how allocators are handled.
- The new I/O interface allows for better control over concurrency and parallelism in I/O operations.
- Examples show how to write concurrent I/O operations using the new interface, including handling futures and cancellation.
- Different I/O implementations are planned, including blocking I/O, thread pools, green threads, and stackless coroutines.
- The design aims for code reusability and optimality, with features like semantic I/O operations (e.g., sendfile and vectorized writes).
- The roadmap indicates partial availability in Zig 0.15.0, with more extensive changes in subsequent releases.
- Zig's approach to async I/O avoids the 'function coloring' problem, making code more reusable across different execution models.
- The new system supports various execution models without forcing a specific one, enhancing flexibility and performance.
- FAQ addresses common questions about Zig's focus on async I/O and how it integrates with the language's low-level nature.
Zig's new I/O: function coloring is inevitable?
10 months ago
- Bob Nystrom's 2015 blog post 'What Color is Your Function?' sparked discussions on async computation handling in programming languages.
- Zig introduced a new I/O approach, aiming to solve function coloring by passing 'std.Io' to functions, but it shifts the problem to 'io/non-io' instead of blocking/non-blocking.
- The article argues that function coloring is about semantics and behavior, not just syntax or type signatures, and may be inherently unsolvable.
- Zig's design improves ergonomics by unifying execution models, similar to how 'std.mem.Allocator' is passed for memory allocation.
- The post concludes that while function coloring remains a challenge, Zig's approach offers a more convenient way to handle I/O operations.
Show HN: Bedrock – An 8-bit computing system for running programs anywhere
10 months ago
- Bedrock is a compact, portable 8-bit computer system designed to last forever.
- It is a specification, not a physical device, allowing programs to run on any system with a Bedrock emulator.
- Programs can run on Windows, Linux, the web, and Nintendo DS via emulators.
- Bedrock has 32 instructions and 12 devices, making it quick to learn.
- Includes tutorials, documentation, and examples like a microwave clock program.
- Implementations include bedrock-js (JavaScript) and bedrock-pc (Rust) for assembling and emulating programs.
- Originated as a fork of Uxn, focusing on performance on resource-constrained systems.
- Live demos include Cobalt (pixel art), Snake (graphics demo), and a microwave clock.

first prev11next

About|Login

#programming

Zig language and toolchain packaged as a deb for Debian and Ubuntu amd64/ARM64

A compact bitset implementation used in Ocarina of Time save files

Crypto 101 – Introductory course on cryptography

The First Time I Was Almost Fired from Apple

Ziglings: Learn Zig by fixing broken programs

Uncommon Uses of Python in Commonly Used Libraries (2022)

Best Way to Advertise a Programming Language

Haxe 5.0 preview.1 has been officially released

# [derive(Clone)] Is Broken

Code and Trust: Vibrators to Pacemakers

Jank Programming Language

A software conference that advocates for quality

Dict Unpacking in Python

Difftastic: A structural diff that understands syntax

"high level" languages are easier to optimize

Working through 'Writing A C Compiler'

A Mental Model for C++ Coroutine

Zig's New Async I/O

Zig's new I/O: function coloring is inevitable?

Show HN: Bedrock – An 8-bit computing system for running programs anywhere