标签：#programming

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

This article covers Node.js garbage collection (Mark-and-Sweep), memory leaks, and practical techniques for debugging them using Clinic.js, heap dumps, and heap snapshot comparisons. submitted by /u/cryptomallu123 [link] [留言]

As announced in this blog post on June 18, 2026, Gemini CLI and Gemini Code Assist IDE extensions...

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

Originally published on lavkesh.com I recall one of the first design decisions for our payments platform, which was to deploy an in-memory cache for low-latency access to customer account balances. The architecture diagrams looked clean, with Go services using sync.Once-initialized maps in memory, bypassing the database for sub-millisecond reads. However, this approach worked as expected for only three months, until users started reporting inconsistent charges on receipts. The problem surfaced at peak hours when concurrent updates to the same balance would overwrite each other. For instance, the account balance for user ID 12345 went from $1,200 to $850 to $1,200 again within seconds, leaving the cache in a state that defied the database of record. Engineers stared at the logs, baffled by the mismatch between transactions and cached values, because the team had not accounted for the fact that memory maps are not thread-safe by default in Go. Debugging revealed the fundamental error: we were optimizing for speed without considering write-through guarantees. The cache treated concurrent requests as idempotent, which they were not. During a single user’s purchase flow, multiple goroutines could validate the balance, each reading a stale value from memory before any had a chance to commit updates. We had to shift to Redis with explicit lock keys and time-to-live settings, adding 4 milliseconds of latency but ensuring atomicity. The cache also invalidated itself only when a change occurred, not when an upstream source updated. We discovered this when the accounting team reconciled overnight and adjusted balances based on fee settlements - the cache never reflected these updates until it expired naturally. To fix this, we had to implement message queues to broadcast invalidation events across all services. What started as a performance optimization became three nights’ worth of rewriting concurrency models. This experience taught me two concrete lessons about distributed

You think your AI is just helping you write code. In reality, it's built a logging system on your machine that you never knew existed. Every conversation. Every code snippet. Every file path. Every time you asked "what was my password again?" — permanently archived, without your knowledge. How It Started: An Accidental Discovery I was about to sell my old laptop and decided to clean up my data first. I opened Claude Code's config directory — ~/.claude/ — intending to just remove my API key. Then I saw this: history.jsonl 243 KB / 695 lines sessions/ conversation metadata session-env/ environment variables shell-snapshots/ command execution snapshots telemetry/ 63 telemetry files projects/ 19 project directories ├─ interview-prep/ 31 sessions / 20 MB ├─ spring-ai/ 11 sessions / 13 MB └─ ... 17 more I thought I was just writing code. My computer thought it should record everything. What's Inside These Files history.jsonl — Everything You Ever Asked 695 entries. Every single thing I typed into Claude Code. Including: "I forgot my database password — can you check what passwords were configured in the project files?" "How do I view the database password?" Pasted code snippets Every /model , "who are you?", and project path You casually ask about a password once. It's permanently stored. projects/ — Full Conversation Transcripts (43 MB) If you think history.jsonl only storing user input isn't so bad — you haven't seen this yet. Inside ~/.claude/projects/ , every project directory contains .jsonl files. Opening one 2.3 MB session file: Content Count AI responses 590 AI internal thinking blocks 272 Tool calls 101 Tool call results (including file paths) 100 File history snapshots 208 Every conversation. Every AI response. Every internal reasoning step. Every file operation — what was read, what was modified, what was executed — all written to this file. shell-snapshots/ — Traces of Everything You Ran Your system PATH. Installed tools. Java version. All sitting in command s

submitted by /u/Adventurous-Salt8514 [link] [留言]

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

The Prizes for the SecDim AppSec Village Wargame CtF at DEF CON 34 has been announced! Build and submit a challenge and get a chance to Win a ROG Xbox Ally if your challenge submission wins 1st Place! Challenge submissions close on 31 July. https://sessionize.com/appsec-village-wargame

𝗦𝗮𝘆 𝗵𝗲𝗹𝗹𝗼 𝘁𝗼 𝗟𝘂𝗺𝗼𝗿𝗮 — 𝗧𝗵𝗲 𝗨𝗹𝘁𝗶𝗺𝗮𝘁𝗲 𝗕𝗼𝗼𝘁𝘀𝘁𝗿𝗮𝗽 𝟱 𝗔𝗱𝗺𝗶𝗻 𝗗𝗮𝘀𝗵𝗯𝗼𝗮𝗿𝗱 𝗨𝗜 𝗞𝗶𝘁. 💎 🔗 𝗚𝗶𝘁𝗛𝘂𝗯 𝗥𝗲𝗽𝗼: https://github.com/Chetankumar-Akarte/lumora 🔗 Demo: https://renukatechnologies.in/demo/lumora/ Don't forgot to 🤩 Star and 👉 Fork the Repo 𝗟𝘂𝗺𝗼𝗿𝗮 is a modern, responsive 𝗕𝗼𝗼𝘁𝘀𝘁𝗿𝗮𝗽 𝟱 𝗔𝗱𝗺𝗶𝗻 𝗗𝗮𝘀𝗵𝗯𝗼𝗮𝗿𝗱 𝗨𝗜 𝗞𝗶𝘁 designed for teams that need a polished, enterprise-ready control center without the bloat. Whether you are building for SaaS, CRM, E-commerce, or internal analytics, Lumora provides a scalable, token-driven foundation to speed up your workflow. 𝗟𝘂𝗺𝗼𝗿𝗮 is the result: a complete admin ecosystem featuring everything from KPI blocks and ApexCharts to full E-commerce management flows and authentication screens. 𝗪𝗵𝗮𝘁’𝘀 𝗶𝗻𝘀𝗶𝗱𝗲? • Full UI Kit with basic and advanced components. • Enterprise pages (Users, Roles, Permissions, Invoices). • Interactive apps like Calendar and Contacts. • Clean, token-driven styling for consistent design. 𝗧𝗲𝗰𝗵 𝗵𝗶𝗴𝗵𝗹𝗶𝗴𝗵𝘁𝘀: • Bootstrap 5.3 • ApexCharts & Chart.js • Vanilla JavaScript • Mobile-first design 𝗞𝗲𝘆 𝗛𝗶𝗴𝗵𝗹𝗶𝗴𝗵𝘁𝘀: • 𝗠𝗼𝗱𝗲𝗿𝗻 𝗧𝗲𝗰𝗵 𝗦𝘁𝗮𝗰𝗸: Built with Bootstrap 5.3, Vanilla JS, and CSS3 using a module-first architecture. • 𝗖𝗼𝗺𝗽𝗿𝗲𝗵𝗲𝗻𝘀𝗶𝘃𝗲 𝗗𝗮𝘀𝗵𝗯𝗼𝗮𝗿𝗱𝘀: Includes layouts for Analytics, CRM, Project Management, HRM, and more. • 𝗙𝗲𝗮𝘁𝘂𝗿𝗲-𝗣𝗮𝗰𝗸𝗲𝗱 𝗔𝗽𝗽𝘀: Ready-to-use interfaces for Advanced Chat, Kanban boards, Email, and File Management. • 𝗗𝗮𝗿𝗸 & 𝗟𝗶𝗴𝗵𝘁 𝗠𝗼𝗱𝗲𝘀: Clean, professional visuals with seamless theme switching. • 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 𝗙𝗿𝗶𝗲𝗻𝗱𝗹𝘆: Modular CSS, reusable partials, and organized project structure. I built this to bridge the gap between "pretty" templates and "functional" enterprise tools. Check it out, star the repo, and let me know what you think! I'd love for you to take a look at the code and perhaps even use it for your next project. Feedback and contributions are always welcome! WebDevelopment, Bootstrap5, AdminDashboard, OpenSource, UIUX, JavaScript, GitHub, Bootstrap, CodingCommunity, OpenSourceProject, FrontendDev, LumoraUI

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

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

submitted by /u/adrian-cable [link] [留言]

📚 Limn Engine — Complete API Reference Quick Navigation Class Purpose Level Display Canvas, game loop, input, camera, scenes 🟢 L1 Component Every visible game object 🟢 L1 Camera Viewport control (follow, shake, zoom) 🟡 L2 move Movement, physics, particles, helpers 🟢 L1 state Read-only query helpers 🟢 L1 TileMap Grid-based levels 🟡 L2 Tctxt Rich text with backgrounds 🟢 L1 Sound Single audio file 🟢 L1 SoundManager Multiple sounds, volume control 🔴 L4 ParticleSystem Emit, burst, continuous emitters 🟠 L3 Sprite Spritesheet animation 🟡 L2 Display The heart of every Limn Engine game. Creates the canvas, runs the game loop, captures input, manages the camera, and controls scenes. Constructor const display = new Display (); Properties Property Type Description .canvas HTMLCanvasElement The game canvas .context CanvasRenderingContext2D 2D drawing context .keys Array Boolean array indexed by keyCode .scene Number Current active scene (default 0) .camera Camera Attached camera instance .deltaTime Number Time since last frame (seconds) .fps Number Current frames per second .frameNo Number Total frames elapsed .x / .y Number false Methods Method Parameters Description .start(w, h, node) width, height, parentNode Initialise canvas and start game loop .perform() — Activate dual-canvas pipeline (call before .start() ) .add(comp, scene) Component, scene number Register a Component for rendering .stop() — Pause the game loop .scale(w, h) width, height Resize canvas after start .backgroundColor(color) CSS color Set background colour .lgradient(dir, c1, c2) direction, color, color Linear gradient background .rgradient(c1, c2) color, color Radial gradient background .fullScreen() — Enter fullscreen .exitScreen() — Exit fullscreen .tileMap() — Build TileMap from display.map and display.tile Usage const display = new Display (); display . perform (); display . start ( 800 , 600 ); display . backgroundColor ( " #0a0a2a " ); const player = new Component ( 40 , 40 , " blue " , 100 , 100 ); d

Hi folks, I wrote a paper, Fearless Concurrency on the GPU, and maintain the related repository cuTile Rust ( https://github.com/nvlabs/cutile-rs ). The idea is to establish a safe way to write async kernel launch code, extend that across the kernel launch boundary, and sustain (to the extent possible) a safe programming model for GPU programming in Rust. We provide a variety of tools to enable static bounds checks so that the data-race freedom is effectively zero-cost. Sharing in case it's of interest. Happy to answer questions. submitted by /u/Exciting_Suspect9088 [link] [留言]

I promised myself that starting this week I'd switch to lighter topics. But on Monday, my JSNation...

Guys! What’s the best way to gather early adopters to evaluate new dev tool that literally just killed REST, gRPC, Thrift, SignalR, DAPR and GraalVM in one shot? The concept is to shift away from writing code to expose any business logic in any specific integration strategy like create REST controllers or provide proto interfaces or expose via subscription to queue events as well as avoid implementing the integration-specific client code to call that rest or gRPC endpoint. Instead of that the question comes when I call “zip” module from Nuget in .net I just use its public methods and handle exceptions. Why if I want to use it remotely I should expose the same method via REST, map it to routes, strange parameters, http codes and next call that on other end? Wy I cannot just say it will be on this remote node so whenever I ca that method to “unzip” my intention just travel over network and execute there? The potential solution is to bridge runtimes on native level. Think of it like intercepting developer intention at abstract syntax tree so when you perform operation in code before it gets executed and just send it to the remote runtime fulfill job there and return result. Wouldn’t be beautiful if you could just call methods of any module regardless if it’s same tech or different and regardless of its in memory or remotely? Just by calling methods? I know I know there are isolation interfaces etc… but if you apply those concepts design facade properly, decide what should be public, and allow to attach to those calls any headers (to still support JWT, NTLM, api Keys etc) and will add support that if method is static it goes stateless if it’s instance it goes stateful with sticky session and give the DevOps ability to change channel between WebSocket, http/2, tcp/ip or any message bus without touching code as it will be just pure method code. It could really work. Think of it. How clean your codebase would be, how much more design would fit your original uml, how much l

O Event Loop é o mecanismo responsável por decidir quando callbacks e continuidades de operações assíncronas devem ser executados. Ele não executa operações de I/O diretamente, mas organiza a ordem em que elas retornam para o JavaScript. Essa arquitetura permite que o Node.js mantenha uma única thread de execução para JavaScript, enquanto delega operações de rede, disco e sistema operacional para componentes especializados do runtime e do próprio sistema operacional. Início Quando iniciamos um processo Node.js, o runtime carrega o arquivo de entrada da aplicação e executa todo o código síncrono disponível na Call Stack. Somente após essa etapa o Event Loop passa a assumir o controle do fluxo da aplicação, verificando continuamente quais callbacks estão prontos para execução. │ timers │ └─────────────┬─────────────┘ │ v ┌───────────────────────────┐ ┌─>│ pending callbacks │ │ └─────────────┬─────────────┘ │ ┌─────────────┴─────────────┐ │ │ idle, prepare │ │ └─────────────┬─────────────┘ ┌───────────────┐ │ ┌─────────────┴─────────────┐ │ incoming: │ │ │ poll │<─────┤ connections, │ │ └─────────────┬─────────────┘ │ data, etc. │ │ ┌─────────────┴─────────────┐ └───────────────┘ │ │ check │ │ └─────────────┬─────────────┘ │ ┌─────────────┴─────────────┐ │ │ close callbacks │ │ └─────────────┬─────────────┘ │ ┌─────────────┴─────────────┐ └──┤ timers │ └───────────────────────────┘ Trecho retirado da documentação principal. Sobre o Event Loop Durante muito tempo tratei o Event Loop como um dos conceitos mais complexos do Node.js. Depois de estudar a documentação oficial com mais calma, percebi que a dificuldade não está no Event Loop em si, mas na quantidade de conceitos diferentes que normalmente são apresentados ao mesmo tempo: libuv, Call Stack, Promises, Microtasks, Sistema Operacional e I/O. Quando isolamos o papel do Event Loop, ele se torna surpreendentemente simples. Definindo os passos e apresentando o iceberg 🧊 O Event Loop não executa trabalho. Ele agenda tr

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

The Quest Begins (The “Why”) Picture this: I’m knee‑deep in a legacy codebase that feels like the Death Star’s trash compactor—every time I try to add a feature, the walls close in and I’m squashed by tight coupling. I’d just spent three hours tracking down a bug that only showed up when the payment gateway was mocked in a test. The culprit? A new PaymentGateway() buried deep inside an OrderService class. It was like trying to defeat Darth Vader with a butter knife—no matter how hard I swung, the Dark Force (aka hidden dependencies) kept pulling me back. I realized I was instantiating collaborators inside the very classes that should be oblivious to their implementation details . The result? Tests that needed a real database, a real Stripe account, and a sacrificial goat to run. Any change to a third‑party API meant hunting down every new scattered across the project. Onboarding a new teammate felt like handing them a map written in ancient Sumerian. Honestly, I was ready to quit coding and become a professional napper. Then, during a late‑night coffee‑fueled refactor session, I stumbled upon a tiny line of documentation that whispered: “Depend on abstractions, not concretions.” It sounded like Yoda giving me a pep talk. The Revelation (The Insight) The magic spell I uncovered is Dependency Injection (DI) —specifically, constructor injection . Instead of a class creating its own collaborators, we hand them in from the outside. Think of it as giving a Jedi their lightsaber rather than making them forge one in the middle of a battle. Why does this feel like discovering the Force? Testability explodes – you can swap in fakes, mocks, or stubs without touching production code. Flexibility skyrockets – swapping a payment provider becomes a one‑line config change, not a scavenger hunt. Clarity reigns – the constructor becomes an honest inventory of what a class needs to do its job. The moment I applied it, the codebase felt lighter, like Luke finally trusting the Force ins