标签：#programming

Apache Fory is a blazingly fast multi-language serialization framework for idiomatic domain objects, schema IDL, and cross-language data exchange. Key Features For 1.0 Release: Unified xlang type system and xlang is default serialization mode now across java/python/c++/rust/go/c#/swift/javascript/dart/kotlin/scala. Decimal, bfloat16, dense array support for xlang serialization. Android serialization and Java annotation processor support Kotlin xlang, KSP, and schema IDL support Scala schema IDL support and scala3 macro derived serializer Serialization performance improvements submitted by /u/Shawn-Yang25 [link] [留言]

Tabla de Contenidos Objetivo Restricciones de los Errores Basados en Texto Errores Personalizados en Go Conceptos Clave Implementar e Inspeccionar Errores Casos de Uso Comunes Para no morir en el intento y consejos que no pediste Conclusiones del Tema Objetivo Aprender a diseñar tipos de errores personalizados con metadatos de negocio en Go y a propagarlos correctamente a través del flujo de la aplicación sin perder su tipo ni su información de origen. Restricciones de los Errores Basados en Texto En programas sencillos, el uso de errors.New es perfecto. Sin embargo, en aplicaciones empresariales los errores necesitan transportar datos estructurados. Por ejemplo, si una validación de entrada falla, el frontend no solo quiere saber que "hubo un error", necesita saber qué campo exacto falló (ej. email ) y qué regla se violó (ej. formato inválido ). Si solo devolvemos una cadena de texto, la capa superior de nuestra aplicación tendría que parsear el texto del error con expresiones regulares para extraer los metadatos. Esto es extremadamente ineficiente, propenso a errores de formato y acopla la lógica interna a los mensajes de texto visibles al usuario. Tipos de Errores Comunes en Go Antes de analizar cómo propagar y envolver errores, es fundamental comprender los dos patrones principales que se utilizan en Go: Sentinel Errors : Son variables globales predefinidas que representan un estado de error estático y específico. Se definen a nivel de paquete y se comparan directamente por valor. Ejemplos estándar: io.EOF , sql.ErrNoRows . Creación: Generalmente declarados con errors.New (como var ErrNotFound = errors.New("not found") ). Custom Structs (Errores estructurados personalizados): Son estructuras que implementan la interfaz error y contienen campos adicionales para transportar metadatos dinámicos del fallo en tiempo de ejecución (como códigos de estado o parámetros de entrada). Creación: Un struct personalizado que implementa el método Error() (ej. type ValidationErr

Bugs, crashes, glitches... Game development is full of them, and even experienced teams run into issues. But while no game is perfect, that doesn't mean we should stop chasing better quality. In this live session, we'll look at why even seasoned game development teams make mistakes and how you can reduce the number of issues in your own projects. What's the talk about? The speaker, Gleb Aslamov, developer advocate and static analyzer developer at PVS-Studio, will walk you through common and less obvious reasons behind code errors, share real-world bug examples from actual game projects, discuss development practices that help prevent bugs before release, and demonstrate tools designed to catch those issues early. Gleb will show some amusing bug examples from projects like osu!, GZDoom, and SanAndreas Unity. The discussion will cover how code reviews, testing, and CI/CD, combined with profilers, dynamic analyzers, and static analyzers, can help detect issues long before players ever encounter them. Also, expect to see static analysis in action, including warnings that reveal performance-sensitive issues and other hidden problems in game code. When? Mark your calendar for June 2, 2026, at 1:00 PM UTC+1 . Join the live talk and learn how to make your game code more reliable—one bug at a time. P.S. And don't forget to check your inbox to confirm the registration!

The numbers just dropped. April ecommerce growth came in at 11% more than double the total retail sales growth rate for the same period. For developers building ecommerce infrastructure, this isn't just a market stat. It's a load test result. And a lot of backends are failing it quietly. Here's what 11% ecommerce growth actually means technically and the five infrastructure decisions that determine whether your client captures it or gets buried by it. What 11% growth means at the infrastructure level 11% more orders. 11% more simultaneous channel requests. 11% more concurrent inventory mutations across every connected platform. The sync architecture that handled last year's volume handles this year's volume — until it doesn't. The failure mode is predictable: javascript// Last year's volume const ordersPerDay = 500; const syncWindowsPerDay = (24 * 60) / 15; // 96 const ordersPerWindow = ordersPerDay / syncWindowsPerDay; // 5.2 // This year's volume at 11% growth const ordersPerDayNow = ordersPerDay * 1.11; // 555 const ordersPerWindowNow = ordersPerDayNow / syncWindowsPerDay; // 5.8 // During a flash sale at 10x velocity const peakOrdersPerWindow = ordersPerWindowNow * 10; // 57.8 // 57 orders processed against potentially stale stock per 15-minute window // Up from 52 last year seemingly small, meaningfully worse at the tail The difference between 52 and 58 orders per window sounds minor. At the tail peak flash sale velocity, multiple channels firing simultaneously — it's the difference between manageable oversell exposure and a crisis. The five infrastructure decisions that matter Sync architecture polling vs event-driven This is the highest leverage decision. Everything else builds on it. javascript// Polling — what most systems still run // Sync lag: up to 15 minutes // Cost at 11% growth: proportionally worse setInterval(async () => { const stock = await getSourceOfTruth(); await syncToAllChannels(stock); }, 15 * 60 * 1000); // Event-driven — sync lag approache

Recently, Apache SeaTunnel welcomed several talented and highly motivated new Committers, and Wang Xuepeng is one of them. As a long-time contributor, Wang Xuepeng’s promotion to Committer was no coincidence. Over the years, he has quietly contributed a tremendous amount to the community, and everyone has witnessed his dedication. From first stepping into the open-source world to becoming a Committer of an Apache top-level project, he has accumulated plenty of stories and valuable insights along the way. What inspired his journey? What experiences and lessons does he want to share with the community? Let’s take a closer look at this exclusive interview with him! Personal Introduction Interview Transcript How long have you been involved in open source? What attracts you to open source? I started getting involved in open source in 2023. What attracts me most is the sense of achievement when the code I write can actually be used within the industry. When did you start contributing to SeaTunnel? What was the trigger? I joined WhaleOps in 2023, which was also when I first started engaging with open source. Now that you’ve been elected as a SeaTunnel Committer, could you summarize your contributions to the community, including both code and non-code contributions? Most of my major feature PRs have focused on building SeaTunnel’s metadata capabilities. When running SeaTunnel jobs and writing job configurations, users often need to manually enter datasource connection information. For file-based tasks, users also need to manually define field mappings. To address these issues, I designed an SPI interface called MetadataProvider . The interface mainly exposes two methods: Map<String, Object> datasourceMap(String connectorIdentifier, String metaDataDatasourceId); Optional<TableSchema> tableSchema(String metaDataTableId); Previously, some users in the community mentioned that datasource usernames and passwords were stored in Nacos with read-only access permissions. In scenario

submitted by /u/Efficient-Public-551 [link] [留言]

If you’ve been doing Android development for a while, you know the drill. You start a new project,...

AI wrote the code in 30 seconds Three lines A simple function I prompted it generated I copied It...

submitted by /u/mrpro1a1 [link] [留言]

submitted by /u/Xaneris47 [link] [留言]

The Problem We Were Actually Solving During load testing at 50k concurrent hunters hitting the hunt endpoints, p99 latencies stayed under 200ms. But at 270k concurrent users in production, the hunt page suddenly took 1.8 seconds to load, triggering cascading 502s from our CDN. The error surfaced in Datadog as hunt_page_render_time_bucket{le=2.0} = 42% while le=0.5 dropped to 18%. The fingerprints were identical across three regions: high latency correlated exactly with Redis cache miss rate spiking from 12% to 48% during the hunt start window. Our cache-aside pattern with a 30-second TTL was amplifying miss storms. We discovered that the treasure hunt start time was synchronised by marketing campaigns. When the clock struck 10:00:00 UTC, 270k users hit the endpoint within 30 seconds. Each request would check the cache (miss), fetch from PostgreSQL, render the page, and write the cache entry. But PostgreSQL couldnt keep up with 9k queries per second during that window, causing query queueing and connection exhaustion. The Redis layer, designed for 150k ops/sec, was not the bottleneck. The database was. What We Tried First (And Why It Failed) Our first attempt was to increase Redis TTL from 30 seconds to 5 minutes. This reduced cache misses from 48% to 24%, and p99 latency improved to 650ms. But at 320k concurrent users, the latency still spiked to 1.4s because the underlying database queries were still hitting the same table with the same indexes. The Redis layer was masking symptoms, not solving the root cause. Next, we tried database read replicas. We spun up three read replicas and routed hunt queries to them using a weighted service mesh. This worked for a few minutes, but then we hit replication lag. The replicas fell 800ms behind primary, causing hunt pages to display stale treasure locations. Our operators started getting customer complaints about seeing the wrong treasure coordinates. We rolled back within 15 minutes. We even tried increasing PostgreSQL share

[ Removed by Reddit on account of violating the content policy . ] submitted by /u/Economy_Goose_8561 [link] [留言]

🚀 The Golden Age of “Just Ship It” A few months ago, I started building side projects differently. Instead of: Planning architecture Reading documentation Writing every function manually I started doing this: “Build me a responsive dashboard with authentication, dark mode, PostgreSQL integration, and Stripe payments.” And somehow… It worked. AI tools can now generate: APIs UI components Database schemas Docker configs Tests Documentation We’ve entered the era of vibe coding . And honestly? It feels amazing. What Is “Vibe Coding”? Vibe coding is when you: Describe what you want Let AI generate most of the implementation Keep iterating through prompts Instead of engineering every detail manually, you steer the vibe of the application. Tools making this popular: Cursor GitHub Copilot Claude Windsurf ChatGPT Replit AI You become less of a code writer and more of a: reviewer editor product thinker debugger At least in theory. The First Few Days Feel Like Magic The productivity boost is unreal. You can build in hours what used to take days. Things that once required: Stack Overflow endless documentation tabs debugging sessions at 2 AM …now happen through prompts. You feel unstoppable. Then Production Arrives And production is where the vibes end. Because production doesn’t care if the demo looked cool. Production cares about: edge cases reliability security scalability maintainability observability This is where AI-generated code starts exposing cracks. Problem #1: The Code Looks Right This is the dangerous part. AI code is often: clean formatted nicely modern-looking confident But hidden underneath: unnecessary complexity duplicated logic subtle bugs bad abstractions Problem #2: Hallucinated Architecture AI is very good at generating: components snippets isolated features It is much worse at: long-term architecture consistency scaling systems over time You start noticing: 4 different API patterns duplicated utilities random folder structures inconsistent state management

The advice was correct. That's what makes it interesting. A creator with a large audience recently described the problem precisely: unused project ideas atrophy. They gave the prescription: externalize the idea, commit to a 30-60-90 day sprint, get into a community that holds you accountable, treat a deployed URL as the only real milestone. The audience listened. The ideas stayed unshipped. Not because the advice was wrong. Because advice is not a mechanism. The gap between diagnosis and structure There's a category of knowledge that's completely useless without enforcement. "You should exercise consistently." Correct. Also irrelevant for the 80% of people paying for gym memberships they don't use. "You should ship your side project in 30 days instead of perfecting it." Also correct. Developers have been hearing this for years. The projects that were "almost done" last year are still almost done. The advice identifies the problem. The problem persists. The gap between them is not information. It's structure. Discipline is the tax on misalignment One phrase from the transcript stayed with me: "Discipline is the tax on misalignment." The insight is sharper than it sounds. When what you're building doesn't connect to why you're building it, every work session requires a new act of will. You're not building forward momentum — you're paying an interest payment on a debt you haven't quite defined. This is why most sprint systems fail. They give you the structure (30 days, daily tasks, accountability partner) but skip the alignment check. The structure holds for two weeks. Then it becomes another system you're "almost following." What the AI makes worse Here's where it gets specific for developers using AI tools on side projects. The AI is genuinely useful. It generates architectures, writes boilerplate, outlines features, summarizes where you are. The output looks like forward motion. But the AI has no ground truth about your actual progress. It has your files and your pr

The Problem We Were Actually Solving Treasure hunts in Hytale arent just about generating loot. Theyre about generating simultaneous loot across thousands of players while keeping the world state consistent. We started with the assumption that events are stateless notifications: a hunt starts, we fire an event, clients react. That model worked fine when we had 200 concurrent players. At 2,000 players, the event bus turned into a 40 MB/s firehose of JSON blobs. Each loot drop required serializing the entire chunk state—blocks, entities, metadata—so clients could render the drop in real time. The JVMs G1GC couldnt handle the allocation rate. Every 47 minutes, a GC cycle would pause for 4.2 seconds, the chunk cache would fragment, and the server would hard crash with an OutOfMemoryError in net.minecraft.server.MinecraftServer#processQueue. The real problem wasnt the hunt logic. It was the architectural laziness of treating events as a catch-all glue layer instead of a boundary layer with explicit interfaces. What We Tried First (And Why It Failed) We tried Kafka as the event bus. The plan was to shard hunts by region and stream loot drops as compacted topics. The first run worked for about 6 hours before the compacted topics started to bloat. Each hunt was generating 700 KB of serialized chunk state per drop. At 30 drops per hunt per minute, thats 21 MB per hunt per minute. With 400 active hunts, the brokers couldnt keep up. The lag grew to 12 seconds, clients started rubber-banding, and we got a flood of Discord reports: You sank my boat! The event stream was now the bottleneck, not the event source. Next, we tried Redis Streams with a Lua script to aggregate loot drops per chunk. Within 30 minutes, we hit the 4 GB maxmemory limit because Lua scripts were stacking dropped items in memory while waiting for the next batch. The script was elegant—O(1) per drop—but the memory footprint made it unusable in production. Finally, we tried a sidecar service: a small Go process

I understand why so many people are questioning software engineering right now. Every week there’s another headline saying AI will replace developers. Junior engineers are worried there won’t be jobs. Senior engineers are wondering how long their experience will stay valuable. And honestly, if you spend enough time on tech Twitter or LinkedIn, it can start feeling like the industry is collapsing in real time. But after using AI heavily in my day-to-day work as a software engineer, I’ve started seeing things differently. AI didn’t make me feel less useful. It made me feel more capable. Before AI became part of my workflow, a lot of engineering time disappeared into things that were mentally draining but necessary: repetitive refactoring debugging small issues writing boilerplate digging through documentation trying to remember syntax cleaning up legacy code writing SQL queries optimizing simple functions translating vague tickets into technical tasks None of these tasks were impossible. They were just time-consuming. Now, a lot of that friction is reduced dramatically. One of the biggest changes I noticed was backlog cleanup. Tasks that used to sit untouched because nobody wanted to deal with them suddenly became manageable. Not because AI magically solved everything. But because it helped reduce the “mental startup cost” of difficult tasks. Sometimes all you need is: a starting point a refactored example help understanding unfamiliar code a faster debugging path quick documentation summaries That momentum matters more than people realize. A task that feels overwhelming at 9AM suddenly becomes achievable when AI helps break it down. I also noticed we started delivering faster as a team. Not in a “replace developers with AI” kind of way. More in a: less context switching faster research quicker prototyping fewer hours stuck on repetitive problems better ticket breakdowns improved communication kind of way. The interesting part is that AI didn’t just help with coding.

I am a software developer who has been using LLMs extensively at work. I wanted to develop a foundational understanding of LLMs, but have no background in machine learning or statistics. So, I started to read and take notes with the goal to eventually write up a developer's guide to the foundations of LLMs. The article kept growing, so I have split it into four parts. This is the first in the series. Hope this helps! submitted by /u/Normal-Tangelo-7120 [link] [留言]

submitted by /u/henk53 [link] [留言]

submitted by /u/teivah [link] [留言]

submitted by /u/tanin47 [link] [留言]