标签：#RAM

For those who prefer to read the code instead of text, source code is available on GitHub . Relying only on model specification or common benchmarks, we can't predict how it would perform in a specific use case like detecting duplicated code. Focused evaluation revealed, for example, that a general-purpose model can be better than dedicated for code. Or that small model can outperform big providers. submitted by /u/rafal-kochanowski [link] [留言]

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

A fairly ordinary Go service can gradually end up owning polling loops, schedulers, workers, shared state, and shutdown—not because anyone designed an application runtime, but because the setup code was where all the dependencies happened to meet. I wrote about recognising that transition and making the architecture explicit. The article starts with a small 3D-print farm, takes a short detour through PX4, then builds a typed in-process backplane in Go using ordinary function signatures. The library itself isn’t really the point. The more interesting part is separating contracts that are easy to blur together: calls versus messages, streams versus current state, and durable truth versus in-memory notification. I’d be interested to hear where people think this sort of abstraction stops paying for itself, or what patterns you’ve used instead. submitted by /u/Michael-F-Bryan [link] [留言]

Photo by Microsoft Copilot on Unsplash TL;DR: In a poll of 138 developers, three‑quarters say Claude Code outperforms Codex for everyday AI‑driven coding, pointing to higher accuracy, deeper context awareness, and a smoother workflow. The AI‑coding battlefield has been dominated by OpenAI’s Codex for years, powering tools like GitHub Copilot and shaping how developers write code. Yet a fresh wave of feedback suggests a shift: Anthropic’s Claude Code is rapidly becoming the preferred assistant for many programmers. A recent survey of 138 software engineers—spanning startups, enterprise teams, and freelance coders—revealed that 75% now rely on Claude Code as their go‑to AI partner. What drives this migration, and what does it mean for the future of AI‑augmented development? Survey Overview and Key Findings The questionnaire targeted developers who regularly use AI code generators, asking them to rank their primary tool and rate specific workflow attributes. Respondents represented a broad skill spectrum, from junior developers to senior architects, and worked across languages such as Python, JavaScript, Java, and Go. Adoption rate: 104 out of 138 participants (75%) listed Claude Code as their primary AI assistant, while only 34 (25%) still favored Codex. Primary criteria: Accuracy of generated snippets, ability to retain long‑form context, and ease of integration into existing IDEs topped the list. Secondary factors: Cost efficiency, response latency, and the perceived safety of the model (fewer hallucinations) also swayed decisions. The data paints a clear picture: developers are no longer satisfied with a one‑size‑fits‑all approach. They want an AI that can understand the nuance of a multi‑file project, stay on‑topic across extended sessions, and deliver code that compiles on the first try. Why Claude Code Wins Over Codex Higher Accuracy and Fewer Hallucinations Respondents repeatedly highlighted Claude Code’s ability to generate syntactically correct, production‑re

Android, the last to arrive at the declarative UI party, took its time, until finally reaching a stable solution. Here's a rundown of the major changes in the Android System Design across the eras. I was away from Android for 7 years and came home to a totally strange place. This is my attempt to make sense of what happened while I was gone - how the stack reset four times (Activities -> MVP/RxJava -> Architecture Components -> Compose) and why each lurch happened. Written for interview prep but the history stands on its own. submitted by /u/Super-Performance-86 [link] [留言]

I like working on aspect calculations because the astrology terminology disappears pretty quickly once you get into the code. At the calculation level, an aspect is basically: How close are two points on a circle to a configured angle? That turns the problem into geometry, tolerances and a few interesting edge cases. Start with angular distance Suppose two planets have longitudes: 12° 102° Their separation is 90°. That’s easy. But this pair is more interesting: 358° 2° A normal absolute difference gives you 356°. On a circle, they’re actually 4° apart. So one of the basic utilities looks conceptually like this: def angular_distance ( a : float , b : float ) -> float : delta = abs ( a - b ) % 360 return min ( delta , 360 - delta ) Now: angular_distance ( 358 , 2 ) returns: 4 That simple normalization is the base of the rest of the aspect system. Then define target angles For the major aspects, you’re comparing against angles such as: 0° conjunction 60° sextile 90° square 120° trine 180° opposition If everything had to be exact, the implementation would be trivial. But astrology uses orbs. So a separation of 92° can still be treated as a square depending on the calculation profile. The orb is basically: orb = abs ( actual_distance - target_angle ) Then: if orb <= allowed_orb : # aspect matched I keep orb rules in a profile This is one of those places where hidden constants are really tempting. Something like: MAX_ORB = 8 and move on. I prefer putting this kind of behavior into an explicit calculation profile. That way the result isn’t just: Venus square Saturn It can be understood as: Venus square Saturn under this aspect profile with this orb That makes the methodology easier to inspect and makes future changes much less messy. The engine reports geometry, not sentiment This was another boundary I wanted to keep clean. The core can calculate: planet A planet B aspect type orb phase It should not calculate: good bad easy terrible relationship Those are interpretation-

Building fully autonomous "AI agent teams" with automated code merging often introduces subtle architectural defects, circular refactoring loops, and codebase degradation. Two agents running in parallel do not constitute independent ground truth: if the author agent makes a logical error, a reviewer agent operating on similar prompt foundations may easily overlook it. A reliable multi-agent workflow is built not on the illusion of full autonomy, but on strict role separation: a dedicated implementer (Author), an independent verifier (Reviewer), and a human developer who makes the final merge decision (Decision Maker). 1. Role Boundaries: Author, Reviewer, and Human Engineer In an effective AI development workflow, each participant has a closed, well-defined scope of responsibility: Role Core Responsibility Input Artifacts Output Artifacts Author Agent Code implementation, local unit tests Task description, completion criteria Git branch, diff, focused test suite Reviewer Agent Edge case discovery, regression checking Git diff, handoff card, verification commands Structured review checklist (Pass/Block) Human Decision Maker Architectural validation, final merge Reviewer summary, CI/CD status Manual merge to main branch 2. Context and Workspace Isolation Never run the author and reviewer agents within the same working directory or shared conversation thread. Isolate them across three operational levels: Session Context : Independent conversation threads prevent mutual hallucination and circular confirmation. Filesystem Isolation : Separate Git worktrees ensure the reviewer inspects only committed diffs without dirty working tree state. Environment Security : API keys and runtime credentials remain in environment variables and are never passed in prompt text. Worktree Preparation Commands: git worktree add ../agent-author -b feat/payment-retry git worktree add ../agent-reviewer feat/payment-retry [!IMPORTANT] API Configuration : Each Claude Code session operates using

An iOS app can feel slow even when its interface looks well-designed and responsive. The problem may not always be the UI or the code running on the device. Often, the real issues are hidden in network requests, API responses, WebSocket connections, and background activity. For developers, finding these problems requires visibility into what is happening behind the screen. This is where Owlse , a network inspection and debugging tool for iOS and macOS developers, can help. 1. What Actually Makes an iOS App Feel Slow? Several hidden network issues can affect an app's performance: Slow API responses Too many network requests Large data payloads Connection delays Failed or repeated requests Background network activity A user may simply see a loading screen or delayed response, while several network operations are happening in the background. Understanding these operations is the first step toward finding the actual cause of the problem. 2. Why Traditional Debugging Can Make These Issues Hard to Find Network-related problems are not always easy to identify through standard debugging. Developers may need to switch between different tools to inspect requests, analyze timing, investigate WebSockets, and understand application issues. When an app generates hundreds of requests, finding one problematic request can also take considerable time. Without a clear view of network activity, developers often have to rely on assumptions. A dedicated network debugging workflow can make this process much easier. 3. Meet Owlse: Network Debugging for iOS & macOS Owlse is built to give iOS and macOS developers greater visibility into their application's network activity. Instead of treating network behavior as something happening in the background, Owlse helps developers inspect and understand it. With features including live request streaming, request inspection, timing analysis, WebSocket inspection, mocking, crash reporting, search, HAR export, and timeline debugging, Owlse brings impo

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

I feel like I was starting on the wrong foot wrt target demographic here...also not being clear that any of _my_ ideas revolving around this concept I've designated public domain, and not after self promotion or disrespecting the unicode gods. I genuinely want to contribute to opensource without kowtowing to the Microsoft:Github ::linix:git cultural expectation/paradigm, which honestly, is played out and unimpressive. This (vsiink) in addition with tag Unicode block, plus standard zero width chars, plus regular ol 7 bit ascii/utf8, I think is ripe for picking at solution to the modern serde clusterfuck and GPU friendly textdoc LLM inference runtime applications, among other pipedreams. (think, Unicode VMs and text doc LLM human readable latent spaces in universal data interchange formats [sic, gross words]) Initial presentation is deliberately sparse and weak (trash by my standard). Alas, I am bandwidth limited. Also, if you are security minded but not yet variation selector savvy, it is only a matter of time before this codepoint block combo is aggressively utilized in all conceivable contexts by the obvious players. It's only a threat if the vector blindsides ops; there is zero reason for this (vsiink) to ever become a threat, so please wakeup quick. (Sorry to spoil your silly little gem on the clearweb @hackers, @stenographers, @etal.) The very worst thing that could happen is Unicode Consortium determines that the variation selector and tag blocks are too dangerous to support anylonger. THIS MUST NOT HAPPEN. *Please forward this to any unicode / HPC / technologist / IET people with best interests in mind on the topic of Humanity and the future of compute. Enjoy. submitted by /u/Singularity_Warrant0 [link] [留言]

Anyone who has worked with SSH private keys has run into an instruction to "set it to 600." Config files, by contrast, often get 644, and executable scripts get 755. What do these three-digit numbers actually mean, and why does the right number depend on what kind of file you're dealing with? This post starts from the mechanics of Unix-style (Mac/Linux) file permissions and works up to the design principle behind them: least privilege. Permissions as a 2D grid of who and what Unix-family operating systems express file access as a grid: three kinds of "who" crossed with three kinds of "what." "Who" breaks down into the file's owner, the group the owner belongs to, and everyone else ("other"). "What" breaks down into read, write, and execute. Each cell in that 3×3 grid is either granted or not, and that's exactly what a listing like -rw-r--r-- from ls -l is showing you. Strip the leading character and the remaining nine characters are three groups of three — owner, group, other — each rendered as r/w/x when granted or - when not. Why a single digit can represent read/write/execute Numeric notation like chmod 600 compresses that rwx combination into a single octal digit. Read is worth 4, write is worth 2, execute is worth 1 — powers of two — and you sum whichever bits are set. Note: powers of two are used here because each of read/write/execute is tracked as an independent bit (on or off), and any sum of a subset of {4, 2, 1} maps back to exactly one combination of bits. There's no ambiguity — for example, 6 can only mean read+write (4+2), never any other combination. Read and write, no execute ( rw- ): 4 + 2 = 6 Read only ( r-- ): 4 Read, write, and execute ( rwx ): 4 + 2 + 1 = 7 No access at all ( --- ): 0 A three-digit number like 600 lines up these single digits for owner, group, and other, left to right. 600 means "owner gets read+write, group and other get nothing." What the common numbers actually mean Reading the numbers mentioned at the top through this lens:

Event loops are a paradigm for processing events different than your typical single-threaded or multi-threaded application. Your request gets broken down into async "events" that are executed in a loop to improve performance and minimize synchronization across threads. It is famously used by Node.js as the backbone of their event processing and also by several other technologies like Redis and Nginx . In this article I'll explain the reason for why this paradigm was created and what it tries to optimize. By the end you'll come out a little wiser, and know more than just "don't block the event loop" :). Motiviation - why event loops? To understand why we need event loops we will explore a simple but key example. Take this straightforward HTTP request code, which sends a request and then tries to read the response from the socket: def send_http_request_GET ( domain : str , request : str ) -> HttpResponse : socket_fd = get_socket_for_domain ( domain ) write_res = os . write ( socket_fd , request ) data = os . read ( socket_fd , 1024 ) return HttpResponse ( data ) We do two things in this call - write data out and read data in. Both of these actions will end up triggering syscalls through the kernel that write and fetch data. In terms of time spent on the CPU, this is relatively inexpensive; sending out packets takes very little time, and eventually reading the response will also take very little CPU time. The key time lost is from waiting on the server to respond to us. os.read will block this thread until the response is available, meaning that the thread cannot be used for any other processing during this time. If our service is single-threaded, this means that we can't make any requests in parallel and are stuck waiting on any previous requests to finish. But of course, most services are not single-threaded, so this isn't a huge problem? Let's continue with the example code, imagining that instead we are processing these requests with multiple threads pulling from a

I just started learning wolfram and it feels really painful. As someone who comes from learning c/c++ the documentation on wofram feels all over the place. Like it is nice to have so many great functions but I wanna just know what Rationalize[_] returns 😭. So is it just me being dumb or is it actually all over the place? And either way how to learn it effectively? submitted by /u/Artyruch [link] [留言]

So just found out that Monopoly beat me to my idea.. So i had the idea to make monopoly work with your phone using nfc cards so you dont have the money hussle. and yea i put that on hold like i do with all my never finishing projects. and now i was wondering the game store and saw "Monopoly banking app" on the self. Screen of old About me Repo with project As you can see on the screen i added the project in dec 2023 18 months before hasbro released the app So i just want to say to all Hobbyist If you have a project that you like don't put it on hold. There will always be someone else with the same idea. Also do you guys think i should still continue with this project and add all versions to the app? since that was the original idea and for the monopoly one you need the special mobile banking version Or should i let it collect dust in my unfinished project pile? (I know not everyone has NFC cards laying around so there was always a plan to make it work by just selecting a player on the phone) submitted by /u/Jason-Deen [link] [留言]

What working on real systems taught me about maintainable code. My second job was the first time I worked with an international team where everyone had ten or more years of experience. I had maybe two. It was also the first time I was part of proper code reviews, branching strategies, and pull request workflows. Everything felt new and slightly intimidating. One of my first tasks was adding spacing between two elements. It should have been a simple margin or padding change, but I added a <br> tag instead. The feedback on that PR was polite but clear, and it made me a little embarrassed. That moment, along with dozens of similar ones, made me want to get better. I started reading about clean code and caring deeply about how my code looked. Small functions, no repetition, everything abstracted and organized. For a while, that served me well. It helped me grow from a junior developer into someone who could write code that passed review without a wall of comments. But over time, as I worked on larger systems with real users and real constraints, I started noticing that the rules I had learned didn't always hold up. Sometimes the "clean" approach made things worse, and sometimes messy-looking code worked better than the elegant version I would have written. This post is about how my definition of clean code expanded. I still believe in the principles I learned early on. I'd just add a few things to them now. What I thought clean code meant When I first started paying attention to code quality, my idea of clean code was mostly about appearances. If the code looked organized and followed certain patterns, it was clean. If it didn't, it wasn't. I believed in small functions for everything. If a function was longer than fifteen or twenty lines, something was wrong. I would extract pieces into helpers even when they were only used once, just because the parent function felt "too long." I was strict about DRY. Any time I saw similar logic in two places, I would immediately pul

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

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

submitted by /u/Shot-Reporter-2443 [link] [留言]

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

Ramp has launched its own AI model routing service, dubbed Router, that lets users and companies use and switch between various large language models via an API.