Full-text search across article titles and summaries. Refine with sector, year, content type, and reading-time filters.
Go slices are confusing because they behave as either dynamically sized arrays or fat pointers depending on context, leading to mutability and ownership issues and surprising behaviors like reslicing beyond the length and modifying the capacity.
Slow code deployment, rather than causing meetings, is more likely the reason for them, as organizations increase meeting overhead to compensate for their inability to deploy code frequently enough.
A benchmark comparing Dart and JavaScript code initially showed JavaScript as faster, but this discrepancy was resolved by making sure equivalent data structures (Int64List in Dart) were used. Further investigation revealed that Dart's interrupt checks impacted performance negatively, while JavaScriptCore's optimizations, including modulo strength reduction, contributed to its speed advantage, which was negated by one-line code change in Dart that took advantage of Dart's compiler.
LinkedIn scaled its restriction enforcement system to handle 5 million queries per second using a multi-faceted approach. It used BitSets for efficient boolean storage and Bloom Filters for probabilistic set membership checks. Its final architecture incorporated a Venice database as the central source of truth, Kafka for near real-time updates, and a client layer utilizing a REST API.
Reddit was experiencing slow Rollup-based frontend build times, averaging nearly two minutes for initial builds and 40 seconds for incremental ones. To address this, it adopted Vite, a build tool using ESBuild's JIT compilation. The migration resulted in build times under one second for both initial and incremental builds.
Burnout isn't always caused by working long hours. Often, it's caused by deeper issues during engineering. This author tells two stories about burning out in the same way at both a startup and a big tech company. The burnout was caused by micromanagement, a lack of trust in engineers, the introduction of unnecessary processes, not shipping code to customers, and overpromising.
This engineering manager usually gets questions about project timelines, team performance (including metrics like MTTR and KTLO costs), and the impact of projects on key performance indicators. In this post, he provides practical advice on using project management tools, operational metrics dashboards, and BI tools to gather information quickly and efficiently.
Screen Sharing is a real-time screen-sharing application built with Next.js, WebRTC, and PeerJS. It has room-based sharing, cross-browser support, and a simple interface.
Vince is a self-hosted, privacy-friendly alternative to Google Analytics that offers features like automatic TLS, outbound link tracking, and unlimited sites and events.
LitDB is a TypeScript/JavaScript library that provides type-safe, parameterized SQL builders for SQLite, MySQL, and PostgreSQL. It lets developers write familiar SQL with better safety and portability.
Many SaaS vendors are charging extra for Single Sign-On (SSO), which is increasingly mandated by regulations like NIS2 and DORA. This practice forces companies, particularly regulated ones, into higher, more expensive pricing tiers to meet security and compliance requirements, despite SSO's relatively low implementation cost.
CrRRUX is a relative-ranking score designed to simplify competitor analysis by aggregating Core Web Vitals data (LCP, INP, and CLS) into a single comparative score. The score accounts for “passingness”, continuity, and real user experiences. It can be automated through Google Sheets and the CrUX API.
Structured editing is a method where code editors understand a program's syntax, offering benefits like instant feedback and accurate selections. Structured editors often restrict non-structural editing, which frustrates many programmers who frequently edit code in ways that violate its syntax. A solution to this is incremental parsing, which allows for both structured understanding and free-form editing by maintaining a parse tree in the background, even if the code becomes temporarily invalid.
A 2024 benchmark comparing memory usage across various programming languages while running one million concurrent tasks showed C# (with NativeAOT) to be the most memory-efficient, followed closely by Rust, while Go performed significantly worse than expected.
Hetzner is reducing included data traffic and raising prices for its US-based virtual private servers (VPS), effective December 1, due to a need to balance costs based on regional conditions.
Spotify is making changes to its Web API that will affect functionalities like related artists, recommendations, and audio analysis.
This blog post presents a framework for deciding whether to use new CSS features based on browser support. The framework considers three factors: the fallback experience if the feature isn't supported, the actual browser usage statistics for the specific audience (which may differ from global averages), and the potential harm caused by a broken experience for unsupported browsers. Devs can simulate unsupported browsers by temporarily removing the CSS declaration to assess the fallback and use `@supports` for custom fallbacks when necessary.
React Islands are used to incrementally modernize web applications by integrating React components into existing, statically rendered projects. This approach avoids the pitfalls of complete rewrites by allowing for a piecemeal transition. React Islands involve creating self-contained React components, declaring them in a separate build target, and then calling them from the main HTML, passing data via props and using a shared context for performance.
A web developer transitioning to React Native initially prioritized custom UI components, which resulted in apps that lacked the familiar and polished feel of native apps. They eventually switched to using native iOS and Android UI elements, pre-built components that offer a polished, platform-consistent experience.
Python dependency management is difficult because there are too many tools and no standardized approach. The core problem stems from the need to manage both Python-specific packages and system-level dependencies, often requiring multiple tools and increasing the chance of conflicts. Good dependency management relies on version control, environment isolation (like virtual environments), and the use of definition and lock files for reproducibility.
The “Safe Engineering Manager” focuses on stability, harmony, and meeting expectations, while the “All-In Engineering Manager” pushes boundaries, challenges norms, and deeply invests in outcomes and people. These approaches often clash, as one values calm consistency and the other thrives on relentless passion and change.
Cali is an open-source AI agent that uses a large language model to simplify React Native app development. It provides tools for build automation, device management, dependency management, and more.
The ESLint plugin Perfectionist automatically sorts various code elements (imports, objects, types, etc.) alphabetically, naturally, or by line length.
React Native Screens 4.0.0 introduces improved sheet API support on Android and iOS, preload support for native-stack screens, better iOS animations, support for React Navigation v7, and support for the new React Native versions.
Deno has filed a petition with the USPTO to cancel Oracle's trademark on “JavaScript,” arguing that the term has become generic, Oracle misrepresented evidence during trademark renewal, and the trademark has been abandoned. If successful, this would remove legal barriers, allowing the community to freely use the term “JavaScript” without restrictions.
LinkedIn's journey of building a GenAI application tech stack began in early 2023. It initially used a Java-based midtier but transitioned to a Python-based framework using LangChain for both offline development and online serving. Prompt management evolved from simple string interpolation to a standardized system using Jinja templates and a prompt source of truth.
HackerRank and similar platforms are now inadvertently rewarding proficiency in using AI to solve problems rather than genuine software engineering ability, leading to flawed hiring processes.
Unlike search engines which return nothing when lacking sufficient information, LLMs produce inaccurate but seemingly plausible responses, making "nothing" more helpful than the misleading "something" they provide.
Python's optional type hints are often impractical for this developer's typical small projects because the effort of defining and updating types outweighs the benefits.
Common causes of false positives in Node.js tests include using loose equality comparisons, overly general assertions, shallow equality for deep comparisons, misunderstanding assertion behavior, forgetting to call matchers, misusing mocks, and incorrect regex matching.
A software engineer, working independently, was able to make huge performance improvements in various apps, including a 30% faster Uber app startup, a 3x speed increase in Android UI display, and an 11% speedup in Lucene. These optimizations were accomplished through the use of automated tools and techniques that focused on identifying and resolving inefficiencies in code, such as overly broad synchronization blocks and dynamic method dispatches. While there's often a lack of incentive to make significant performance improvements, there are many cases where there's low-hanging fruit.
Using a feature-based architecture in React apps can make them easier to maintain and scale. This article goes over how to decouple components and data fetching functions. Focusing each on a single feature avoids intertwining vertical features and creating overly complex functions. This approach initially leads to multiple data requests but can be later optimized using `Promise.all` for parallel fetching to improve performance.
This is a collection of tips and advice for working with Postgres databases. It covers how to improve psql usage, optimize queries, and understand the impact of locks and JSONB on application performance. It is important to normalize data and follow the recommendations of the Postgres developers.
This developer found that Google Cloud Run's pay-per-use model, fast scaling, and lack of cluster management overhead made it a better choice cost-wise compared to Kubernetes. Despite some minor workflow inconveniences in Cloud Run, the overall experience was better.
Mentorship should be a continuous process and not just for onboarding. Even people with lots of experience can benefit from mentoring because there is always knowledge to transfer and things to learn from others' experiences.
The Jekyll-SQLite plugin allows Jekyll users to use SQLite databases as data sources for their websites. It supports site-level, per-page, and prepared queries, which can use existing data as parameters.
jsontr.ee is a lightweight JavaScript library that visualizes JSON data as interactive, dynamically-positioned tree diagrams using SVG.
LLMs are likely to be an unprofitable business, just like airlines, an industry with historically poor profitability. This is due to an unfavorable industry structure for LLM makers, characterized by a powerful single supplier (Nvidia), high buyer fickleness, numerous competitors, and easy market entry for new players.
There are three levels of LLM application within businesses: foundational building blocks (chat, embeddings, and semantic search), basic applications (code generation, summarization, and analysis), and advanced applications (RAG, agents, and swarms).
A benchmark of one billion nested loop iterations across various programming languages revealed that C/clang and Rust were the fastest (0.50 seconds), while Python and R were the slowest (over 70 seconds).
The Java compiler is extremely fast, but build tools add a lot of overhead.
Canva developed a system that used generative AI to create a synthetic dataset of realistic queries and designs. This let the company perform offline evaluation of search algorithm changes. The system was meant for privacy, which meant that user queries were hidden from training. The approach allowed for rapid, reproducible testing of code changes locally, speeding up Canva's development process.
Slack's log search engine, Astra, initially used fixed-size data chunks, leading to wasted disk space and increased infrastructure costs due to underutilized chunks. To address this, the Slack team redesigned Astra to use dynamic chunks. This involved implementing a first-fit bin packing algorithm to optimize chunk assignment across cache nodes, using Zookeeper for persistent data tracking.
The problem with legacy code isn't the code itself, but rather poor knowledge transfer and maintainability among developers. Long programmer tenure, well-architected and documented code, effective knowledge-sharing practices, and the use of standardized tech and frameworks can prevent code from becoming legacy code.
A "codin' dirty" approach is better than following a "clean code" philosophy. This means writing larger, contextually relevant functions, with integration tests over unit tests for their stability and higher-level perspective. It also means minimizing the number of classes and interfaces to simplify project complexity.
Complex code, persistent frustration with debugging, and the rise of AI tools can make developers fear that they are not good enough. Progress, even if imperfect, constitutes "good enough.”
SQLiteStudio is a free, open-source, cross-platform application for creating, editing, and browsing SQLite databases.
Rill is a lightweight Go toolkit that makes concurrent programming easier by providing composable, channel-based functions for common concurrency tasks, like batching, error handling, and order preservation.