Bilingual

Show HN: Salt – a systems language with Z3 theorem proving in the compiler
24 days 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.
Modula-3 History Collection on Computer History Museum
5 days 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.
Zig In-Depth Overview
4 hours 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.

Hasty Briefsbeta

systems programming

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

Modula-3 History Collection on Computer History Museum

Zig In-Depth Overview