Bilingual

Show HN: Build offline-first web apps in pure Go and HTML
19 days ago
- Swag allows building offline-first web apps using Go and HTML without JavaScript.
- It compiles Go handlers and templates to WebAssembly, running them in a Service Worker for local execution after first visit.
- Dual deployment: same app serves HTTP requests natively and as WASM for offline use.
- Features include persistent storage, sync, PWA manifest, and cache versioning.
- Reference apps demonstrate real-time markdown preview and offline social feed reading.
Go-Flavored Concurrency in C
14 days ago
- Go's concurrency model is popular for its lightweight goroutines, channels, and efficient runtime scheduler, but replicating it in C using only POSIX threads presents trade-offs.
- Solod (So) implements a concurrency stack based on pthread primitives: sync.Mutex and sync.Cond wrap pthread_mutex_t and pthread_cond_t, providing basic synchronization.
- Atomic operations in So map directly to C's __atomic built-ins, matching Go's performance for load, store, and compare-and-swap operations without pthread overhead.
- So's conc.Pool uses a fixed number of worker threads with a shared task queue, built with mutexes and condition variables, suitable for coarse-grained workloads but not for thousands of blocked tasks like goroutines.
- Channels in So (conc.Chan[T]) support buffered and unbuffered modes, using mutexes and condition variables for synchronization, with performance close to Go for pooled tasks but slower for fine-grained hand-offs due to kernel wakeup costs.
- Benchmarks show So's pthread-based concurrency is competitive for uncontended locks and atomic operations, but condition variables and channels are significantly slower when threads block, with up to 23x slower unbuffered channel transfers.
- Design decisions include using pthreads instead of fibers for simplicity, keeping concurrency in the standard library for explicit allocations and flexibility, and providing timeouts instead of select for channel operations.
- The approach offers simplicity and performance close to Go for coarse-grained workloads but cannot match Go's efficiency for fine-grained concurrency due to the overhead of kernel thread management.
Building the Pkg.go.dev TUI Explorer
4 days ago
- The new pkg.go.dev API provides programmatic access to package metadata, module versions, symbols, vulnerabilities, and more, eliminating the need for scraping HTML.
- The API is published with an official OpenAPI specification, making it easy to generate a Go client using tools like oapi-codegen.
- The author built a terminal UI (TUI) using Bubble Tea to browse Go documentation entirely from the terminal, improving workflow by avoiding context switching to a browser.
- The TUI currently supports searching packages, browsing module versions, and inspecting exported symbols, with potential for future features like vulnerability browsing and dependency trees.
- The generated API client had minor issues from the OpenAPI spec, which were fixed locally, and some response types needed manual extension.
- The application architecture separates state, networking, and rendering cleanly using Bubble Tea's message-driven model.
- The author highlights the API as a significant addition to Go tooling, enabling easier development of editor plugins, terminal tools, and automation.
Escape Analysis in Go: Stack vs. Heap Allocations Explained
3 days ago
- Escape analysis in Go is a compiler optimization that determines whether a value should be allocated on the stack or the heap.
- Values escape to the heap when they are still needed after the function returns, such as when returning pointers, using closures or goroutines, passing values through interfaces, or storing in long-lived data structures.
- The Go compiler provides escape analysis insights via the 'go build -gcflags="-m"' command, but the output can be noisy and hard to interpret.
- GoLand's escape analysis tool integrates compiler output into the editor, making it easier to understand allocation decisions with gutter markers and organized logs.
- Escape analysis is most valuable for optimizing hot paths in performance-sensitive code, but not all heap allocations need optimization.
- Best practices include measuring performance first, focusing on hot paths, understanding escape reasons, and verifying changes with benchmarking.
Stinkpot: SQLite-Backed Shell History
6 hours ago
- stinkpot is a minimal SQLite-backed shell-history searcher for bash, inspired by atuin but much smaller.
- It is written in Go (about 400 lines) and focuses only on session-agnostic history management and a TUI searcher.
- It can be installed via Nix home-manager or by evaluating an init script in .bashrc.
- Existing bash history can be imported with 'stinkpot import', and reverse search is triggered by Ctrl+R.
- The history database is stored in ~/.local/share/stinkpot; if upgrades break it, simply delete and reimport.
- The project includes performance improvements, using a covering index in SQLite for faster reverse search.

Hasty Briefsbeta

#go

Show HN: Build offline-first web apps in pure Go and HTML

Go-Flavored Concurrency in C

Building the Pkg.go.dev TUI Explorer

Escape Analysis in Go: Stack vs. Heap Allocations Explained

Stinkpot: SQLite-Backed Shell History