Abstract: This workshop covers various aspects of Plan 9 development, including version control, system interfaces, portability, and distributed storage. The first talk introduces Git9, a Plan 9-native Git implementation, highlighting its simplicity and advantages over traditional Git for the Plan 9 ecosystem. The second presentation critically examines conventional system interfaces and proposes a "network of things" paradigm, leveraging WebAssembly and local protocols on repurposed consumer gadgets. The third session details Plan 9's evolving portability strategy, contrasting the older APE environment with the new, more efficient NOPE, and showcasing its success in porting modern applications. The fourth speaker describes the intricate process of adapting Plan 9's listen utility to Linux with GNU Guix, exposing fundamental differences in networking and namespace management. Finally, the last talk discusses the re-implementation of Plan 9's Venti distributed storage system as NeoVenti, aiming to simplify its architecture and significantly improve performance by avoiding over-engineering.

Summary:

• 0:45 IWP9 2024 - Day 1 Introduction & Setup: The workshop begins with technical setup checks, including audio and streaming, and acknowledges the community's presence.
• 18:52 A Git For Plan 9:
  • The speaker introduces Git9, a Plan 9-native Git implementation, emphasizing Git's distributed, snapshot-based, and local-first nature.
  • Key Detail: Git9's core is written in C with shell script wrappers, leveraging Plan 9's file system (gitfs) for repo exploration and command execution (e.g., git diff using diff -u on the file system).
  • Key Takeaway: Git9 aims for simplicity and maintainability, enabling Plan 9 to self-host its codebase (git.9front.org) and foster community growth. It notably replaced Mercurial (which was Python-based) from the NineFront distribution, saving millions of lines of code.
• 1:28:59 Center, Left, and Right:
  • Daniel critiques the historical focus of computing on bureaucracy and the current state of "APIs" and command-line interfaces for their complexity and inconsistencies.
  • Key Detail: He demonstrates repurposing cheap consumer electronics (Wi-Fi hotspots, routers, cameras, TV boxes, car media players) running custom firmware (u-root, OpenWRT) to create a "network of things."
  • Key Takeaway: The vision is to move towards a local-first, protocol-oriented network where devices serve their own applications (possibly WebAssembly) and user interfaces, avoiding reliance on cloud services and vendor lock-in.
• 3:31:50 Portability Has Outgrown Posix:
  • Jacob Moody discusses Plan 9's evolution in software portability, contrasting the traditional APE (Anix Environment) with the newer NOPE (New Portability Environment).
  • Key Detail: APE is a separate libc, causing code reuse issues and bit rot. NOPE is a minimal layer built atop Plan 9's native libc, making it smaller (10K LOC vs 31K LOC for APE) and more integrated.
  • Key Takeaway: Porting alien software (e.g., uxn, DOS games like Doom clones, Cave Story) with NOPE has pushed Plan 9's compilers and linkers, revealing and fixing numerous subtle bugs (e.g., packed struct copying, unsigned integer indexing, bitfield issues).
• 5:23:05 Adapting Plan 9's listen to GNU Guix:
  • Edgar details the challenges of porting Plan 9's listen utility, which treats network ports as files, to Linux with GNU Guix.
  • Key Detail: Linux lacks Plan 9's netfs (file-system network interface) and per-process unprivileged mounts/capabilities within namespaces, forcing the use of external tools like socat and complex privilege management.
  • Key Takeaway: The port exposes fundamental architectural differences between Plan 9 and Linux, highlighting Plan 9's elegant approach to resource management. The use of GNU Guix for reproducible and auditable environments is also discussed.
• 6:11:03 What is a computer for?:
  • Neal recounts his frustrating experience with Plan 9's Venti distributed file system, leading him to rewrite it as NeoVenti.
  • Key Detail: Venti is criticized for being over-engineered (multiple redundant caches, unnecessary abstraction layers, poor memory management) and unstable (demonstrated by a live crash during a Go installation).
  • Key Takeaway: NeoVenti's philosophy is to "do things simple, do things right," leading to significantly better performance (e.g., 4-second cached read vs. 11 seconds for Venti) and stability by drastically reducing code complexity and directly manipulating data. The goal is to provide a solid foundation for future features like Git integration and flexible synchronization.
• 7:09:04 Workshop Conclusion: The organizer concludes Day 1, thanking participants and viewers from around the world, and invites attendees to dinner.