Original title: A Review of Helix after 1.5 Years
The author, after 1.5 years of using Helix, a modal terminal editor similar to Vim, provides a review and comparison. Helix offers built-in features like file pickers, language server protocol (LSP) support, and treesitter-based code navigation, reducing the need for extensive configuration. The editor's core functionality is robust, supporting numerous languages with standard tooling. Helix uses a Kakoune-like input grammar, which differs from Vim's, but the author found it adaptable. While Helix lacks a plugin system, it compensates with integrated features. The review highlights Helix's powerful selection manipulation, diagnostics picker, and other features like code actions and color themes. The author also provides configuration tips for new users, including keybindings and theme preferences. Despite some missing features like Vim's redo command and marks, the author is generally happy with Helix, citing its ease of use and minimal configuration compared to Vim, especially on Windows.
Original title: After the Graz, Austria February 2025 WG14 Meeting, I am now confident in the final status of the defer TS, and it is now time.
The author announces the finalization of the 'defer' Technical Specification (TS) for the C programming language, a scope-based mechanism for ensuring the execution of specific statements regardless of program flow. This feature, similar to destructors in C++ and 'defer' in other languages, is designed to handle tasks like unlocking mutexes, freeing memory, and rolling back transactions. The author explains the rationale behind using a TS instead of directly incorporating 'defer' into the C standard, citing vendor preferences and the need to refine the initial proposal. The TS version of 'defer' is lexically bound, meaning it executes at the end of its containing block, offering deterministic behavior and direct variable reference. The author emphasizes the benefits of 'defer' in preventing resource leaks and simplifying code, contrasting it with alternative approaches like single-exit functions and the C++ object model. The author highlights the importance of implementing 'defer' to gain deployment experience and encourages compiler vendors and users to actively support its adoption. The author also discusses the differences between C's 'defer' and its counterparts in other languages, such as Go, and addresses the limitations of 'defer' in handling runtime control flow and its compatibility with C++.
Original title: Our interfaces have lost their senses
The article discusses the evolution of computer interfaces from physical, embodied experiences to the current flat, text-based interfaces. Initially, computers involved physical interaction with switches and cables, evolving into command lines and GUIs. Touchscreens offered direct interaction but remained limited to a flat display. The rise of AI chatbots further reduced interfaces to text input, eliminating tactile and multi-sensory experiences. The author argues that removing friction from interfaces, while seemingly efficient, diminishes the satisfaction derived from effortful activities. The author suggests that interfaces should incorporate multiple modalities, such as voice, gestures, and visuals, to allow for collaboration on tangible artifacts and respond to ambient signals. The author envisions interfaces that adapt to users' bodies and senses, offering a richer, more engaging experience. The author provides an example of a thought-organizing tool that uses voice and text input to organize ideas into cards, demonstrating a different way of working with technology.
Original title: Git 2.49 Released With Faster Packing, Rust Foreign Language Interface
Git 2.49, the latest update for the distributed version control system, has been released. This version introduces several enhancements, including faster packing through name-hash v2, and a new "git backfill" tool designed to handle missing historical blobs. The "git clone" command now supports shallow clones for single commits, even if they are not at the tip of a branch. Additionally, Git 2.49 features lazy-loading of missing files in blobless clones and includes preparations for zlib-ng support. A significant addition is the foreign language interface for Rust, marking the first integration of Rust code into Git. This initial implementation includes two new Rust crates, libgit-sys and libgit, with further Rust code planned for future releases. Users can find more details and download the release from the official announcement and the GitHub blog.
Original title: My Favorite Firefox Extensions
The author, a Firefox user, shares a list of their favorite extensions for both desktop and Android. These include Dark Reader for dark themes, LeechBlock NG for blocking distracting websites, SponsorBlock for skipping YouTube sponsorships, Stylus for website style modifications, and uBlock Origin for ad-blocking. Other extensions mentioned are Web Archives for viewing archived pages, Yang! for client-side search bangs, 1Password for password management, Activate Reader View to force reader view, AudioContext Suspender to fix battery drain, Auto Tab Discard for managing inactive tabs, Clickbait Remover for YouTube, Close Tabs Shortcuts + Toggle Pin Tab for tab management, Floccus for bookmark syncing, LanguageTool for grammar and spelling, Linkding extension + SingleFile for saving and archiving links, Old Reddit Redirect for redirecting to the old Reddit UI, RSSPreview for previewing RSS feeds, Sideberry for vertical tabs, StreetPass for Mastodon for discovering Mastodon users, Substitoot for improving Mastodon federation, Tabliss for a new tab page, and Vimium for Vim-like keybindings. The author seeks recommendations for additional extensions.
Original title: tl;dr: ‘Multiple return values’ in Go interact poorly with other language features. We should probably promote them to full-blown tuple types.
The author critiques Go's design, particularly the implementation of multiple return values, arguing they are not true tuple types and cause several problems. They claim this design choice complicates the language, hinders interaction with other features, and leads to workarounds. The author points out that the lack of tuples makes it difficult to store function results in lists or pass them through channels, especially in concurrent scenarios. They also criticize the impact on error handling, where multiple return values are used, leading to potential issues like variable shadowing and the inability to easily compose errors. The author suggests that promoting multiple return values to full-blown tuple types could improve the situation, but acknowledges the challenges of backward compatibility. They also discuss the history of this design choice, suggesting it was made to keep the language simple, but ultimately led to complex edge cases. The author concludes by acknowledging Go's strengths, such as its tooling and simplicity, while expressing hope for future improvements, including the potential addition of tuples.
Original title: Someone copied our GitHub project, made it look more trustworthy by adding stars from many fake users, and then injected malicious code at runtime for potential users.
A developer discovered a malicious campaign involving forked GitHub projects. The attacker copied projects, added fake stars to appear legitimate, and injected malicious code. The code, executed at runtime, downloads and runs a script from a remote server. The affected project is a GORM provider for Atlas, a popular project. The malicious code uses wget
to download and execute a bash script. The developer found similar malicious code in other projects. The attacker obfuscates the code, making it difficult to detect and track the full impact. The developer reported the issue to GitHub support, highlighting the need for assistance in resolving the problem. The impact is potentially widespread due to the obfuscation techniques used by the attacker. The developer is concerned about the scale of the attack and the difficulty in identifying all affected projects.
Original title: An exploration of SBCL internals
The article explores the internals of the SBCL Common Lisp implementation, focusing on memory representation, disassembly, and object types. The author aims to demystify how Lisp objects, such as strings, functions, and numbers, are stored in memory. The process begins with the use of a disassembler to examine the machine code generated for a simple function, revealing how arguments are passed and constants are handled. The author then demonstrates how to modify the compiled code directly by manipulating memory addresses. The article delves into the memory layout of Lisp objects, using tools to obtain and inspect the memory addresses of strings. It explains the concept of tagged pointers, where the last few bits of a memory address indicate the object's type, allowing for efficient handling of different data types. The author references SBCL's source code to illustrate how the runtime system defines object types and their corresponding tags. The article also touches on how fixnums (integers) are stored and how function pointers and lists are represented in memory. The author concludes by mentioning a discussion on Hacker News and hints at a potential continuation of the series.
Original title: The Year of the Picotron Desktop
The user reflects on a year of Picotron development, showcasing various projects and customizations. They started with Picotron Utilities, enhancing the terminal with commands like 'touch', 'grep', and 'fd'. They also created Fuzzy Finder for file searching and Picotron Remote Terminal for external editing via a web server. Other projects include Picotron Definitions for LuaLS, 8Ball and Snowglobe demos, PUSH for shell enhancements, and Balloon Run for the Pico 1K Jam. The user also participated in Advent of Code, developed Trash Manager for file management, and created 'extload' and 'extrunner' for external editor integration. Bouncy Ball, a desktop toy with physics, and calendar/clock widgets were also developed. The user also highlights the use of a startup folder for easier configuration, easy-to-access logs, an INI parser, and an inline image editor. Work-in-progress projects include an Archive Utility, a Cointris clone, a Pac-Man-inspired demo, LulPeg, and a weather widget, though the latter is on hold due to a Picotron bug.
Original title: What are your favorite Git tutorials?
A user is preparing to teach colleagues about Git, specifically focusing on forge-oriented usage within GitLab. The user is seeking tutorial recommendations to help colleagues learn Git effectively, without delving into complex distributed workflows. Several resources are suggested, including "git-from-the-bottom-up," the Git book, and "git for computer scientists." The user also mentions the importance of understanding Git's state through commands like git status
, git log
, and git reflog
. Other users recommend visual aids such as "Git Commands Explained with Cats" and the "git" zine. A whiteboard approach, illustrating Git's state transitions, is also suggested to provide a clear mental model.
Original title: Context Switching and Performance: What Every Developer Should Know
Context switching, essential for system responsiveness, involves saving and restoring a process's context, primarily its register state and virtual memory (page table). This operation, triggered by CPU time exhaustion or blocking operations, incurs direct costs (time to switch) and indirect costs (impact on CPU caches, TLB, pipeline, and branch predictor). Registers, crucial for storing a process's state, and main memory, organized into virtual pages mapped to physical memory via page tables, form the core of a process's context. Context switching involves switching the CR3 register (page table address) and saving/restoring registers. Indirect costs stem from cache contention (L1/L2/L3), TLB misses (virtual-to-physical address translation), pipeline flushes (instruction execution), and branch predictor state loss (branch prediction). Modern processors use ASIDs to mitigate TLB flushes, and VIPT caches to avoid cache flushes. Pipeline flushes and branch predictor state loss remain performance bottlenecks. Speculative execution vulnerabilities (Spectre, Meltdown) necessitate mitigations like TLB and cache flushes, though these are often configurable to balance security and performance. Strategies to mitigate context switching penalties include CPU pinning, priority adjustments, and user-space threading.
Original title: Happy Little Monoliths (Chapter 6)
The article explores Cap'n Proto, a data interchange format, and its potential for JavaScript applications, contrasting it with JSON. It introduces Cap'n Proto's schema-based, binary format, which promises faster parsing and smaller payloads due to on-demand data extraction via pointers. A simple example demonstrates creating and sending Cap'n Proto data using Fastify and capnp-es. The article then investigates Cap'n Proto's performance with larger payloads, comparing it to JSON using a generated 'News JSON' file. Benchmarking reveals that while Cap'n Proto offers significant speed improvements when accessing only a single field, its performance degrades dramatically when accessing all fields, due to the overhead of pointer-based data access. The conclusion is that Cap'n Proto is advantageous for large data payloads with deferred processing, but its benefits are limited to payload size reduction. The article suggests that JSON and application/x-www-form-urlencoded are preferable for most other scenarios, and it also notes that capnp-es is still in alpha.
Original title: The DEC Professional 380: A Unix Workstation from 1984
In 1982, DEC entered the personal computer market with the Rainbow, DECmate II, and Professional series, facing challenges due to their proprietary architectures and limited software compatibility. The Rainbow, designed to run both CP/M and MS-DOS, struggled with its unique architecture and incompatibility with standard PC software. The DECmate II, primarily a word processor, had compatibility issues. The Professional series, including the 350 and 325, were incompatible with standard PDP-11 programs and had sluggish operating systems. The 1984 Professional 380, with the J-11 CPU, offered improved performance but retained incompatibilities. The author upgraded a Pro 380 with an MFM emulator for a solid-state drive and increased RAM, then explored PRO/VENIX, DEC's Unix option. DEC's initial reluctance to enter the microcomputer market, influenced by Ken Olsen's skepticism, led to missed opportunities. The company's attempts to adapt existing minicomputer architectures, like the PDP-11, resulted in systems that were expensive and lacked software support. The author's Pro 380, acquired from a Caltech surplus sale, was used to demonstrate Venix's features, including split I+D, shared data segments, and real-time programming capabilities. The article details the hardware, including the CTI bus, gate arrays, and the J-11 CPU, and the process of converting the hard drive to solid state. The author also discusses the history of Venix, its features, and its evolution from Venix-11 to PRO/VENIX V2.0, highlighting its System V roots and unique capabilities. The article concludes with a look at the file system, installed software, and the author's plans for future exploration of the Pro's capabilities.
Original title: Open UI: Modernizing Web UI Controls
Web browsers have always provided UI controls, but current HTML5 controls are insufficient for modern web projects. Developers often resort to heavy JavaScript frameworks, leading to accessibility issues, performance problems, and security vulnerabilities. Designers also desire greater control over the look and feel of interfaces, which current controls don't provide. The Open UI Community Group is working to modernize HTML, CSS, JavaScript, and Web APIs to enable developers to create custom user interfaces. The group will research common component patterns, define design principles, and recommend improvements to relevant standards bodies. The goal is to address gaps in current web technology and facilitate the creation of more accessible, performant, and customizable web interfaces. The group will not define standards themselves, but rather make recommendations to existing standards bodies. The group welcomes community involvement and contributions to the project.