Hasty Briefsbeta

All tags

#programming

778 stories total

Bilingual

New Go Garbage Collector
a year ago
- New experimental garbage collector for Go programs announced.
- The project is hosted on GitHub under the Go language repository.
- The announcement was made by Michael Knyszek on his personal site.
- The issue includes a comment link for further details.
- The post emphasizes the need for JavaScript due to the interactive nature of the web application.
Vrs: Personal Software Runtime inspired by Emacs, Plan 9, Erlang, Hypermedia
a year ago
- vrs is a personal software runtime designed for a holistic programming experience, inspired by Emacs, Erlang, Unix, Plan 9, and Hypermedia systems.
- Key principles of vrs include joy, uniformity, simplicity, practicality, and interactivity.
- vrs includes components like lyric (an embedded Lisp dialect), vrsd (a runtime daemon), libvrs (shared library), vrsctl (CLI client), and vrsjmp (GUI launch bar).
- Lyric lang features include function definitions, list operations, pattern matching, message passing between processes, and service registration.
- Processes in vrs are lightweight, isolated, and communicate via message passing, with built-in pubsub mechanisms.
- vrsctl provides a CLI for interacting with vrs, including an interactive REPL and service binding.
- An Emacs major-mode, lyric-mode, is available for syntax highlighting and interactive development.
Squiggle: A simple programming language for intuitive probabilistic estimation
a year ago
- Squiggle is a simple programming language designed for intuitive probabilistic estimation.
- It makes working with probability distributions very easy.
- Squiggle is portable and can be used wherever Rescript and Javascript are available.
- It is fast, avoiding Monte Carlo simulation when possible but using it when necessary.
On eval in dynamic languages generally and in Racket specifically (2011)
a year ago
- The `eval` function is central to dynamic languages like Racket but is often avoided by experienced programmers due to potential issues.
- `eval` can be compared to instructing someone in a language they may not understand, leading to unreliable results.
- Good uses of `eval` include scenarios where instructions are dynamically generated and passed to others, such as construction crew instructions.
- In Racket, `eval` interacts with the module's namespace, and DrRacket sets the namespace for the interactions window.
- Racket's default empty namespace for `eval` helps programmers remember to consider language context.
- Security concerns highlight the need to limit `eval`'s authority and avoid quoting confusion.
- Mike Samuel emphasizes making languages analyzable and limiting embedded scripting languages' authority.
- A typo in the original text was pointed out by Hendrik Boom regarding a missing 'that' in a sentence about `eval`.
Smallest Possible Files
a year ago
- Repository for smallest syntactically valid files in various languages.
- Started with a blog post on minimal HTML/XHTML files.
- Encourages pull requests; author waives copyright.
- Lists minimal file examples for compression formats (e.g., .bz2, .gz, .rar, .tar, .zip).
- Includes executable formats (e.g., .com, .exe, .elf, .class, .wasm).
- Covers image formats (e.g., .bmp, .gif, .jpg, .png, .webp).
- Enumerates programming/scripting languages (e.g., C, Java, Python, Ruby, JavaScript).
- Features markup/data formats (e.g., JSON, Markdown, SVG, YAML, HTML, XML).
Automated Verification of Monotonic Data Structure Traversals in C
a year ago
- Bespoke data structure operations are common in real-world C code.
- Monotonic data structure traversals (MDSTs) iterate monotonically through structures, e.g., strlen or binary search tree insert.
- Shrinker is a new automated verification tool for MDSTs in C, using scapegoating size descent analysis.
- Scapegoating size descent leverages similar execution traces between original and 'shrunk' inputs.
- A new benchmark set includes over 100 instances proving correctness, equivalence, and memory safety of MDSTs in major C codebases.
- Shrinker outperforms state-of-the-art tools in verifying monotonic string and list traversals.
Learning C3
a year ago
- The author describes their experience learning the C3 programming language, motivated by curiosity and a desire to explore new paradigms.
- C3 is presented as an evolution of C, offering features like modules, operator overloading, generics, compile-time execution, and more, aiming to improve ergonomics and optimization.
- The article includes a real-time learning approach, highlighting both the advantages of immediate insights and potential inaccuracies due to the learning process.
- Key language features discussed include Hello World example, foreach loops, while loops, enum types with switch statements, the defer keyword, struct types, and error handling mechanisms.
- The author explores C3's macro system, type properties, base64 & hex literals, and primitive types, comparing them to C and other languages like Zig and Rust.
- A practical example of creating a calculator in C3 is provided, covering tokenization, parsing, and calculation, showcasing the language's syntax and features in action.
- The conclusion reflects on C3's potential as a safer and more expressive alternative to C, while acknowledging personal preferences for other languages like Zig.
- The author appreciates C3's readable source code and macro system but critiques certain design choices like inclusive slicing syntax and the error system.
For your eyes only – Bitfield Consulting
a year ago
- Error messages should be informative, not just 'error' or 'failed'.
- Programmers often overlook error handling, leading to unhelpful or silent failures.
- The article demonstrates improving error handling in a Rust line-counting program.
- Using the `?` operator in Rust helps propagate errors effectively.
- Displaying user-friendly error messages is crucial for a good user experience.
- Standard error (`stderr`) is preferred for error messages to avoid mixing with normal output.
- Setting a non-zero exit status helps scripts detect and handle program failures.
- Handling invalid input (e.g., non-UTF-8) gracefully is essential for robust software.
- Rust's strict type system and error handling promote durable and resilient programs.
See You at the Last RailsConf
a year ago
- Final RailsConf to be held July 8-10 in Philadelphia, celebrating 20 years of Rails history.
- Theme of the conference: 'The Past, Present, and Future of Rails'.
- Highlights include evolution of Rails from pre-Bundler days to Hotwire-era.
- Speaker lineup features DHH, Rails team members, and a panel on background jobs.
- Tickets are still available for the event.
Making C and Python Talk to Each Other
a year ago
- LeetArxiv is a platform for implementing research papers, primarily in C and Python.
- The guide explains how to call Python from C, starting from basics like locating Python.h.
- Steps include including Python header in C, compiling C files with Python paths, and working with PyObjects.
- Detailed instructions on initializing Python, loading modules, and calling Python functions from C are provided.
- Examples cover calling functions both with and without arguments, including handling PyObjects and memory management.
- The article concludes with a summary of the process and a link to example files for reference.
Revisiting Loop Recognition in C++ in Rust
a year ago
- Comparison of programming languages (C++, Java, Go, Scala) from 2011 to 2024, highlighting Rust's emergence as a popular and admired language.
- Rust's core properties: performance, type safety, concurrency, memory safety without garbage collection, and compile-time checks via the borrow checker.
- Implementation of a loop recognition algorithm in Rust, comparing Safe Rust and Unsafe Rust approaches, with focus on idiomatic Rust practices.
- Performance analysis comparing C++ and Rust (Safe and Unsafe) in terms of code size, compile times, binary size, memory footprint, and execution times.
- Findings: Rust's Release builds outperform C++ in execution time and memory usage, with Unsafe Rust showing the best performance, while Debug builds are slower.
Show HN: Code_puppy – a CLI vibe coder that I vibe coded using a vide coder
a year ago
- Code Puppy is an AI-powered code generation agent designed to understand programming tasks, generate high-quality code, and explain its reasoning.
- Features include multi-language support, an interactive CLI, and detailed explanations of generated code.
- Installation is simple with pip, and it supports various models like GPT-4.1 and Google Gemini.
- Custom configurations are possible for corporate environments, including custom model endpoints.
- Code Puppy can execute specific tasks directly or run in interactive mode.
- Requirements include Python 3.9+ and API keys for models like OpenAI, Gemini, or Anthropic.
- The project is licensed under the MIT License.
- Puppy rules allow users to define and enforce coding standards and design guidelines.
Fractran Interpreter
a year ago
- FRACTRAN is a Turing-complete esoteric programming language invented by John Conway.
- A FRACTRAN program consists of an ordered list of positive fractions and an initial positive integer input n.
- The program runs by updating n: for the first fraction f where n*f is an integer, replace n with n*f.
- This process repeats until no fraction produces an integer when multiplied by n, then the program halts.
Pure vs. Impure Iterators in Go
a year ago
- Go has standardized iterators with the introduction of generics in Go 1.18, enhancing flexibility and performance.
- Iterators in Go can be classified into 'pure' (stateless, no observable side effects) and 'impure' (stateful, with side effects).
- The official documentation introduces 'single-use iterators' as a subcategory of impure iterators, but this classification is seen as ambiguous and imprecise.
- Pure iterators are easier to reason about and can reduce heap allocations, making them preferable from a performance standpoint.
- However, consistency with related iterators (like those in the bytes package) may necessitate the use of impure iterators in some cases.
- The Go community is still establishing conventions around iterators, with ongoing discussions about terminology and best practices.
C++ to Rust Phrasebook
a year ago
- The book helps C++ programmers learn Rust by translating common C++ patterns into idiomatic Rust.
- It provides concrete code examples and discusses engineering trade-offs.
- Designed for random-access use, allowing readers to look up specific C++ to Rust translations as needed.
- Written by expert C++ and Rust programmers at Brown University's Cognitive Engineering Lab.
- Suggests additional resources for beginners, embedded systems programmers, and those interested in Rust's deeper mechanics.
- Encourages feedback through a form linked at the bottom of every page and quizzes for research purposes.
Simpler Backoff
a year ago
- Exponential backoff with jitter is commonly used for service calls.
- Traditional approach involves calculating delays dynamically with potential for bugs.
- Simplified version uses a lookup table for delays, making it more readable and maintainable.
- Lookup table approach reduces variables and scope, simplifying reasoning about behavior.
- Edits to backoff schedule and attempts are safer and easier with the lookup table method.
Implementing a Forth
a year ago
- The author shares their experience with implementing Forth, emphasizing the learning opportunities it provides about concatenative programming and computer operations.
- Three approaches to implementing Forth are suggested: porting an existing Forth (like JONESFORTH), creating an ultra-tiny Forth core (examples include PlanckForth, SmithForth, sectorforth, milliForth, StoneKnifeForth, and a 'Three Instruction' Forth), and designing a Forth around a tiny target program (like Meow5 and Snobol4th).
- Porting existing Forth implementations is highlighted as a valuable learning method, with the author's own experience porting JONESFORTH to NASM as an example.
- The concept of minimal Forth cores is explored, discussing how few words are needed to bootstrap the rest of the language, with examples of extremely compact Forth implementations.
- The idea of targeting a specific program to guide Forth implementation is presented, with examples like Meow5 and a SNOBOL4-based Forth that runs a '99 Bottles of Beer' program.
- Resources for aspiring Forth implementers are recommended, including JonesForth source, Brad Rodriguez's Moving Forth series, and the book Threaded Interpretive Languages by R.G. Loeliger.
Show HN: A new programming language inspired by Go, no LLVM
a year ago
- Nature is a general-purpose open-source programming language and compiler designed for secure, reliable, and cross-platform software development.
- Features include simple syntax, no dependency on LLVM or VM, static linking, comprehensive type system, high-performance GC, and memory allocator.
- Supports high-performance coroutines, built-in libuv for IO event loops, modularity, package management, and common data structures.
- Error handling uses try+catch, match for pattern matching, channels for concurrency, and select for concurrent processing.
- Follows system ABI, includes libc, and supports direct calls to C standard library functions.
- Current version supports compilation on linux/amd64, linux/arm64, darwin/amd64, and darwin/arm64.
- Future work includes improving usability, refining standard libraries, collecting user feedback, and fixing bugs.
- Nature is designed as an improvement over Go, addressing its limitations while maintaining similar runtime features.
- Suitable for game development, scientific computing, AI, IoT, command-line tools, and web development.
- Installation involves downloading the nature installer, setting environment variables, and verifying with nature -v.
- Quick start, syntax, and standard library documentation available on the official website.
- Project source code is under Apache License 2.0, while standard libraries use MIT license.
Why Use Structured Errors in Rust Applications?
a year ago
- Structured errors in Rust applications provide better maintainability and reasoning about code.
- Libraries should expose detailed error types for better handling and documentation.
- Applications often use `anyhow` for simplicity in error propagation.
- Custom error types enhance code review and interface descriptiveness.
- Error types reduce repetition and improve consistency in error messages.
- Custom errors can be enriched with additional data and functionality.
- Structured errors have tradeoffs like more code and maintenance overhead.
- Performance considerations vary based on error handling needs.
- Structured errors are deemed beneficial despite the tradeoffs.
Unexpected Gotchas in Making a Game Deterministic
a year ago
- Deterministic programming requires careful seeding of random number generators, handling of multithreading, and floating-point computations.
- Less common pitfalls include differences in compilers, compiler options, standard library implementations, and architectures.
- Random number generation issues arise from `uint_fast32_t` usage in `std::mt19937`, which varies by architecture (32-bit vs. 64-bit).
- Standard library distributions (e.g., `std::uniform_int_distribution`) can vary across implementations, leading to non-deterministic behavior.
- Sorting and parameter evaluation order can produce different results across platforms (e.g., Linux vs. Windows).
- Memory usage limits are non-deterministic due to varying pointer sizes, alignment requirements, and STL implementations.
- Deterministic memory limitation enforcement requires higher-level abstractions than just allocation size.
- References to external resources on deterministic floating-point calculations and game determinism are provided.

first prev7next

About|Login

#programming

New Go Garbage Collector

Vrs: Personal Software Runtime inspired by Emacs, Plan 9, Erlang, Hypermedia

Squiggle: A simple programming language for intuitive probabilistic estimation

On eval in dynamic languages generally and in Racket specifically (2011)

Smallest Possible Files

Automated Verification of Monotonic Data Structure Traversals in C

Learning C3

For your eyes only – Bitfield Consulting

See You at the Last RailsConf

Making C and Python Talk to Each Other

Revisiting Loop Recognition in C++ in Rust

Show HN: Code_puppy – a CLI vibe coder that I vibe coded using a vide coder

Fractran Interpreter

Pure vs. Impure Iterators in Go

C++ to Rust Phrasebook

Simpler Backoff

Implementing a Forth

Show HN: A new programming language inspired by Go, no LLVM

Why Use Structured Errors in Rust Applications?

Unexpected Gotchas in Making a Game Deterministic