Dev · Top stories
KubeCon Speakers Discuss Shifting from Project to Product Thinking for Platform Development
Eugenia Bergman and Hagen Tonnies presented at KubeCon & CloudNativeCon Europe on their shift from project-oriented to product-oriented thinking for platform development, emphasizing user adoption and clear interfaces. This approach aims to reduce coordination overhead and align development with actual user value by treating internal platform capabilities as products with producers and consumers.
JioHotstar Details Distributed Engineering for Personalized Ad Requests at Scale
JioHotstar published an engineering overview of its ad request workflow, explaining how it coordinates distributed services to select and deliver personalized advertisements during video playback. This matters as it details how a large streaming platform handles real-time ad decisions under strict latency and high traffic conditions.
Comparing build2 performance against Ninja for C++ project compilation
A comparison is being conducted to see how a modern, native build system like build2 performs against Ninja, which is considered a performance benchmark for build systems. This matters for developers interested in optimizing C++ project compilation times.
Clean Code Practices Can Lead to Poor Performance, According to Analysis
An analysis suggests that several common "clean code" guidelines, particularly those emphasizing polymorphism over conditional statements, small functions, and object encapsulation, can negatively impact software performance. This challenges widely accepted programming advice by demonstrating measurable runtime costs associated with these practices.
Book Corners will not sync contributions back to OpenStreetMap due to policy complexity
The Book Corners project will not implement a feature to sync user-submitted public bookcase locations back to OpenStreetMap (OSM). This decision was made because the process of contributing data to OSM, even with human moderation, is subject to strict import and automated edit guidelines that require extensive planning and community engagement, making the integration impractical.
IBM i (OS/400) Operating System's Unique Architecture and History Detailed
The IBM i operating system, originally AS/400, is highlighted for its unique architecture that integrates a relational database and treats everything as an object, diverging from typical file-based systems. This system, developed in the 1980s, aimed to combine the advanced features of System/38 with the user-friendliness of System/36, and its design prioritized backward compatibility through the TIMI abstraction layer.
Diátaxis: A Systematic Approach to Technical Documentation Authoring
Diátaxis is a framework for technical documentation that categorizes content into tutorials, how-to guides, technical reference, and explanation based on user needs. This approach helps organize documentation content, style, and architecture, benefiting both users and creators of documentation.
Pgtestdb's template cloning for Postgres testing offers fast setup times
A comparison of pgtestdb, a Go/Postgres testing package utilizing Postgres template databases, found its setup time to be comparable to a schema-based testing approach. While the overall test suite using pgtestdb was slower due to other optimizations in the schema-based method, pgtestdb's database cloning is faster than migrating a test database from scratch. This matters for developers seeking efficient database testing strategies, particularly for end-to-end testing scenarios.
Netflix Details Device Capability Modeling for Feature Management and Analytics
Netflix developed a comprehensive device capability data model and integrated feature flags to manage features across its diverse device ecosystem. This system allows Netflix to understand hardware limitations, optimize user experience, and make data-driven decisions about feature deployment, improving feature penetration and innovation speed.
Revisiting Abstractions: Beyond Existential Hiding in Computer Science
This article explores alternative approaches to traditional existential abstractions in computer science, where implementation details are hidden. It discusses how Application Binary Interfaces (ABIs) and debuggers like DWARF opt out of this hiding to enable interoperability and meta-level operations. This re-evaluation suggests that not all abstractions benefit from complete concealment of their underlying realizations.
Experiment Measures Economic Benefit of Refactoring Agent-Generated Code
An experiment was conducted to quantify the economic benefit of refactoring a large codebase primarily written by AI agents. The experiment aimed to demonstrate that refactoring reduces future token consumption for making changes in agent-generated code.
DNS Management Should Adopt Infrastructure as Code Principles
DNS management should be treated with the same operational rigor as other infrastructure components, such as servers and cloud resources. This approach, termed "domain management as code," aims to prevent outages caused by misconfigurations and improve accountability.
Gpiozero Library Simplifies Raspberry Pi GPIO Programming with Abstraction
The gpiozero Python library for Raspberry Pi simplifies General Purpose Input/Output (GPIO) programming by abstracting hardware details into device-focused APIs. This approach allows developers to program in terms of device actions rather than low-level electrical signals, supporting procedural, event-based, and declarative programming styles. The library's value stream manipulation features enable advanced control of connected devices.
Jef Raskin's Proposed Apple Calculator Language and His Views on Programming Languages
Newly surfaced documents from Jef Raskin, an early Apple employee, reveal his proposal for a "calculator" language in 1979, which he envisioned as a potential programming language for the Macintosh. The documents also detail Raskin's critical opinions on contemporary programming languages like BASIC, Fortran, PL/1, Pascal, and Lisp, while praising APL.
Godot Engine Used for Commercial VR Development and PSVR2 Porting
A developer shared experiences from using the Godot engine for commercial VR projects and porting to PSVR2, detailing the challenges and necessary engine work. The report indicates that while Godot is viable for commercial VR, it required significant custom development, incurring an estimated £80k in "early adopter tax."
Developer Trust in Tools, from IDEs to AI Agents, is Shaped by Customization and Consistency
This article explores how developers build trust in their tools, contrasting highly customizable traditional IDEs like Vim and Emacs with newer AI coding agents. It highlights that while AI tool usage is rising, developer trust in these tools is declining due to their evolving capabilities and lack of precision, emphasizing that trust is built through consistency and the ability to integrate tools into established workflows.
Benchmarking DuckDB vs. SQLite for Observability Data on Low-Cost Hardware
A benchmark compared DuckDB and SQLite performance on a $16.49/month server for observability data, finding DuckDB significantly outperforms SQLite in write throughput and query capacity. This comparison provides data for self-hosting telemetry stacks on small servers.
Exploring Peculiar User Interfaces in the Demo Scene
The demo scene, a digital art subculture, often develops its own unique tools with unusual user interfaces due to a combination of factors including inexperience, habit, experimentation, and aesthetic desires. This practice has led to distinctive software designs, particularly on platforms like the Amiga, which are explored through examples like Elite Sinus Producer. The article highlights how these interfaces, despite their quirks, serve the specific needs of demo creators in producing real-time visual effects.
The 1983 Release of BSD 4.2 Introduced the Sockets Interface, Standardizing Network Access
In 1983, the University of California, Berkeley (UCB) released version 4.2 of its UNIX operating system, Berkeley Standard Distribution (BSD), which included the sockets model for networking. This release standardized network access for UNIX systems, enabling a significant increase in global access to network services.
Multi-cursor support in Wayland explored for collaborative computing
An investigation into the current state of multi-mouse cursor support in Wayland desktop environments reveals surprising progress and potential for collaborative use cases. The findings highlight the feasibility of multiple users controlling a single desktop with individual input devices, alongside the release of tools to improve this functionality. This development could enable new forms of interaction for pair programming, gaming, and in-application collaboration.
Distinguishing Buttons and Links for HTML's Proposed Button Actions
A new proposal, Button Actions, aims to add `action` and `method` attributes to HTML buttons. This feature highlights the fundamental difference between buttons, which trigger actions within the current context, and links, which represent independently navigable destinations.
EYG: A Programming Language Designed for End-User Automation
A new programming language, Eat Your Greens (EYG), is being developed to address the frustrations experienced by technically-minded non-professional developers using low-code/no-code tools. EYG aims to provide a more suitable language for end-user programming by focusing on features that cater to users who are not full-time developers.
Tokio Task Scheduling Prioritizes Progress Over Strict Ordering in High-Throughput Workloads
A Rust service processing events with Tokio tasks observed that the scheduler prioritizes making progress on all tasks rather than strictly ordering their completion, even for short-lived tasks. This behavior means that tasks spawned earlier do not necessarily finish earlier, which is important for understanding performance in high-concurrency Rust applications.
Johannes Schickling Discusses Transition to Client-Side Event Sourcing and Local-First Development
Johannes Schickling, founder of Prisma, discussed his shift from traditional three-tier web stacks to a local-first approach using client-side event sourcing and SQLite for his music curation app, Overtone. This transition highlights the architectural considerations and trade-offs involved in moving data bottlenecks from servers to clients for improved performance and responsiveness.
Misago Project Considers Replacing React.js with Htmx for UI Interactivity
The Misago project is evaluating removing React.js from its codebase and adopting Htmx to manage UI interactivity. This change aims to address issues like duplicated code, performance bottlenecks, and complex development workflows caused by the current dual Django template and React.js component architecture.
Proposal for a new email protocol, HMTP, built on existing web technologies
A new email protocol, HMTP (Hypertext Mail Transfer Protocol), is proposed as a successor to SMTP, leveraging existing web standards like HTTP, TLS, and WebFinger. This design aims to address SMTP's limitations by re-imagining email infrastructure using battle-tested components, though it would not interoperate with current email systems.
Unix spell checker fit dictionary into 64KB RAM using data structures and compression
The original Unix spell checker, developed in the 1970s by Douglas McIlroy, managed to fit a 250KB dictionary into 64KB of RAM on a PDP-11 computer. This was achieved through linguistic stemming, early use of Bloom filters, and a custom hash compression algorithm that approached the theoretical compression limit. The engineering methods used demonstrate how to solve problems under strict resource constraints.
Systemd Linger Feature Clarified for Debian Users
The systemd "linger" feature, often misunderstood as necessary for screen/tmux/nohup to persist after logout, is not required for this functionality in Debian's default configuration. The article clarifies how systemd-logind's KillUserProcesses option and the linger feature interact, and how to manage linger for user accounts. This information helps users understand systemd behavior regarding process persistence and manage it effectively.
Fil-C Introduces New Memory Safety Approach for C/C++ with GC and InvisiCaps
Fil-C offers a new method to achieve memory safety in C and C++ by combining garbage collection and InvisiCaps, causing programs to panic on invalid memory access. This development provides an alternative to Rust's compile-time guarantees and traditional C/C++ manual memory management, potentially expanding options for developers focused on software security.
Potential Android Restriction on On-Device ADB Connections Discussed in IssueTracker
A Google IssueTracker discussion indicates a potential future restriction on on-device Android Debug Bridge (ADB) connections to enhance security. This change could affect applications that rely on local ADB access, such as Shizuku-based tools. The discussion highlights Google's consideration of security implications for on-device ADB usage.
Principles for Effective Build Systems, Contrasting Civ with Make and Bazel
This article discusses core principles for effective build systems, using the Civ build system as an example and contrasting it with Make and Bazel. It emphasizes the importance of explicit inputs and outputs and programmatic configuration for adaptability across target systems.
Personalization is a Ranking Problem Requiring Architectural Solutions
Effective personalization in products is fundamentally a ranking problem, not a quality issue, and often fails due to architectural limitations rather than signal collection. Systems need to weigh user intent, item quality, user history, availability, and business priorities simultaneously and in real-time to deliver relevant results. The challenge lies in combining these diverse signals efficiently during query-time ranking.
Platform Team Improves Compliance Adoption by Simplifying Governance and Prioritizing Developer Experience
A platform team improved compliance adoption by simplifying governance, prioritizing key issues, and rolling out changes incrementally, as detailed by Davide de Paolis. This approach addressed initial developer friction caused by new workflows and poor documentation, leading to successful adoption through prevention, detection, and communication.
DBOS Project Proposes Database-Centric Architecture for Workflow Orchestration
A presentation introduced the DBOS project, an architectural approach that compiles application workflows directly into existing databases. This method aims to simplify the management of distributed system state and improve failure handling, particularly for complex AI-driven processes.
GitHub Copilot introduces canvas extensions for interactive workflows
GitHub has launched canvas extensions within the Copilot app, enabling developers to create interactive interfaces for various tasks. These canvases allow real-time collaboration between developers and agents, making it easier to visualize information and manage workflows more effectively.
Reduced costs of coding agents enhance home device automation
The decreasing cost of coding agents is making reverse-engineering and automating home devices more accessible. This shift changes the ROI perception for programmers, as maintenance concerns become less daunting.
Guide on Building a Custom Metrics Exporter for Kubernetes
A guide details the steps to create a custom metrics exporter for Kubernetes, allowing for the collection of external application metrics beyond CPU and memory. This approach enables better scaling decisions and integration with Prometheus and HorizontalPodAutoscaler.
Addressing Unhealthy Leadership Models in Technology Companies
A senior engineer in a large company discusses unsustainable work pace due to management's unrealistic expectations, seeking advice on influencing change. A related discussion highlights the tech industry's pattern of idealizing authoritarian leaders while undermining collaborative management models.
Overview of Lisp Dialects for Beginners
The article discusses various Lisp dialects and their differences, particularly for beginners. It emphasizes that while choosing a dialect matters, understanding Lisp concepts takes precedence over the specific dialect selected.
Understanding Agentic Loops in Autonomous Agents Development
The concept of agentic loops is elaborated into three distinct functional loops that define their operations. This clarification is crucial for developers to understand how to integrate chat completion and tool usage effectively in autonomous agent systems.