systems programming

Bilingual

complected and orthogonal persistence
2 months ago
- Persistence is difficult to implement; for example, autobackup in editors requires serializing data structures to a crash-consistent database.
- Some languages like MUMPS, Bank Python, and IBM i integrate persistence directly into the language runtime, making it part of the syntax.
- Complected persistence ties business logic and persistence code together, while orthogonal persistence saves state automatically without programmer effort.
- Examples of orthogonal persistence include system hibernation and virtual machine snapshots (e.g., VirtualBox, VMWare).
- A proposed system uses existing tools (rr for syscall replay, ZFS for filesystem snapshots, bubblewrap for sandboxing) to provide orthogonal persistence for individual processes.
- This system enables many tools: collaborative terminals, undo for terminal commands, querying files modified by a command, and live-editable recordings.
- Performance is manageable: rr has <20% slowdown, ZFS and bubblewrap have minimal overhead, and the system can be optimized.
- Inter-process persistence works across program versions if syscalls are replayed, but memory snapshots are version-specific.
- Orthogonal persistence is achievable today with moderate trade-offs and unlocks many powerful tools with minimal development effort.
Zig In-Depth Overview
2 months ago
- Zig is a small, simple language with no hidden control flow, no hidden memory allocations, no preprocessor, and no macros.
- It offers four build modes (Debug, ReleaseSafe, ReleaseFast, ReleaseSmall) that can be mixed at scope granularity for performance and safety.
- Zig is faster than C due to whole compilation unit optimization, careful illegal behavior, SIMD vector types, and advanced CPU features enabled by default.
- The standard library integrates with libc but does not depend on it; Zig can produce very small static executables (e.g., 9.8 KiB for Linux).
- Zig uses optional types instead of null pointers, requiring explicit handling of null with `orelse` or `if`/`while`.
- Memory management is manual; all allocation functions accept an allocator parameter, and `defer`/`errdefer` simplify resource management.
- Errors are values that cannot be ignored, handled with `catch` or `try`, and can be exhaustively checked with `switch`.
- Zig supports compile-time code execution, reflection via `@typeInfo`, and generic data structures via functions returning types.
- C libraries can be directly imported with `@cImport` without bindings; Zig can also compile C code and export functions with the C ABI.
- Cross-compilation is a first-class feature; Zig ships libc for all supported targets, enabling cross-compilation without system files.
- Zig includes a build system and package manager with support for dependency fetching, system integration, and reproducible builds.
- Target support is tiered, and Zig is friendly to package maintainers with deterministic builds and JSON download pages.
Modula-3 History Collection on Computer History Museum
2 months ago
- Modula-3 was designed in the late 1980s by Luca Cardelli, Jim Donahue, Mick Jordan, Bill Kalsow, and Greg Nelson, aiming to be safe and efficient for systems and application programming.
- Key features included interfaces, objects, generics, threads, isolation of unsafe code, garbage collection, exceptions, and subtyping, many of which were ahead of their time.
- The language originated from Modula-2+ and was refined through several revisions, with the definitive book 'Systems Programming with Modula-3' published in 1991.
- Two main implementations existed: Olivetti Modula-3 (short-lived) and DEC SRC Modula-3, which became the basis for all later distributions.
- Subsequent distributions included CM3, PM3, Cambridge Modula-3, and EZM3, with maintenance later taken over by Elego and then moved to GitHub.
- Modula-3 was used in significant projects such as the SPIN extensible operating system, CVSup version control tool, persistent object stores, and distributed virtual environments like COTERIE.
- The language's influence persisted through its concepts and the annotated archive maintained by editor Paul McJones.
Show HN: Salt – a systems language with Z3 theorem proving in the compiler
3 months ago
- Salt provides verified safety at compile time without runtime overhead using Z3-proven contracts.
- It uses arena allocation instead of garbage collection or a borrow checker, ensuring memory safety and preventing leaks.
- Salt achieves performance parity with clang -O3 across various benchmarks, including ML inference, kernels, networking, and rendering.
- The language features pipe operators for chaining, optional chaining for errors, and f-strings for type-safe formatting without allocation.
- Salt's package manager, sp, offers dependency verification, content-addressed caching, and monorepo support for fast, reliable builds.

systems programming

complected and orthogonal persistence

Zig In-Depth Overview

Modula-3 History Collection on Computer History Museum

Show HN: Salt – a systems language with Z3 theorem proving in the compiler