标签：#RAM

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

I wrote a detailed comparison of GitHub Actions vs Jenkins after working with both while learning DevOps. Instead of focusing on "which one is better," I looked at questions like: When does GitHub Actions become enough? When is Jenkins still the right choice? Performance and scalability Security and maintenance Cost Real-world use cases I'd love to hear where you disagree or what your production experience has been. Article: actions vs jenkins submitted by /u/ganeshak11 [link] [留言]

The AI neocloud provider, which specializes in hosting open source models, last raised at a $3.3 billion valuation in early 2025.

submitted by /u/Dear-Economics-315 [link] [留言]

I’ve been experimenting with local AI setups for a while, and honestly, most guides online are either too complicated or miss key steps. I recently set up Open WebUI with Docker and Ollama , and once it clicked, it actually felt pretty straightforward. Here’s a simple breakdown of what worked for me: Used Docker to avoid dependency issues (this saved a lot of time) Connected Open WebUI to Ollama local models Accessed everything through browser (ChatGPT-like interface) Tested basic prompts + API flow Played around with pipelines for structured outputs The biggest confusion I had was around connection between Open WebUI and Ollama, but once the API endpoint was correct, everything just worked. I also documented the full step-by-step setup, errors I faced (like 500 errors), and fixes here if anyone’s interested: 👉 Build your own ChatGPT locally in minutes If anyone else has tried similar local LLM setups, curious what stack you’re using or if there’s a better workflow. submitted by /u/thecoode [link] [留言]

I’m building an experimental HTML-to-PDF engine in Rust and would like technical feedback from people who understand browser engines, PDF generation, rendering, or high-volume document systems. The goal is to build a very low-RAM, highly parallel HTML-to-PDF engine for server workloads. Think invoices, reports, tables, receipts, business templates, generated dashboards, and API-based PDF rendering. The motivation is that Chromium/Puppeteer is very compatible, but expensive for high-volume PDF generation because each render can involve a heavy browser process/runtime. I want to explore whether a dedicated engine can cover common server-side HTML-to-PDF use cases with much lower memory and better multi-core scaling. Current architecture: HTML -> html5ever parser -> compact arena DOM -> cssparser stylesheet parsing -> cascade + computed styles -> box tree -> layout / pagination -> display list -> compressed PDF writer Some current design choices: Rust implementation no Chromium or browser subprocess compact arena-based DOM instead of pointer-heavy node graph independent render jobs so many PDFs can render in parallel across worker threads display-list boundary so layout is separate from PDF writing optional bounded pre-layout JavaScript stage behind a trait PDF backend supports compressed streams, selectable text, embedded fonts, Unicode/ToUnicode, and font subsetting work The long-term ambition is “lean and fast HTML-to-PDF with broad CSS and controlled JS support,” but I’m trying to be realistic. I know “full CSS/JS” is basically browser-engine territory, so I’m thinking the practical first target should be server-generated documents rather than arbitrary websites. Questions for the community: Is this technically realistic if the scope starts with business/document HTML rather than full browser compatibility? What are the hardest parts I’m likely underestimating? Which CSS/layout features are absolutely necessary for real-world adoption? Is pre-layout deterministic J

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

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

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

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

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

The acquisition was approved without concessions by the Department of Justice in June.

Exhaust the enemy's strength without fighting. Weaken the strong by nurturing the soft. — The 36 Stratagems, " Wait at Leisure While the Enemy Labors " P flipped the business card over and wrote one letter on the back: P . Then P walked into the conference room. P didn't do opening lines. P doesn't have a name — not yet, not in this series anyway. But if you've read the earlier stories, you'd recognize the signature. The first story — P's own article got flagged as "low quality" by the company's AI moderation system. P dug into the internal API, pulled 347 flagged records — effective accuracy came out to 38%. More false positives than correct identifications. The second story — an AI payment gateway processing $2.8 billion. The CTO backed it with formal verification, claimed it was "mathematically bulletproof." P spent eight months quietly building an adversarial testing pipeline, and proved the gateway would approve illegal transactions. P won both times. P left zero fingerprints both times. After those two jobs, P stopped working for other people. This time, P got brought in as an independent evaluator. Two Companies, One Customer, Zero Questions The customer was a mid-sized industrial IoT firm called FirmCore . Their production-line gear had been running for almost a decade. The monitoring system was going down once a month, and management had finally had enough. They decided to bring in an AI monitoring platform. A good call — right up until they decided to run two vendors through POC at the same time and pick a winner. "We want to see who can actually cover our failure modes," the VP said in the meeting. "We've also brought in an independent evaluator." P was that evaluator. The two AI monitoring companies were MonitorAI and SentryWave . MonitorAI's pre-sales team went first, slides blazing with "99.3% fault coverage, validated across 3 manufacturing customers." SentryWave followed right behind: "99.7% coverage, 7-day deployment" — bigger numbers, bolder font.

In this talk, Trisha identifies issues that slow down developers when writing, running and debugging tests, and look at tools that can help developers with each of these problems. There's live coding, analysis of social media poll results, an overview of solutions in this space, "best practice" recommendations, and machine learning will be mentioned at some point. submitted by /u/goto-con [link] [留言]

Most teams still suffer from a classic disconnect: the gap between what a developer is actually doing in their local Git repo and what Jira shows to the rest of the team. Developers forget (or delay) updating tickets not because they're lazy, but because switching context to Jira breaks flow. This leads to stale Jira boards, painful standups full of status checks, and poor visibility for PMs and Scrum Masters. I decided to close this gap with a tool called Jitly . The Core Idea Instead of manually doing: git pull origin main git checkout -b feature/ABC-123-xyz Go to Jira → Move ticket to In Progress Jitly lets you run jitly start ABC-123 and it handles everything automatically — including respecting team-specific branch naming conventions and commit message formats. Technical Implementation Highlights Jira Integration : Supports both Jira Cloud (SSO/OAuth2) and Jira Server/Data Center (PAT). Uses atlassian-python-api under the hood with proper session management. Git Operations : Uses GitPython + subprocess for safe operations. Handles dirty working tree by offering stash/push/discard choices. Workflow Hooks : Detects ticket status change (via manual command for now) and triggers git + Jira actions. Configuration : Team-level config for branch patterns (e.g. {type}/{ticket}-{slug}) and commit templates using Jinja2-style formatting. Idempotency : If a branch already exists for a ticket, it intelligently checks out and continues work instead of failing. Single binary-like experience via pip install with entry point. It's currently focused on the most painful part of the developer workflow — starting and finishing work — while keeping the tool lightweight. Would be interesting to hear how others are solving this Jira-Git synchronization problem in their teams. What tools/workflows do you use today? Download link: https://pypi.org/project/jitly/ Demo Video: https://www.youtube.com/watch?v=_czVTfqGKGY submitted by /u/Direct_Holiday_5934 [link] [留言]

I saw an issue today on a fairly popular project (better-auth, see the link to the issue attached). No repro, no context, just a wall of caps and profanity ending in "fuck you". The maintainers ship this for free. People run production businesses on top of it, for free. And the thanks is someone raging into a text box because a minor bump cost them an afternoon. I maintain and contribute to a few projects myself, so this hits a nerve a bit. Something people don't see from the outside: it's not enough to know how to build the thing. You also have to know how to defuse a thread where someone's insulting you and not fire back, even though most of us aren't paid for any of it, let alone the work of staying civil while being told to get fucked. I'm not pretending breaking changes don't cause real pain (that's what the issue is about). But I keep coming back to a boundary question: if you're not paying for it, do you actually get to demand anything? (Obviously yes, but we still need some boundaries) submitted by /u/swithek [link] [留言]

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

This week was largely a Claude story: Sonnet 5 landed with enough benchmark muscle to make Opus feel redundant for most workloads, and GitLab's production data backs up the claims. Alongside that, GitHub Copilot quietly dropped its JetBrains friction, and Google's image model got cheaper and faster on Vercel's gateway. Here's what's worth acting on. Claude Sonnet 5 launches on Vercel AI Gateway Sonnet 5 is available now via Vercel AI Gateway at anthropic/claude-sonnet-5 . Launch pricing is $2/$10 per million input/output tokens—identical to Sonnet 4.6—but that rate expires August 31, after which it steps to $3/$15. The model matches Opus 4.8 on coding and agentic benchmarks, which means you can stop routing hard tasks to Opus and absorb a 50–67% cost reduction in the process. For AI SDK users, this is a one-line change. Stronger long-context handling and document parsing are the practical wins for RAG pipelines and multi-turn agent workflows—two areas where Sonnet 4.6 had real rough edges. Verdict: Ship. Update your model identifier before August 31 while the launch pricing holds. Zero breaking changes, and there's no reason to stay on 4.6 for new work. Sonnet 5 closes Opus gap at lower cost Beyond the Vercel integration, the broader Sonnet 5 release deserves its own read. The model is now the default reasoning tier replacing Sonnet 4.6 across Anthropic's plans, and the capability jump is specifically on agentic task completion—planning, multi-step tool use, brownfield code navigation. Early testers report that tasks which previously stalled midway through agent loops now finish end-to-end, which is a qualitatively different outcome from incremental benchmark gains. The economics are straightforward: Opus-level performance at Sonnet prices through August, then a modest step up to $3/$15. If you're running production agents today, the cost-per-completed-task improvement compounds because you're paying less and spending fewer cycles on failure recovery and re-promptin

TL;DR codegraph , codebase-memory-mcp , and serena all got there first, handing a coding agent code intelligence over MCP so it stops grepping. On my own open-ended questions the token bill didn't budge: the agent kept sliding back to grep, and no amount of forceful prompting could stop it. So I built @ttsc/graph . It gives the agent an index the TypeScript compiler already resolved, never the source bodies, through a single tool with a forced chain-of-thought. On "how does this work?" questions that works out to roughly 10× fewer tokens, and the answers are no worse. That figure is a median, and a conservative one. Repository: https://github.com/samchon/ttsc Benchmark: https://ttsc.dev/docs/benchmark/graph 1. Preface 1.1. What @ttsc/graph Is On the left, the agent is lost in a maze of files, chasing dashed arrows dozens deep. On the right, it's reading a single compiler-built graph of nodes and edges, with the file:line anchors it can open and check. You're new to a TypeScript repo, so you ask the agent for a tour: what's the main runtime flow, from the public API down to the code that does the work, and what should you read first? You know how it goes. It opens a file, follows an import into another, then another, and a few dozen files later it gives you an answer. @ttsc/graph cuts that crawl short. Over MCP, it hands your agent a graph of your TypeScript codebase that the compiler itself drew: what calls what, what depends on what, and where each piece lives. The agent answers structural questions straight from the graph instead of spelunking through files, and every claim it makes points at an exact file:line the compiler resolved. Nothing invented, just a location you can open and check for yourself. It's the same question and the same agent in every case, and only @ttsc/graph stays flat across the repos no matter how big they get. The other three, codegraph, codebase-memory, and serena, swing all over the place, and a few even spend more than the baseline does

While researching the massive wave of digital transformation rewriting the rules for startups this year, I stumbled upon an insightful podcast by the tech firm GeekyAnts. Hosted by Prem, the episode featured Sanket Sahu, the co-founder of GeekyAnts, who recently emerged from a year and a half hiatus to discuss what he calls the " AI-native shift ." As someone navigating the unpredictable US tech market in 2026, listening to their conversation felt like a reality check. We are constantly flooded with news about AI replacing engineers or cutting budgets, but this discussion offered a grounded perspective on what is actually happening on the ground in software development. The Illusion of Speed The central theme that caught my attention was the sheer velocity of modern AI adoption. Sanket made a striking contrast: while television took decades to become a common household utility, modern AI systems like ChatGPT or Claude reached exponential revenue and widespread adoption in mere months. But here is where the critical analysis kicks in. As founders, we often mistake engineering speed for product success. The podcast highlighted a massive bottleneck that many of us are guilty of overlooking: the human limit. While AI can spin up code in hours instead of months, the time required for human review, validation, and team collaboration remains relatively static. If an organization rushes to ship code simply because it can, they risk launching products that lack deep market validation. True product development still requires user testing and meticulous iteration. The building phase might be operating at 10x speed, but the surrounding human infrastructure is only moving at 1.5x. Fluid Roles and the Rise of the "Builder" Another significant takeaway for Western businesses is the shifting definition of software roles. The traditional silos dividing front-end, back-end, and DevOps are rapidly blurring. According to the insights shared in the video, the engineering ecosystem is mo