Popular：
Virtualization DNS security formal verification reachability analysis compiler errors macro conflict web extension development framework Bitmap Graphics API inconsistencies All Tags

Category: Development

Adélie Linux 1.0-BETA6 Released: Enhanced Compatibility and Richer Features

2024-12-16

Adélie Linux has released its 1.0-BETA6, supporting 32-bit and 64-bit ARM, POWER, and x86 architectures, spanning smartphones, game consoles, and supercomputers. This release boasts over 35 new packages, updates to GCC 13, LLVM 18, Rust 1.80, and Linux kernel 6.6 LTS, along with improved GRUB and Wayland support. Numerous bugs have been squashed, and the user experience has been enhanced. While some known issues remain, the Adélie team is actively working on solutions and welcomes bug reports and feedback.

(blog.adelielinux.org)
Development Linux distribution

Cyphernetes: Automating Cloud-Native Kubernetes Cluster Management

2024-12-16

Cyphernetes is a project that automates the management of cloud-native Kubernetes clusters. It significantly reduces operational complexity by simplifying deployment, upgrades, and management processes. Imagine effortlessly scaling your cluster to handle surges in traffic, automatically repairing failures, and ensuring service stability—all without manual intervention. Cyphernetes acts like an expert Kubernetes cluster administrator, safeguarding your applications 24/7, allowing you to focus on innovation.

(cyphernet.es)
Development Automated Operations

Dillo Browser: 25 Years of History, a Resurrection Story

2024-12-16

The Dillo web browser, born in 1999, has weathered 25 years of development. It has stalled several times but persevered. Initially led by Jorge Arellano Cid, it went through major GTK and FLTK phases, with key developers changing hands and the project experiencing ups and downs. In 2024, Rodrigo Arias Mallo took over, and with community help, released version 3.1.1, bringing this veteran browser back into the spotlight. Dillo's story exemplifies the spirit of open source and is a legendary tale of technological legacy and innovation.

(dillo-browser.github.io)
Development open-source browser

Hyperbola GNU/Linux-libre: A Lightweight OS Committed to Freedom and Long-Term Support

2024-12-15

Hyperbola GNU/Linux-libre is a community-driven operating system project aiming to provide a fully free, stable, secure, simple, and lightweight long-term support distribution. It leverages Arch Linux's package management and Debian's security patches, adhering to the GNU Free System Distribution Guidelines. Supporting i686 and x86_64 architectures, Hyperbola plans to release a BSD-based system, HyperbolaBSD. Recent news includes continued support for 32-bit systems, discontinuation of Debian patchsets beyond version 12, and concerns expressed regarding the Free Software Foundation's statement on machine learning.

(www.hyperbola.info)
Development Operating System Free Software

GitHub Project Map: Visualizing 400,000+ Projects

2024-12-15

Developer Anvaka created an interactive map visualizing over 400,000 GitHub projects using publicly available data. The project uses Jaccard similarity to calculate relationships between projects and the Leiden algorithm for clustering. The result is a visually stunning representation of the GitHub ecosystem, allowing users to search and explore connections between projects, revealing its complexity and richness.

(github.com)
Development project relationships

Vercel Launches ƒun: A Local Serverless Function Runtime

2024-12-15

Vercel has released ƒun, a local development runtime for serverless functions, enabling developers to emulate the AWS Lambda environment locally. Supporting various runtimes like Node.js and Python, ƒun allows for quick testing and debugging of serverless functions without cloud deployment. While striving for a close approximation of the real Lambda environment, ƒun has some key differences, notably in process sandboxing and user permissions.

(github.com)
Development Function Computing Local Development

Drag and Drop Images into Bevy 0.15 on the Web

2024-12-15

This post demonstrates integrating web native APIs via WASM with Bevy 0.15 to enable drag-and-drop image functionality in a web browser. It details using wasm-bindgen, gloo, and bevy_channel_trigger to handle DOM events in Rust, extract file data, and pass it to the Bevy engine for image loading and rendering. The process mirrors JavaScript implementation but leverages Rust's capabilities, addressing error handling and event listener memory leaks. The result is a Bevy web application capable of loading and displaying dropped PNG images.

(rustunit.com)
Development Web Development

Programmer Focus Indicator: The Birth of FlowLight

2024-12-15

Inspired by a research paper on the impact of work interruptions, programmer Shae Erisson DIYed a system called FlowLight to indicate whether a programmer is in a focused "flow" state. The system monitors idle time in the Emacs editor; when the programmer is inactive for a period, an Adafruit MagTag board's LED changes color (green for idle, red for busy). Erisson also wrote an HTTP server in CircuitPython to remotely control the LED color and display status. While the system has room for improvement, such as more granular idle time monitoring and a more visually appealing display, it effectively helps programmers avoid interruptions and improve productivity.

(www.scannedinavian.com)
Development programmer focus flow

WASM Program Bypasses node:wasi Filesystem Sandbox

2024-12-15

This project demonstrates a proof-of-concept showcasing how a WASM program can bypass the preopens directory restriction in node:wasi to access files outside the sandbox. Normally, WASM programs are limited to accessing pre-opened directories. However, by cleverly using symbolic links to replace files at a precise moment and running an external process, this limitation can be circumvented. This is not a practical security vulnerability in node:wasi, but rather a potential edge case. The project highlights that one shouldn't rely on node:wasi to completely prevent malicious code from accessing external files.

(github.com)
Development

MacOS GPU Optimization: Wasting Resources for Speed

2024-12-15

Anukari's developer encountered a bottleneck while optimizing GPU performance on MacOS. Due to limited system control over GPU performance, Apple's GPU performance regulation mechanism performed poorly in Anukari's use case, resulting in audio glitches. The developer implemented a workaround: dedicating a GPU threadgroup warp to useless computation to 'trick' the system into increasing GPU clock speed, significantly reducing audio latency and improving performance. While crude, this method proved effective in resolving MacOS performance issues. However, performance improvements varied significantly between different DAWs (Ableton and GarageBand), requiring further optimization.

(anukari.com)
Development GPU optimization performance bottleneck

Will Large Language Models End Programming?

2024-12-15

Recent advancements in large language models (LLMs) have sparked debate about the obsolescence of programming. This article argues against this overly optimistic view. Focusing on the computational complexity of program synthesis, the author demonstrates that generating correct code is a PSPACE-complete problem, meaning even moderately sized inputs could require exponential time. While LLMs can assist programmers and boost efficiency, their inherent limitations prevent them from completely replacing human programmers. The core of programming remains problem-solving and system design, requiring human ingenuity and creativity.

(cacm.acm.org)
Development program synthesis future of programming

Optimistic Computing: A Path Towards Better Software

2024-12-15

This essay explores the concept of "Optimistic Computing," not as blind optimism, but as a convergence of several powerful ideas: simplicity and ease of use ("boot to kill"), local-first principles, and user empowerment. The author argues that by limiting dependencies, simplifying workflows, creating a seamless "just works" experience, and giving users more control, we can build more reliable, secure, and long-lasting software. This philosophy applies to both individual users and enterprise software development, ultimately aiming for a digital world that respects user privacy and data ownership.

(www.deobald.ca)
Development optimistic computing local-first

Spark vs. DuckDB vs. Polars: Benchmarking Performance for Small to Medium Workloads

2024-12-15

This article benchmarks Spark, DuckDB, and Polars, comparing their performance, cost, and development ease on 10GB and 100GB datasets. Results show that for large datasets and ETL tasks, Spark remains dominant due to its distributed computing capabilities and mature ecosystem. DuckDB and Polars excel at interactive querying and data exploration on smaller datasets. The author recommends a strategic mix-and-match approach, using Spark for ETL, DuckDB for interactive queries, and Polars for niche scenarios, tailoring engine choice to specific needs.

(milescole.dev)
Development data processing engines benchmark

Fast LLM Inference Engine Built From Scratch

2024-12-15

This article details the author's journey in building an LLM inference engine from scratch using C++ and CUDA, without relying on any libraries. The process provided a deep dive into the full stack of LLM inference, from CUDA kernels to model architecture, showcasing how optimizations impact inference speed. The goal was to create a program capable of loading weights from common open-source models and performing single-batch inference on a single CPU+GPU server, iteratively improving token throughput to surpass llama.cpp. The article meticulously outlines the optimization steps on both CPU and GPU, including multithreading, weight quantization, SIMD, kernel fusion, and KV cache quantization, while analyzing bottlenecks and challenges. The final result achieves near state-of-the-art performance for local LLM inference.

(andrewkchan.dev)
Development LLM inference

Preferring Throwaway Code Over Design Docs: A More Efficient Software Development Approach

2024-12-15

In software development, the traditional design document and incremental development model isn't always efficient. Author Doug Turnbull proposes a "coding binge" approach: quickly implement a prototype using a temporary PR, get early team feedback, refine the design, and then gradually break it down into deployable PRs. This method encourages rapid iteration, early problem detection, and considers code itself as the best documentation. While design documents still have value in specific situations, the author advocates for "showing, not telling," using code prototypes for rapid validation and iteration to achieve more efficient software development.

(softwaredoug.com)
Development code prototype

The Secret to High-Performing Teams: Transactive Memory Systems

2024-12-15

This article explores the cornerstone of high-performing teams: Transactive Memory Systems (TMS). It's not about individual memory strength, but how teams effectively share and leverage members' knowledge and skills. Three types of team memory are introduced: working, long-term, and transactive memory, with a focus on how TMS enhances team performance. TMS comprises two elements: collaborative patterns and individual expertise. By building a TMS, teams unlock collective intelligence and overcome the impact of member changes. The article recommends methods like the Capability Comb, Team Manual, and deliberate practice to help teams quickly establish and improve their TMS.

(emilywebber.co.uk)
Development knowledge sharing transactive memory system

Isomorphic Web Components: Server-Side Rendering Made Easy

2024-12-15

The long-held belief that server-side rendering of web components is difficult has been challenged. This article demonstrates how to achieve server-side rendering of existing web components by cleverly using Happy DOM to emulate a browser environment. Two methods are detailed: using the `` tag for direct rendering and emulating the DOM to run component code and generate HTML. The author emphasizes the advantages of this approach: compatibility with all web components, robustness in the face of JavaScript failure, and avoidance of framework lock-in. This solves the server-side rendering problem for web components, offering a flexible and resilient solution.

(jakelazaroff.com)
Development Server-Side Rendering Isomorphic

SVC16: The Simplest Virtual Computer Challenges Programmers

2024-12-15

SVC16 is a minimalist 16-bit virtual computer designed for ultimate simplicity. It features no CPU registers, performing all operations within a single memory chunk. The instruction set is extremely streamlined, lacking bells and whistles like sound or variable screen size. Programmers are challenged to write machine code and compilers themselves, creating amazing feats with the simplest of tools. The project provides an emulator to run user-created programs and even games. This is a perfect project for learning low-level computer principles and honing programming skills.

(github.com)
Development virtual computer 16-bit programming challenge

Railgun Labs Unveils High-Performance Unicode Algorithm Library: Unicorn

2024-12-15

Railgun Labs has released Unicorn, a high-velocity Unicode algorithm library known for its speed, embeddability, cross-platform compatibility, and security. Unicorn supports numerous Unicode algorithms, including normalization, case conversion, collation, and segmentation, and provides decoders, encoders, and validators for UTF-8, UTF-16, and UTF-32 encodings. The library is fully customizable and extensively tested for accuracy and reliability. It's MISRA C:2012 compliant and largely thread-safe.

(railgunlabs.com)
Development Unicode algorithms software library high-performance

Home Assistant's Internet Accessibility Security Flaw

2024-12-15

Frederik Braun attempted to use Home Assistant for remote smart home control but discovered a significant security vulnerability. While Home Assistant offers username/password and two-factor authentication, its inability to handle URLs with embedded credentials and its requirement for root path deployment prevent additional security layers like web server authentication or obfuscated paths. This leaves Home Assistant's security solely reliant on its internal mechanisms, creating a security risk. The author calls on the Home Assistant community to improve its security configuration flexibility.

(frederikbraun.de)
Development Remote Access

XFCE 4.20 Released: Experimental Wayland Support and Numerous Improvements

2024-12-15

After nearly two years of development, XFCE 4.20 has been officially released! This version focuses on preparing the codebase for Wayland, now offering experimental Wayland support for most components, though it's still in its early stages and recommended for advanced users. XFCE 4.20 also boasts numerous new features, bug fixes, and improvements, including improved icon scaling, a performance-enhanced icon view, and an upgraded Thunar file manager. Importantly, Wayland support is incomplete, with some components and features yet to be ported.

(alexxcons.github.io)
Development Desktop Environment

Building a Simple Object System from Scratch in Ruby

2024-12-15

This blog post details building a basic object system in Ruby without using classes. The author cleverly uses anonymous functions and hash tables to implement core OOP concepts like method lookup, prototypal inheritance, mixins, and metaprogramming. Starting with a constructor function, the post demonstrates simulating private variables and public interfaces, effectively recreating class-like behavior and inheritance. Through clear code examples, readers learn to create objects, define methods, implement inheritance and mixins, and even build a rudimentary `attr_accessor`-like metaprogramming feature. It's a practical guide to understanding object system fundamentals.

(metacircu1ar.github.io)
Development Object-Oriented Programming Metaprogramming

JP Camara's RubyConf 2024 Talk Now on YouTube

2024-12-15

JP Camara's presentation on Ruby concurrency from RubyConf 2024 is now available on YouTube. The talk summarizes his past year's research and writing, and features animated slides. The video is also available on RubyVideo.

(jpcamara.com)
Development

TeaVM 0.11.0 Released: New WebAssembly Backend

2024-12-15

TeaVM 0.11.0 has been released, featuring a brand new WebAssembly backend. The old WebAssembly backend, while functional, lacked adoption due to insignificant performance gains and a poor developer experience. The new backend, leveraging the WebAssembly GC proposal, addresses these issues, improving interaction with browser JS APIs and reducing binary file size. While currently slightly less feature-rich than the JS backend, it already supports JSO (Java-to-JS interaction API), aiming for parity in the next release. This release also includes bug fixes in BitSet implementation and adds support for various JS APIs, such as file reading, touch events, the Popover API, and Navigator.sendBeacon.

(teavm.org)
Development

Farewell to Endless Meetings: A New Approach to High-Velocity Software Development

2024-12-15

Tired of endless meetings and lengthy planning? This article introduces a high-efficiency software development method: code-centric, rapid iteration. The author uses baking as an example to illustrate the concept of achieving the optimal solution through rapid experimentation, frequent testing, and continuous improvement. This method emphasizes reducing documentation, expressing ideas directly in code, using mock data and hot-reloading tools to speed up development, and improving code readability through concise code style and naming conventions. The author advocates breaking down projects into independently executable files, minimizing restart time, and using default language tools for debugging. Although this method may seem like a "chaotic lab," it can efficiently complete projects and avoid the redundancy and inefficiency of traditional methods.

(mihaiolteanu.me)
Development agile development efficient programming

Vim: A Programming Language Beyond an Editor

2024-12-15

Vim is more than just a text editor; it's a language for interacting with your computer. Its concise and efficient command structure is easy to learn and remember, and also easy for a computer to interpret. While Vim itself is powerful, its core strength lies in the fact that its mode has been integrated into almost every mainstream code editor, allowing developers to flexibly choose their preferred editor interface while retaining Vim's efficient command language. Therefore, NeoVim, as the most complete and consistent implementation of the Vim language, is valuable for providing this efficient editing language, not just the editor itself.

(blog.jonas.foo)
Development editor

Programming Languages: Balancing Safety and Power

2024-12-15

This article explores the trade-off between safety and power in programming languages. The traditional view is that powerful languages, like C with its manual memory management, are inherently unsafe. However, the author argues this is outdated. Modern language research shows that greater expressiveness allows for both safety and power. The evolution of macros in Lisp, Scheme, and Racket exemplifies this, demonstrating how improved design can enhance macro capabilities while maintaining safety. Racket's macro system is presented as a best practice, combining hygienic code with powerful manipulation capabilities. The article concludes that safe and reliable systems build more capable and reliable software, and recommends resources for further learning about Racket macros.

(lambdaland.org)
Development programming languages safety macros

Python Dependency Management: A Raging Inferno

2024-12-15

This article delves into the complexities of Python dependency management, likening it to building a bonfire in a dry forest. The author argues that Python dependencies aren't simply a matter of `pip install`; they encompass project packages, system packages, the operating system, hardware, and the environment itself. Good dependency management is crucial for reproducibility—ensuring consistent results across different environments. The article details version control, environment isolation, definition files, lock files, and other key concepts. It then provides a comprehensive comparison of numerous tools, including pip, venv, virtualenv, pip-tools, Pipenv, Poetry, PDM, pyenv, pipx, uv, Conda, Mamba, conda-lock, and Pixi, analyzing their strengths, weaknesses, and use cases. Finally, the author offers tool recommendations based on different scenarios (administrative privileges, dependency types, operating systems, etc.) and looks ahead to future trends in Python dependency management.

(nielscautaerts.xyz)
Development Python dependency management reproducibility Python tools

LLVM C Library Speeds Up GPUs: Running C Code on GPUs

2024-12-14

The LLVM project has released an exciting GPU C library enabling developers to run libc and libm functions directly on the GPU within C/C++ code. The library supports two main modes: as a supplementary library for offloading languages like OpenMP, CUDA, or HIP; and by directly compiling C/C++ code for the GPU. The article details how to use both modes, including compilation options, linking, and specific builds for AMD and NVIDIA GPUs. This library allows developers to leverage the parallel processing power of GPUs, significantly improving performance without needing deep knowledge of complex GPU programming models.

(libc.llvm.org)
Development GPU programming C library

Buzee: Open-Source Full-Text Search App Released

2024-12-14

Buzee is a cross-platform, full-text search application built with Rust and Svelte. It allows for fast searching of local files, folders, browser history, and more, even extracting text from PDFs and images using OCR. Developed over two years, this project showcases a robust architecture using Tauri for performance, SQLite and Tantivy for indexing, and a clean Svelte frontend. While feature-rich, it still has some areas for future development, and the author is releasing it open-source for others to contribute.

(github.com)
Development full-text search
1 2 3 4 6 8 9