标签：#RAM

Have you ever had this happen? You're chatting with a friend about buying a new pair of shoes. A few hours later... Instagram shows you an ad for those exact shoes. Or maybe you're talking about planning a trip. Suddenly...Your feed is filled with hotel deals, flight offers, and travel videos. The first thought that comes to almost everyone's mind is: "𝐌𝐲 𝐩𝐡𝐨𝐧𝐞 𝐢𝐬 𝐥𝐢𝐬𝐭𝐞𝐧𝐢𝐧𝐠 𝐭𝐨 𝐦𝐞." 👀 Honestly... I've thought the same. And maybe you have too. But what if I told you that the truth is actually more fascinating than the myth? So... is your phone secretly listening? Probably not. Not because it can't. But because it usually doesn't need to. Think about it. Every day you leave behind hundreds of tiny digital clues. 🔍 What you search. ❤️ What you like. ⏱️ How long you watch a video. 🛒 What you browse. 📍 Where you go. 👥 Even who you interact with online. Individually...They don't say much. Together...They tell a story that's surprisingly accurate. A story about your habits. The scary part? AI doesn't need to hear your conversations. Sometimes...It already knows what you're likely to do next. Not because it can read your mind. But because it's incredibly good at recognizing patterns. And when a prediction is accurate enough... It starts to feel like magic. Or surveillance. Here's what fascinates me the most. The real superpower of modern AI isn't listening. It's predicting. And sometimes...Those predictions are so good that they make us question reality itself. The next time you think, "My phone is definitely listening to me." Ask yourself a different question. "How much of my digital behavior have I already shared without realizing it?" Because maybe...The microphone isn't the real story. Your patterns are. 💬 Have you ever had an experience that made you think your phone was listening to you? What happened? Takeaway : Technology doesn't always become powerful by knowing more. Sometimes... It becomes powerful by predicting better. Technology becomes less magical when you und

Hay muchísimo escrito sobre qué tiene que reportar una organización: guías de Supersalud, de Supersociedades, de SAGRILAFT, de PTEE, de SST, de reportes ambientales. Todas contestan la misma pregunta — ¿qué me aplica? — y la contestan bien. Casi nadie escribe sobre la pregunta que de verdad hace fallar a las organizaciones: ¿cómo no perder ninguno, todos los años, cuando son treinta? Porque los incumplimientos que he visto de cerca casi nunca vienen de que alguien ignorara la obligación. Vienen de que la obligación se conocía perfectamente y aun así se pasó la fecha. Este artículo va del problema operativo —fechas, evidencia, responsables— no de cuáles normas le aplican a su entidad. Eso es otra conversación, y no es esta. Por qué el archivo de Excel deja de servir Con tres obligaciones, una hoja de cálculo sobra. El dolor no empieza por el número: empieza cuando el calendario hay que derivarlo . 1. Las fechas no son fechas, son reglas. Muchos vencimientos no están escritos como un día del calendario: dependen del último dígito del NIT, de días hábiles, o de un plazo contado desde un hecho. Eso significa que alguien recalcula el calendario entero cada año, a mano . Cada enero se reintroduce la misma oportunidad de equivocarse, y basta con un festivo mal contado. 2. El calendario vive en una persona. Casi siempre hay alguien que "sabe cómo es la cosa". Mientras esté, funciona. Cuando se va de vacaciones —o se va de la empresa— se va con ella el contexto que nunca estuvo escrito. La hoja sobrevive; el criterio para llenarla, no. 3. La hoja dice que se entregó, no lo prueba. La celda en verde es una afirmación de alguien. La evidencia real —el radicado, el archivo exacto que se subió, la hora— está en el correo de alguien. El día que hay que demostrarlo, empieza la arqueología en bandejas de entrada. 4. Los terceros que le reportan a usted. Si recibe información de contratistas, sedes o filiales, ahora administra dos problemas: sus propios vencimientos y los de ellos.

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

Canonical: this is a cross-post. The original lives at https://four-leaf.ai/blog/openai-interview-process Most OpenAI interview prep hands you a list of hard coding problems and tells you to grind. That calms the nerves and misreads the loop, because at OpenAI the coding bar sits next to something the grind can't touch: a genuine point of view on where AI is going and how it could go wrong. Candidate-facing guides describe that thread running from the first recruiter call to the final behavioral round. You can solve every problem and still stall if you can't hold that conversation. We've mapped the loops at Amazon , Google , Apple , Meta , and Bloomberg by reading each process through how the company actually runs. The map now includes the other AI labs and high-growth names candidates weigh alongside it, including Anthropic , SpaceX , and Robinhood . OpenAI is the one candidates most often prepare for as if it were a standard FAANG gauntlet. It isn't. The coding is practical rather than puzzle-flavored, a whole round asks you to present and defend work you built, and the loop varies more team to team than almost any large employer. Generic big-tech prep leaves you exposed on exactly the parts specific to OpenAI. A note on sourcing. OpenAI doesn't publish its interview process. There's no stage list, no scoring rubric, no candidate-facing equivalent of Google's structured-interviewing guidance. So this map comes from reputable secondary sources that collect named and dated candidate accounts, primarily interviewing.io's OpenAI question guide and Exponent's OpenAI software engineer guide . Where those accounts agree, this guide states the pattern. Where the loop varies or the record thins out, it says so rather than inventing detail. Treat everything below as the common shape, not a guaranteed sequence. Why the loop varies so much Start with the thing that makes OpenAI different to prep for. Hiring is decentralized, and secondary guides are blunt that the loop varies

A deep dive into the 3-way battle for the developer's desktop—comparing AI depth, flow state, autonomous agents, and real-world productivity. Three years ago, choosing a code editor was simple: you downloaded VS Code, installed your favorite syntax theme, added a few extensions, and got to work. Today, developer tooling has undergone a seismic shift. AI isn't just an extension sitting in a sidebar; it's driving entire workflows, editing dozens of files simultaneously, and executing complex engineering tasks. Enter the primary contenders dominating the developer landscape: VS Code (+ GitHub Copilot): The battle-tested industry titan with unmatched ecosystem depth. Cursor: The pioneer of the AI-native fork, built specifically for flow state and multi-file orchestration. Windsurf: Codeium's AI-first editor featuring autonomous flow state agents and deep context tracking. If you're trying to figure out which editor will give you or your engineering team the highest return on productivity, here is a practical, data-informed breakdown. The Architectural Divide: Plugins vs. AI-Native Forks Before comparing feature lists, it helps to understand the underlying architecture: VS Code remains an extension-first model. The core editor is unchanged, while GitHub Copilot operates alongside it as an assistant. Cursor and Windsurf are VS Code forks. Their creators modified the editor at an architectural level to give the AI direct access to your local workspace, terminal, file system, and git context. This distinction dictates how each editor feels when you're in the middle of a complex coding session. 1. Inline Autocomplete & Flow State When writing code line-by-line, friction is the enemy of productivity. Cursor Famous for its ultra-fast multi-line predictions. Cursor predicts not just the next token, but your next probable edit location across nearby lines. It keeps you in a continuous "flow state" where hitting Tab feels almost telepathic. Windsurf Features "Supercomplete" inlin

AI is not a genie. Treat it like a function. Most people use AI the way they use a search box: type a question, read the answer, move on. That works for one-off curiosity. It is a bad fit for the work you repeat every week, because you re-explain the context every time and never build anything you can trust. A small assistant is different. It is one narrow task, wired up once, with a fixed input and a fixed output shape. You run it, check it, improve it. After a few iterations it stops being a demo and starts pulling real weight. Here is how to build one without drowning in frameworks. Start narrow: one task, one input, one output Do not build "an assistant for my job." Build the thing that turns a messy meeting note into three bullet points. Pick a task that is: Repetitive (you do it weekly or daily) Boring (nobody will miss the manual version) Verifiable (you can look at the output and know if it is wrong) That last one matters most. If you cannot tell good output from bad in ten seconds, you cannot trust the assistant and you cannot improve it. Good starter tasks: drafting reply emails, summarizing documents, normalizing scrappy data, extracting fields from text. Example: an email draft as a function Think of your prompt as a function signature. Inputs go in, a structured draft comes out. def draft_reply ( incoming_email : str , tone : str = " friendly, brief " ) -> str : prompt = f """ You are drafting a reply on my behalf. Do not invent facts. If information is missing, leave a [PLACEHOLDER]. Tone: { tone } Incoming email: --- { incoming_email } --- Write only the reply body. """ return llm ( prompt ) # any model client you like Two lines do the real work: "Do not invent facts" and the [PLACEHOLDER] rule. Together they turn a confident hallucination into a visible gap you can fill. The goal is to make errors loud instead of silent. Example: summaries you can actually trust The failure mode of summaries is a plausible sentence that never appeared in the source.

Introduction Artificial Intelligence has evolved far beyond answering questions and generating code. Modern AI systems can search databases, interact with APIs, read files, execute commands, access cloud services, and even coordinate multiple tools to complete complex tasks. This shift has given rise to AI agents - systems that don't just generate responses but can actively perform work on behalf of users. However, enabling an AI model to interact with external tools introduces a challenge. Every application, service, and API exposes its capabilities differently. Without a common standard, every AI platform would need custom integrations for every tool it wanted to support. This is where the Model Context Protocol (MCP) comes in. MCP provides a standard way for AI models to discover, understand, and use external tools, data sources, and services. Instead of building separate integrations for each AI model and every application, developers can expose capabilities through a common protocol that different AI clients can understand. In this article, we'll explore what MCP is, why it matters, how it works, and how it's changing the way developers build AI-powered applications. The Problem Before MCP Imagine you're building an AI assistant that needs to interact with: GitHub Slack Google Drive PostgreSQL Jira Notion Local files Internal company APIs Without a shared protocol, every integration becomes a custom implementation. For each tool, you need to define: Authentication API endpoints Request formats Response parsing Error handling Documentation Now imagine supporting multiple AI models. Every model may require different integration logic, increasing development effort and maintenance costs. This creates unnecessary complexity. What Is MCP? At its core, the Model Context Protocol (MCP) is a communication standard between AI models and external systems. Instead of hardcoding every integration, MCP defines a consistent way for an AI client to: Discover available tools U

AI systems can change without the code changing. That makes “is this correct?” a much harder question. I talked with Diana Pfeil about evals, input drift, prompt versioning, model deprecations, and the maintenance work hiding behind all this new capability. Curious how teams here are handling it in production. https://maintainable.fm/episodes/diana-pfeil-building-confidence-in-probabilistic-systems submitted by /u/robbyrussell [link] [留言]

Most Laravel applications do not become difficult to maintain because somebody made one obviously terrible architectural decision. They get there through dozens of small decisions that looked completely reasonable at the time. A controller grows beyond a comfortable size, so part of its logic moves into an Eloquent model. Later, the application needs to send a notification after an order ships. Then inventory must be checked through an external API. Accounting requests an ERP integration, and marketing wants loyalty points awarded after dispatch. Each change adds only a few lines. Since the Order model is already available wherever the feature is being implemented, adding one more method feels natural: $order -> ship (); It is concise, expressive, and pleasantly object-oriented. Six months later, however, that innocent method may be updating several tables, calling two APIs, dispatching events, sending notifications, and deciding whether the entire operation is allowed. The model has quietly become the place where the application runs its business workflows. That is the real problem. It is not that the model is “fat.” It is that persistence, domain decisions, and application orchestration have been mixed together until nobody can change one without understanding all three. Business Logic in Eloquent Models Is Not Automatically Wrong The common advice to remove all business logic from Laravel models goes too far. Eloquent follows the Active Record pattern. Martin Fowler describes Active Record as an object that represents a database row, encapsulates database access, and adds domain logic related to that data. In other words, an object containing both state and behavior is not an architectural mistake by itself. A model should be allowed to answer questions about itself: class Order extends Model { protected function casts (): array { return [ 'paid_at' => 'datetime' , 'expires_at' => 'datetime' , ]; } public function isPaid (): bool { return $this -> paid_at !== nul

Vista previa técnica: Iter todavía no está publicado en PyPI y no existe un paquete oficial instalable. Abrir un recurso, convertir datos o cambiar de backend suele exigir aprender una interfaz diferente y repetir código de integración. Iter nace de una idea sencilla: Aprende una vez. Usa cualquier biblioteca. iter convert data.json to data.csv El usuario expresa una sola intención. Iter se encarga de abrir el recurso, detectar los formatos, seleccionar un adaptador compatible, convertir los datos y guardar el resultado. Una intención. Una instrucción. ¿Qué busca cambiar Iter? Actualmente, una tarea sencilla puede exigir: importar bibliotecas; aprender APIs diferentes; configurar formatos manualmente; escribir código de integración; seleccionar cada backend. Con Iter, el usuario indica principalmente qué quiere conseguir: iter analyze sales.csv Iter selecciona automáticamente una herramienta compatible. Si el usuario necesita controlar la biblioteca, puede indicarla: iter analyze sales.csv with pandas La automatización es el comportamiento predeterminado. El control detallado sigue siendo opcional. Everything is a Resource Iter representa archivos, datos y recursos web mediante una estructura común llamada Resource . El sistema está organizado alrededor de cinco componentes: Resource : representa el recurso. Resolver : identifica formatos, tipos y backends. Registry : registra y selecciona adaptadores. Adapter : ejecuta operaciones concretas. Engine : coordina el proceso. La meta no es afirmar que todas las bibliotecas son idénticas. La meta es unificar intenciones comunes y conservar las diferencias importantes cuando sean necesarias. Estado actual Iter 0.3.0-rc.2 está en fase de corrección de errores y validación privada. Actualmente: el código principal permanece privado; Iter todavía no está publicado en PyPI; no existe un paquete demostrativo; la sintaxis puede ajustarse antes del lanzamiento; solamente se anunciarán como disponibles las funciones implementadas

Welcome to Part 2 of the JS interview series! This time we're tackling functions, scope, and the topic that trips up even experienced developers in interviews: closures . Missed Part 1? Check out Fundamentals & Data Types first. Q1. What is a closure? A closure is what happens when an inner function "remembers" and continues to have access to the variables from its enclosing (outer) function's scope, even after that outer function has already finished running and would normally have had its local variables cleaned up. This works because JavaScript functions don't just capture the values of outer variables — they capture live references to them, keeping the entire surrounding scope alive in memory for as long as the inner function itself is reachable. Closures are one of the most powerful and commonly used patterns in JavaScript. They're the mechanism behind data privacy (since variables inside a closure can't be accessed from outside except through the functions that were given access), factory functions that generate customized functions, memoization caches, and event handler callbacks that need to remember state from when they were created. In the classic counter example below, each call to counter() creates a fresh, independent count variable that only the returned function can see or modify — there's no way to reach into it from outside. function counter () { let count = 0 ; return () => ++ count ; } const inc = counter (); inc (); // 1 inc (); // 2 Q2. What is lexical scoping? Lexical scoping (also called static scoping) means that a variable's accessibility is determined entirely by where it's physically written in your source code — not by which function called which, or the order in which functions happen to execute at runtime. When JavaScript compiles your code, it can already determine, just by looking at the nesting of functions and blocks, exactly which variables any given piece of code will be able to see. This is what allows an inner function to "reach

Software projects fail on fixed-price contracts. This is not a controversial statement — the Standish Group's CHAOS report has tracked this for decades, showing that only 31% of software projects succeed on time and on budget, while 50% are challenged and 19% fail outright. But the conventional wisdom about why they fail — scope creep — misses the real problem. Scope creep is a symptom. The real disease is specification ambiguity . The Map Is Not the Territory Paweł Brodziński, an experienced software delivery leader, captured this perfectly with a simple analogy. A specification is a map of the software you want to build. And as with any map, its representation of the terrain is necessarily imperfect. For a perfect map, it would have to be as large as the terrain itself. "The only absolutely precise specification of a software project is the code itself. But if you already have that, why would you buy it?" When you write "As a workspace owner, I can set administrative privileges to workspace members," two people reading that sentence will envision different things. One imagines a simple dropdown with three permission levels. The other imagines role-based access control with custom policies, audit logs, and delegation. Both are reasonable interpretations of the same text. The PMI's research on communications complexity confirms why this happens: the number of communication paths grows geometrically with project size ( n(n-1)/2 ), and every path is a channel where ambiguity can creep in. Even a simple conversation involves encoding, decoding, and filtering — two receivers can interpret the same message differently. Why This Is Not Scope Creep Scope creep is when a client asks for something new after the contract is signed. That's a well-understood problem with well-understood countermeasures: change requests, sign-offs, contingency buffers. Specification ambiguity is different. It's not about adding new things — it's about both parties believing they agreed on the sa

submitted by /u/goto-con [link] [留言]

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

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

https://ekxide.io/blog/byte-wise-atomic-wrapper-to-prevent-ub iceoryx2 provides zero-copy inter-process communication mechanisms based on shared memory and data structures that are modified concurrently by multiple processes. One of the key operations in these algorithms is a memory copy using core::ptr::copy . However, this results in undefined behavior if one process reads the data while another process writes to it concurrently. Even if our lock-free algorithm reliably detects such a race, iceoryx2 cannot depend on undefined behavior in a safety-critical system. This blog post introduces our solution: a byte-wise atomic wrapper that enables well-defined concurrent copy operations. It also shows how it can be used to implement a simple sequence lock. Note: I am not the original author of the blog post. Since the author does not have a Reddit account, I am posting it on her behalf. submitted by /u/elfenpiff [link] [留言]

Part 1 was about waiting well. This one is about not waiting at all, and about a couple of mistakes I...

Problem Description Merge multiple structurally similar tables with different column names into a wide table using full outer joins by common ID. Four tables have similar structures, each with two fields. The fields have the same meaning but different names (id, id2, id3, id4 all represent ID). The goal is to merge the four tables into single rows by ID, with each ID appearing in exactly one row. When an ID is absent in a table, the corresponding columns take NULL. Source Data T1 table: T2 table: T3 table: T4 table: * Expected Result * For example, ID=555 appears in both T1 and T2 but not in T3 or T4, so id, colA, id2, colB have values, while id3/colC/id4/colD are NULL. ID=222 only appears in T3, so only id3 and colC have values; all other columns are NULL. ID=10 appears in T2 and T4 but not in T1 or T3, so id2, colB, id4, colD have values; all other columns are NULL. SQLazy Step-by-Step Implementation Core Idea: First use derive to unify the ID column names of each table to ID_main, making subsequent merging easier. Then start from the first table and perform full outer joins one by one: use join to full outer join the current result with the next table on ID_main, then use derive and nvl to merge the new ID into the ID_main column, appending tables one by one to get the final result. [ Click to run this example online ] The steps are explained below. Steps 1-4: Unify ID Column Names Across Tables derive id as ID_main, id, colA Use derive on T1-T4 to rename their respective ID column names (id/id2/id3/id4) uniformly to ID_main. Step 5: Full Outer Join T1 and T2 join ID_main; with t2; ID_main; take id2, colB; full Use the join function to full outer join t1 and t2 on ID_main. Step 6: Merge NULLs in ID Column derive nvl(ID_main, id2) as ID_main, id, colA, id2, colB If a record comes from t2 but is not present in t1, its ID_main is NULL. This step assigns t2.id2 to ID_main in such records, ensuring the ID_main column always has a value. Different SQL implementations u

A practical guide to writing specs that turn vague AI prompts into production-quality code — from functional requirements to edge cases, with real before-and-after examples. Let me paint a picture you've probably lived. You open Claude Code or OpenCode, type a vague prompt like "add a user dashboard with analytics," and hit enter. The agent spins up, writes a bunch of code — it even looks decent at first glance. Then you realize: the data model is wrong, the API endpoints don't match your existing patterns, there's no error handling, and the "analytics" is just a row of four hardcoded numbers. You spend the next hour correcting, prompting, correcting again. You would have been faster writing it yourself. Now imagine a different scenario. You spend 15 minutes writing a structured specification, paste it into the agent, and it produces exactly what you wanted — following your conventions, handling edge cases, wired into your existing auth and data layer. One shot. That's not luck. That's the difference between treating your AI coding agent like a chatbot and treating it like a senior engineer who needs a clear design document — also known as spec-driven development . The Core Problem: AI Agents Are Powerful but Undirected Claude Code, OpenCode, Cursor Agent — these tools are incredible when pointed at a well-defined task. They can read your entire codebase, understand your conventions, and produce production-quality code. But they share a fundamental limitation: they don't know what you want unless you tell them, precisely and completely. When you give an agent a one-liner prompt, you're leaving an enormous amount of ambiguity. The model will fill in the gaps — but it fills them with its own assumptions, which are often generic, incomplete, or just wrong for your context. A spec closes those gaps. It transforms an open-ended creative writing exercise into a constrained engineering task. What Makes a Spec Actually Work for AI Coding Agents? A spec that works for an AI

The most valuable thing Claude has done for my work is help me make better architectural decisions before I start building. When I was designing my hotel reservation system I needed to handle multi-currency pricing and timezone conversion. My first instinct was to put all of that logic directly in the booking controller alongside the reservation code. It would have worked but it would have created a mess that was hard to test and harder to extend. Before writing anything I described the problem to Claude and talked through a few approaches. The conversation helped me see that separating pricing and timezone logic into dedicated service classes would make each piece independently testable and easier to swap out later. The booking controller would just call those services without knowing how they worked internally. That conversation took maybe twenty minutes. It saved me hours of refactoring later. I still designed the system. I still made the judgment calls. But the quality of my thinking going into implementation was significantly better because I had a thinking partner to pressure test my ideas against.