标签：#programming

The decision between a free hosted AI coding server and a self-hosted stack is rarely about price. It is about three measurable variables: token burn per task, latency tolerance, and privacy surface. Teams that compare sticker prices pick wrong. Teams that measure these variables pick right most of the time. This guide provides a decision table, a token budget script, and a one-week audit workflow. The framework applies to any free AI coding tier. The examples use MonkeyCode, an open-source AI coding assistant whose free tier includes model access and a hosted server with a 10M token allowance at the time of writing. Quotas and model availability change, so verify the current limits before relying on them. Disclosure: This article was prepared as part of MonkeyCode's product outreach. Why Sticker Price Is the Wrong Variable Free sounds better than paid. It is not always cheaper. A free server that burns 40,000 tokens on a task a local model handles in 8,000 tokens costs more in time, context, and rework. The real unit of comparison is tokens per completed task, not dollars per month. Self-hosting has the same trap. A GPU that already sits in the office looks free. Add power, cooling, maintenance, and the engineer who keeps the stack alive, and the hourly cost becomes visible. The comparison needs one model that accounts for both sides. The Three Variables That Decide Token burn per task Refactors and test generation consume more tokens than single-file edits. The number varies by model, context length, and repository size. Most teams never measure it. That is the first mistake. A 10M allowance sounds large until a monorepo context window eats a meaningful slice of it on every request. Latency tolerance Interactive coding needs fast first-token time. Batch tasks like code review or documentation generation tolerate seconds of delay. A free hosted server usually sits between the two. Teams that treat all tasks as interactive overestimate latency risk. Teams that treat

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

I've been thinking about something that is becoming pretty common among developers.🤔 A lot of us...

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

You have an orders topic on a Kafka cluster, its values encoded with Avro against a schema in the Schema Registry . You want the orders worth more than fifty euros on a topic of their own, and you have decided to do it with Kafka Streams — a JVM library, your code, your deployment. The schema has five fields: { "type" : "record" , "name" : "Order" , "namespace" : "com.alginte.demo" , "fields" : [ { "name" : "orderId" , "type" : "string" }, { "name" : "customerId" , "type" : "string" }, { "name" : "item" , "type" : "string" }, { "name" : "quantity" , "type" : "int" }, { "name" : "priceEur" , "type" : "double" }]} You want one line of logic over them: quantity * priceEur > 50 . Here is everything standing between that line and a topic of big orders. Seven steps The route Confluent's own examples take, and many projects with them: Get the schema out of the registry and into your repository as an .avsc — or, if your team owns the schema in the repository and publishes it to the registry, the other way round. Whichever copy you call the source, there are now two that can disagree. Add the code generator to your build. Configure it — source and output directories, and the string type. Build , producing Order.java under target/generated-sources . Write the topology against the generated class. Package the application, with the schema, the class and the serde. Deploy it somewhere that runs a JVM. Steps 2 and 3 are this, once — in Maven, though Gradle's equivalent has the same shape: <plugin> <groupId> org.apache.avro </groupId> <artifactId> avro-maven-plugin </artifactId> <version> 1.12.1 </version> <executions><execution> <phase> generate-sources </phase> <goals><goal> schema </goal></goals> <configuration> <sourceDirectory> ${project.basedir}/src/main/avro </sourceDirectory> <!-- without this, string fields generate as CharSequence, not String; Confluent's own examples set it for the same reason --> <stringType> String </stringType> </configuration> </execution></executio

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

Intro There's a pitch behind every "AI writes your tests too" workflow: more coverage, less manual toil, a safety net that used to take a sprint now takes minutes. The pitch skips over what that safety net is actually made of. When the same model writes the implementation and the test suite, you haven't added a second, independent check. You've asked one reviewer to grade its own homework and handed you the green checkmark as if someone else had signed off. The blind spot loop A model reasons about a function once, forms an implicit set of assumptions (input shapes, timezone handling, what counts as "empty"), and writes the implementation against those assumptions. Ask the same model to write tests for that function, and it doesn't re-derive correct behavior from scratch. It writes tests against the same assumptions it just used to write the code. If it assumed dates always arrive as ISO strings in UTC, the implementation assumes that, and the tests assume it too. The suite goes green. The assumption is still wrong. Tests that pass for the wrong reason (Illustrative, not a specific case, but recognizable to anyone who's shipped an AI-generated suite.) Picture a discount-calculation function where the model assumes quantities are always positive integers. The implementation skips a negative-quantity check. The generated tests exercise 1, 5, and 100, because those are the "normal" values a model reaching for plausible test data will reach for. Nothing ever asks what happens at -1 or 0, because neither pass, the code or the tests, ever considered them worth asking about. Coverage tooling reports 100% on this function. The bug ships anyway. Coverage becomes a false signal High line or branch coverage from an AI-authored suite tells you the code paths were exercised, not that the right inputs exercised them. A suite can hit every line of a function and still never send it a null, an empty array, a duplicate key, or a value at a type boundary, if the author, human or mode

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

In this post I'll talk about my brief experience with muse , Meta's LLM harness for developers, as well as Muse Spark 1.3, their latest frontier-level model. The Bad I'll start with the bad, just because I like to end with the positive :) Skill Usage It's not that good following skills. If the skill has disable-model-invocation , sometimes it refuses to launch it, even if you manually call it. I think it happens when you call the skill mid-sentence, but it's not consistent. It's also not as good as other models at following skill instructions. It seems to get confused more often. For example, I have one skill that will address an issue from GitHub to PR. In Claude (Opus 5) and Cursor (Grok 4.6) it works perfectly. The first step is grilling the issue, after that's finished, the next step is autonomous, plan, implement with TDD, review and open PR. With Muse Spark 1.3, sometimes the skill will not continue and I have to nudge it for the next step, just saying something like "continue" is enough, but surely is annoying. Formatting The output is not great. Sometimes it will show me raw markdown, sometimes not. It's not consistent. Sandbox Having a sandbox is good, but in this case, it's a bit too restrictive. For example, I'm working with a Firebase project and I want to use the emulators. Well, too bad. The sandbox doesn't allow you to run files outside your workspace or use external ports. That would be great if I could add exceptions or some kind of configuration, but you can't. You are basically forced into --yolo mode if you don't want to be prompted on repeat for the same things over and over. What's sad is that even if you want to give them access, the models will just get stuck asking for permissions for the same thing over and over again and eventually they will just be stuck doing nothing. The Good Not everything is bad, of course. With a bit of effort I think it's actually quite usable. Price The main reason I decided to try the model. The subscription plan

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

Introdução Muitas linguagens como C#, Java, entre outras são descritas como orientadas a objeto, possibilitando o paradigma Programação Orientada a Objeto (POO). No entanto, quando falamos de JS, sabemos que por mais que existam objetos, ela é dita como uma linguagem orientada a protótipos, mas o que de fato isso significa, qual problema isso resolve e como muda a maneira como programamos? O problema Tanto a orientação a objeto quanto a orientação a protótipo lidam, entre outras coisas, com a questão de como a herança vai funcionar em determinada linguagem e é justamente nesse ponto que as duas abordagens mais se diferem. Em linguagens orientadas a objetos as classes de fato existem, contendo propriedades, métodos e servem como molde para a criação de objetos. Com isso, todo objeto criado a partir de uma classe herda suas propriedades e métodos ficando acessíveis para uso. Como não existem Classes de fato em JavaScript, a herança ocorre de maneira diferente, de objeto para objeto, ligados através da propriedade [[Prototype]] que possui uma referência ao seu protótipo, fazendo com que determinado objeto herde de seu protótipo propriedades e métodos que nunca foram definidos nele. Exemplo com array Quando criamos um array, seja de forma literal com [], ou de forma explícita com new Array(), o resultado final é o mesmo: um array cujo [[Prototype]] aponta para o Array.prototype. Essa propriedade .prototype possui um objeto contendo todas as propriedades e métodos que o [[Prototype]] referencia, possibilitando que todos os arrays possam usar métodos como push, pop, map, filter… Com isso, se irmos além e conferirmos o [[Prototype]] do Array.prototype vamos perceber que ele aponta para o Object.prototype que contém propriedades e métodos também disponível em todo essa cadeia que chamamos de prototype chain . Por fim, se tentarmos visualizar o protótipo do Object.prototype veremos que é null, pois ele representa o último elo dessa cadeia. Teste o código abaixo para ver na p

I'm working on making a latest system from an old pascal system (created in year 2008). And am trying to retrieve all of the data from that old system. It's has been said that the data was encrypted by the creator of the old system. But when i looked into the contents of the saved file using notepad, there are still readable text which are the raw data of the system. That made me think - it might not be encrypted. it might be serialized, instead. Like a saved file of c# unity game. The old system is still alive but the source code of it is no more. And the creator already passed away. So, i can't sif The internet or AI suggests that i use R language or python but it doesn't seem to work. So now, I'm trying to recreate the data's blueprint/record using pascal but there's a lot of variables and the arrangement of those variables must be correct as the original bluprint.. Can you give me other ideas to reverse-engineer the file? submitted by /u/Sil3nt_R3ap3r-1208 [link] [留言]

I wrote "just use a match statement, it's fine" three times before I stopped saying it. It is fine, right up until an enemy needs a fourth state and two of the transitions start depending on each other. Here is what actually cost time building enemy AI for a wave-based game, in the order it bit me. Lesson 1: the match statement is fine until state 4 A two-state enemy — chase, attack — is genuinely not worth a framework: func _physics_process ( delta : float ) -> void : match state : State . CHASE : velocity = ( player . global_position - global_position ) . normalized () * speed if global_position . distance_to ( player . global_position ) < attack_range : state = State . ATTACK State . ATTACK : attack_timer -= delta if attack_timer <= 0.0 : do_attack () state = State . CHASE The moment a third and fourth state show up — hurt, dead, stagger, windup — the match block stops being one enemy's logic and becomes a grid of every state times every other state it might transition to. That grid is where the bugs live, not in any single state. Lesson 2: the bug is never inside a state, it's in the transition Every state-machine bug I actually spent time on was the same shape: state A left some flag or timer set that state C didn't know to check. An enemy stuck mid-attack-animation forever, still receiving hits, was not a bug in the attack state — it was the hurt state interrupting attack without cleaning up attack_timer or resetting the animation. The fix that made these bugs findable is giving every state an explicit enter and exit , and never mutating another state's data directly: func change_state ( new_state : State ) -> void : if new_state == state : return _exit_state ( state ) state = new_state _enter_state ( new_state ) func _exit_state ( s : State ) -> void : match s : State . ATTACK : attack_timer = 0.0 sprite . stop () func _enter_state ( s : State ) -> void : match s : State . HURT : velocity = Vector2 . ZERO hurt_timer = HURT_DURATION sprite . play ( "hurt" ) On

AI Can Write Your Code. Can It Actually Debug It? AI coding assistants have changed how developers write software. You can describe a feature, generate a function, refactor a component, write a test, or explain an unfamiliar codebase in seconds. But there is one part of software development that is still surprisingly difficult: figuring out why something broke. Writing code and investigating a failure are two very different problems. When an application crashes, the answer usually isn't sitting inside the error message. You have to reconstruct what happened. The Problem With "Just Read the Stack Trace" Consider this Node.js error: TypeError: Cannot read properties of undefined (reading 'email') at getUser (/app/services/user.js:42:18) at processRequest (/app/controllers/auth.js:87:12) at async handler (/app/routes/auth.js:31:5) The immediate problem appears obvious. Something is undefined. But what caused it? Maybe: A database query returned no user. An API returned an unexpected response. Authentication middleware failed. A promise returned an unexpected value. A user record exists but its profile doesn't. An earlier function silently produced invalid state. The stack trace tells you where the program finally failed . It doesn't necessarily tell you where the bug began . That's the difference between error reporting and debugging investigation. AI Coding vs AI Debugging Most AI coding workflows look something like this: Developer ↓ Prompt ↓ AI ↓ Code Debugging is different: Failure ↓ Error ↓ Stack trace ↓ Execution path ↓ Application state ↓ Root cause ↓ Fix The AI needs to reason across that chain. Simply asking: "What does this error mean?" usually produces a list of possible explanations. That's useful, but it's not necessarily an investigation. A better question is: "Given this failure and its context, what is the most likely root cause, what evidence supports it, and how can I reproduce it?" That's a much more interesting problem for AI. A Simple JavaScript De

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

The agent is already in your workflow. The failed build is where it goes blind. AI coding agents have moved from novelty to daily tool. In Stack Overflow's 2025 Developer Survey, 84% of developers said they are using or planning to use AI tools in their development process, up from 76% the year before, and about one in seven professional developers now use AI agents at work every day . Among developers who have used agents at work, roughly 70% agree the agents have reduced the time they spend on specific tasks . There is one place, though, where that agent still tends to go dark: the failed CI run. The pipeline turns red, and your agent (like you) is handed a wall of log output from jobs it did not write, covering steps it did not touch. It has to reconstruct what actually broke before it can fix anything. That reconstruction is the expensive part, and it is exactly the part Latchkey is built to remove. This piece is about a clean division of labor. Latchkey's self-healing CI repairs the failures that are about your environment, not your code. For the failures that are genuinely about your code, Latchkey does not guess and patch on your behalf. Instead it hands your own coding agent a complete, structured account of the failure over the Model Context Protocol, so your agent can fix the bug with full context instead of starting from a log file. Two kinds of red build, and only one of them is yours to fix Almost every failed build is one of two things. Either the environment let you down (a flaky network, a full disk, a process killed for memory, a missing tool, configuration that drifted), or your code is actually wrong (a compile error, a failing test, a broken assertion). These two cases want opposite treatment, and conflating them is how teams end up rerunning pipelines and hoping for green. Latchkey's self-healing CI handles the first case. When a step fails on a Latchkey managed runner, Latchkey detects the failure, diagnoses the cause, and applies a fix while t

The Pipeline Became the Attack Surface For most of the last decade, we treated the CI/CD pipeline as plumbing: invisible, trusted, and mostly ignored until it broke. That assumption is no longer safe. The clearest signal came in 2025, when attackers stopped going after the software a pipeline builds and went after the pipeline itself. This week's research pass pulled together three shifts that are all landing at once: a supply-chain attack that redefined the threat model, GitHub's response in its 2026 security roadmap, a pricing change that quietly rewrites the cost math, and a persistent gap between how much teams trust AI in general and how little they trust it inside CI. Here is what the sources actually say. The tj-actions attack changed the threat model On March 14, 2025, researchers discovered that the popular tj-actions/changed-files GitHub Action had been compromised. According to Palo Alto Networks Unit 42, the action was used by over 23,000 GitHub repositories at the time ( Unit 42 ). The mechanics are worth understanding, because they explain why this matters beyond one action. Attackers injected code that dumped the CI/CD runner's memory and wrote sensitive environment variables and secrets straight into the workflow logs. They retroactively modified multiple version tags to point at a single malicious commit, so pipelines that pinned to a tag rather than a commit SHA pulled the payload ( Unit 42 ). The incident is tracked as CVE-2025-30066, described as allowing remote attackers to discover secrets by reading action logs ( GitHub Advisory Database ). The compromise did not start with tj-actions. Unit 42 traced it back through a leaked personal access token that reached reviewdog/action-setup , a dependency in the chain, with earlier steps going back to late 2024 ( Unit 42 ). In other words, the pipeline's own dependency graph was the delivery vehicle. The takeaway is not "avoid one bad action." It is that the automation running your builds is now a firs

The first half of 2026 reset two things at once for engineering teams: what continuous integration costs, and what it takes to keep delivery stable while AI pushes more change through your pipelines than ever. Those two stories are connected, and the connection is the part worth your time. The pricing reset On January 1, 2026, GitHub reduced prices for GitHub-hosted runners by up to 39%, with the size of the cut depending on the machine type ( GitHub Changelog ). Standard hosted-runner usage on public repositories stays free, as it was before. The DevOps publication SamExpert documented the specific per-minute moves. A Linux 2-core runner dropped about 25% (from $0.008 to $0.006 per minute). A Windows 2-core runner dropped about 38% (from $0.016 to $0.010). A Linux 64-core arm64 runner dropped about 39% (from $0.160 to $0.098) ( SamExpert ). If your CI runs mostly on hosted runners, that is real money back, and it is worth recalculating your monthly estimate against the new rates rather than assuming last year's numbers still hold. The same December 2025 announcement carried a more controversial proposal: a $0.002 per-minute charge for self-hosted runner usage in private repositories, scheduled to start March 1, 2026 ( DevClass ). GitHub framed it as ending a cross-subsidy, where revenue from hosted runners was effectively underwriting the cost of operating Actions for everyone, and said the large majority of customers would see no change to their bill. The reaction from developers who run CI on their own hardware was sharp, with some publishing the monthly figures they expected to owe for compute they already pay to operate themselves. Within about a week, GitHub posted that it was postponing the self-hosted billing change to re-evaluate its approach ( SamExpert ). Postponed, it is worth being precise here, is not the same as withdrawn. There is no new date and no guarantee the charge returns in its original form, but there is also no statement that it is gone for

Lend him the opening. Lure him in. Cut his support. Trap him where there is no way out. To take the...