标签：#m

People in Europe will soon lose access to Studio Canal movies they paid for on the PlayStation Store.

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

Repo link and results - https://github.com/Abhinand20/MathFormer Task: Given a factorized expression like (7-3*z)*(-5*z-9), predict the expanded form -> 15*z\*2-8\*z-63 Key takeaway: A tiny (4M param) seq2seq model trained with no math knowledge reaches ~98.6% accuracy on symbolic math tasks, suggesting it learns structural token transformations rather than any notion of operators or variables. Scaling this up could help explain why LLMs appear to “reason” mathematically, when they may actually be performing large-scale structured pattern completion. How does RL change this paradigm given the inherent architecture is still based on attention? submitted by /u/AlphaCode1 [link] [留言]

In the landscape of modern programming, delimiters serve as the essential scaffolding that organizes logic and defines structure. Among these, curly braces—often referred to as braces or squiggly brackets—occupy a unique position. While they are ubiquitous, they are frequently the source of developer frustration and logic errors. A common pitfall for many programmers is the tendency to treat all delimiters as interchangeable, leading to a fundamental misunder身 of how a compiler or interpreter parses a script. Confusion often arises when developers conflate the purpose of curly braces with those of parentheses or square brackets. For instance, in many languages, curly braces denote a scope or a code block, whereas square brackets handle indexing. However, the nuances become even more complex when examining specific environments like R, where the semantic meaning of a symbol can shift depending on the context—moving from defining a function to facilitating list extraction. Understanding the specific curly braces semantics is not merely an academic exercise in syntax; it is a practical necessity for writing clean, maintainable code. When a developer understands why a brace is used, they can more easily debug nested structures and communicate intent to their teammates. Grasping these distinctions reduces the cognitive load required to read complex scripts and prevents the subtle bugs that emerge when syntax is used incorrectly. Curly Braces vs. Other Delimiters: Semantic Roles in R and Beyond To master programming syntax, one must move beyond recognizing symbols and begin understanding their semantic intent. While many developers treat curly braces as just another set of punctuation, their role is fundamentally distinct from parentheses and square brackets. Understanding the nuance of curly braces semantics is essential for writing logic that is both functional and readable. The Primary Role: Defining Code Blocks In most procedural and object-oriented languages (such as

Hello Devs 👋 AI coding assistants have changed the way many teams build software. Tasks like generating components, creating tests, writing boilerplate, or handling repetitive refactors can now happen in minutes instead of hours. The productivity gain is real and that part is easy to notice. What becomes interesting after using these tools for a while is that a different bottleneck starts appearing. Code generation becomes faster, but the review process often stays the same. Teams can generate hundreds of lines of code within minutes, but someone still has to answer important questions: Does this actually solve the requirement? Are edge cases covered? Will this introduce side effects? Does it align with existing patterns? The speed of writing code has changed. The need for confidence has not. That is where I think the conversation around AI-assisted development is starting to shift. The challenge is becoming less about generating code and more about making sure the generated code is actually safe to ship. The Problem With Reviewing AI-Generated Code Like Regular Code Imagine asking an AI coding assistant to implement coupon validation for premium users. Add coupon validation for premium users and create tests A few seconds later you get: if ( user . isPremium ){ applyCoupon (); } Nothing immediately looks wrong. The code is clean, there are no syntax issues, tests may pass, and the implementation appears complete. But pull request reviews usually go beyond reading diffs. Reviewers start asking questions such as: What happens if the coupon has expired? Does this affect payment calculations? Should audit logs be updated? Are there services depending on this behavior? This is where AI-generated code becomes interesting. It can often be functionally correct while still missing important implementation details. Research around larger AI-generated projects has also shown that functional correctness does not necessarily translate into maintainable system design. Teams stil

Maraget Atwood, the storied author of The Handmaid's Tale and The Blind Assassin, was interviewed as part of the Babell Literary and Cultural Festival in Porto, Portugal. As it usually does at these things, the issue of AI came up, and Atwood didn't mince words. According to Deadline's recap, Atwood said she'd used an AI […]

Google's NotebookLM is great. But handing your research notes, PDFs, and meeting transcripts to Google's cloud is a hard sell for a lot of people — especially when those documents contain client data, unpublished research, or internal strategy. So I spent a weekend testing five open-source alternatives. Three things mattered: can I docker compose up in under 10 minutes, does the podcast feature actually work offline, and what breaks first? Here's what I found. The Contenders Project Deploy Time Min VRAM True Offline License Open Notebook (lfnovo) ~8 min 8 GB Yes MIT Notex (smallnest) ~3 min 4 GB Yes Open source KnowNote (MrSibe) ~2 min 4 GB Yes Open source NotebookLM-Local (nagaforcloud) ~15 min 8 GB Qwen-3 4B bundled Open source InsightsLM (phsphd) ~30 min 8 GB Yes N8N SUS license 1. Open Notebook — The One to Beat git clone https://github.com/lfnovo/open-notebook cd open-notebook docker compose up -d Eight minutes from git clone to the web UI on localhost:3000 . It ships with 18+ model providers pre-configured — Ollama, OpenAI, Claude, DeepSeek, Gemini, all selectable per notebook. The podcast generator supports 1-4 speakers with different voices, and it runs entirely offline when you point it at an Ollama backend. What works: Document ingestion is fast — SurrealDB's vector + full-text index handles 200-page PDFs without choking Model switching is genuinely useful — Claude for deep analysis on one notebook, local Qwen for quick summaries on another Podcast quality with 2 speakers is close to NotebookLM's. 4 speakers is still rough. What breaks: Citation highlighting is still being rebuilt (work in progress as of June 2026) Single-user only — no team/workspace isolation built in Docker required. No native binary. 2. Notex — Single Binary, Zero Dependencies Notex is written in Go. You download a single binary (~25MB) and run ./notex . That's it. No Docker, no Python venv, no database setup. It supports PDF, TXT, MD, DOCX, HTML, audio, and YouTube/Bilibili URLs as so

The question My son was on the sofa with his iPad, poking at the live "Predict the Bracket" game — the whole 2026 World Cup knockout tree on one screen, every slot already filled with the crowd's favourite for that match. Tap a match, see who most people think goes through, watch the picks flow all the way up to a predicted champion. He frowned at it. "Daddy, how do they know which team plays which team? The teams aren't even decided yet." He'd caught something real. The little cards sitting in those slots were only predictions — the crowd's best hunch — but the shape underneath them, who-plays-who and where, was already locked in. Months before a single match kicks off. Fair question. The 2026 World Cup has 48 teams in 12 groups (A through L). The top two of every group go through — that's 24 teams. Then, to round it up to a nice bracket of 32, they also take the 8 best third-placed teams . Twelve groups, but only eight of their third-place teams get a golden ticket. "So you don't know which eight until the very end," he said. "But the bracket's already sitting right there on the screen." "Right." "That's cheating." It isn't cheating. It's one of the prettiest little bits of planning in all of sport, and by the end of the afternoon he understood it better than most adults do. We did it with the dining chairs. The setup, first Before the chairs, my son needed to know where these kids even come from. So we did the boring-but-important part first. A football group is a handful of teams who all play each other. When it's done, the best go forward, the worst go home, and — this is the bit that matters — there's a kid right on the line: the best of the rest , neither safely through nor clearly out. That borderline kid is the star of this whole story. Call them a wandering kid . To learn the trick, let's make the groups nice and small: two groups, A and B, three kids in each — six kids total. In each group the top kid goes straight through to the next round, the bottom ki

The document hub, our vision of DocuShark . We want to make collaboration simple again. There are too many amazing tools, too many surfaces to get lost in. Bring them together - and you've got a near-endless wealth of knowledge for anyone with access. The editor is out, and loaded with features, only getting more powerful. Our editor offers: high-speed, realtime collaborative editing on documents in your Cloud Workspace, documents that can write, draw, and store files at the same time, never lose access when your network goes out - offline copies let you use every feature anywhere, and agent endpoints (MCP) for all your agentic needs. The page and canvas are one, with generous file storage, allowing you to design whitepaper-level PDFs in hours, not weeks, with every file, reference, and diagram within that document, all while offline with changes saving when you're back online. It's a mini Google Drive in each document, with offline storage so you can edit anywhere, anytime with changes syncing across your team. The Integrations Story - Combine, don't Compete DocuShark isn't here to compete, it's here to integrate, and keep complex ideas lean and organized across platforms. As we release our integrations, knowledge drift shrinks, leaving you with richer context while you keep working with your favorite apps - or don't, we have rich editor tools as well. An Agent Powerhouse - Keep your Context Close DocuShark is built for agents from the ground up. Citations keep your agent's research properly attributed. Fields eliminate drift and block duplication before it starts. Anchored edits make changes surgical, not sweeping. More is in the works, and the roadmap is moving fast. Try DocuShark - The Editor's Free and Fast You can either launch straight into the editor , or get a cloud workspace and start collaborating today!

Everyone hits the same wall with Claude Code. You add a rule to CLAUDE.md . It works. You add ten more. They mostly work. You add forty more — and now Claude is cheerfully ignoring the rule you care about most, the one that's been sitting there since day one. So you make it LOUDER , in caps, with three exclamation points. It still gets skipped. The instinct is to write more. The fix is almost always to write less . Here's why, and what to do instead. Instruction-following has a budget, and you're overdrawn This is the part most CLAUDE.md guides skip. Frontier models reliably follow on the order of 150–200 instructions at once — and adherence to any single rule drops as you stack more on top of it. It isn't a cliff; it's a slow tax. Every line you add makes every other line a little less likely to be honored. Now subtract what you don't control: Claude Code's own system prompt already spends a chunk of that budget before your file is even read. So the working budget for your project rules is smaller than the headline number — and a sprawling 300-line CLAUDE.md isn't 300 rules followed, it's maybe the first 150 followed well and the rest treated as ambience. The mental model that fixes everything downstream: CLAUDE.md is a budget, not a wishlist. You are not writing documentation. You are spending a scarce attention allowance, and every line competes with every other line. The test for every line: would you bet $5 it's followed? Go through your file line by line and ask one question of each rule: would I bet money this fires every time it's relevant? Three outcomes: Yes, and it's load-bearing — keep it. This is what the budget is for. Nice to have, but I wouldn't bet on it — cut it, or move it to a referenced file (below). It's diluting the rules you would bet on. It absolutely must happen every time — then it doesn't belong in CLAUDE.md at all. Make it a hook. That third category is the one people get wrong, so let's be concrete about it. Advisory vs. deterministic:

A checkout saga spans inventory, payment, shipping, and loyalty. Downstream latency shifts every hour. Black Friday is not the day to discover your payment step timeout is baked into application.yml across twelve Spring Boot services. Kiponos.io gives every saga participant the same live orchestration parameters — step timeouts, retry budgets, compensation triggers — via one shared config tree. Each JVM reads locally on every saga step; ops adjusts once in the dashboard; WebSocket deltas propagate without redeploying the fleet. Why sagas break with static config Typical saga coordinator code: if ( step . elapsedMs () > 8000 ) { compensate ( "payment" , sagaId ); } That 8000 usually comes from: Per-service YAML — payment service says 8s, inventory says 12s; nobody agrees during an incident Env vars in Helm — change means rolling twelve deployments Shared DB config table — poll per step adds latency and coupling Saga steps are high-frequency reads inside workflow engines. You need local memory reads and async updates — the same contract as live API rate limits . Architecture: one tree, many participants ┌─────────────────┐ WebSocket deltas ┌──────────────────────┐ │ Kiponos.io UI │ ────────────────────────► │ Inventory service │ │ platform ops │ │ Payment service │ └─────────────────┘ │ Shipping service │ │ (each: in-mem SDK) │ └──────────┬───────────┘ │ .getInt() local ▼ ┌──────────────────────┐ │ saga step executor │ └──────────────────────┘ Every participant connects to profile ['orders']['v2']['prod']['sagas'] . When NOC extends payment.step_timeout_ms , all JVMs see the new value on the next step — no config server poll, no inter-service "what is timeout now?" REST calls. Shared saga config tree sagas/ checkout/ payment/ step_timeout_ms : 8000 max_retries : 2 retry_backoff_ms : 500 compensate_on_timeout : true inventory/ step_timeout_ms : 5000 max_retries : 3 hold_ttl_seconds : 120 shipping/ step_timeout_ms : 12000 fallback_carrier : ups_ground global/ saga_ttl_m

I've been building agent workflows for a while, and one capability keeps coming up that the ecosystem hasn't fully reckoned with: letting an AI agent publish a document to the public internet and hand someone a link. It sounds trivial ("save HTML, return a URL"). It isn't. The moment an autonomous agent can mint a public link, you've handed it a primitive that touches access control, data exposure, and reputation. This post is about the design questions that surface once you take that seriously, written by someone who builds in this space. Disclosure up front: I work on Thryvate, a document-sharing tool with an MCP server. More on that at the end, but the problems below are general. The naive version The first version everyone writes is a tool that takes content and dumps it to object storage behind a public CDN URL: publish(html) -> https://cdn.example.com/a8f3c2.html Ship that and an agent can now share its work. It can also now: expose a half-finished draft to anyone who guesses the URL, leave that URL live forever with no way to pull it back, publish something containing a customer's name with zero record of who saw it. For a human hitting "publish" deliberately, those are acceptable defaults. For an agent doing it as one step in a longer plan, they're landmines. What "publish" should actually mean for an agent A few properties turn the naive primitive into something you'd trust an agent to call: 1. Default to private, opt into public. The safe default for an agent-minted link is not "world-readable." It's "only people on this list" or "only people with the password." Public should be an explicit parameter someone has to set, not the fallback. 2. Revocability. Anything an agent publishes, you must be able to un-publish instantly. A live link is a liability with a half-life, and the ability to revoke is what makes it safe to let the agent create them liberally. 3. Expiry as a first-class field. "This link dies in 7 days" should be a parameter on the publish call,

Hello, I'm Maneshwar. I'm building git-lrc, a Micro AI code reviewer that runs on every commit. It is free and source-available on Github. Star git-lrc to help devs discover the project. Do give it a try and share your feedback. A single honeybee has exactly one move: find nectar, fly it home. Impressive aviation. Add a few thousand more bees and something strange happens. Now they're making honey, cooling the hive, and defending the colony against threats ten thousand times their size, with no Jira board, no standup, and nobody handing out tickets. That jump from "can fetch nectar" to "runs a self-regulating honey factory" is the best mental model I've found for multi-agent AI systems . So let's steal it xD First, what even is an "agent"? Before we throw thousands of them at a problem, it's worth pinning down what one actually is. An AI agent is an autonomous system that performs tasks on behalf of a user (or another system) by designing its own workflow and using available tools . Three things decide how good an agent actually is: The LLM powering it i.e the brain. Its tools which is the hands. The reasoning framework is how it turns tool outputs into the next decision. A single agent is fine. It's our lone bee, and it can do real work. But ask it to research a topic, run heavy calculations, scrape five websites, and write the summary, and you start to feel the ceiling. Multi-agent systems: bees, but for compute A multi-agent system keeps each agent autonomous but lets them cooperate and coordinate inside a structure . The magic isn't any single agent, it's the choreography between them (claude which is famous for that). And there are a few classic ways to choreograph it. 1. The decentralized network (a.k.a. "everyone's a peer") Every agent can talk to every other agent. They share information and resources, and they all operate with the same authority . No boss. Just message-passing. This is your agent network . It's great for emergent, collaborative problem-solv

Prime Day is officially over, but many of our favorite, hand-picked deals are still available through the weekend.

Paul Meade, the Apple vice president in charge of the Vision Pro headset, is reportedly leaving the company to join OpenAI’s hardware team.

Hey guys, I was playing around with Nanotron recently and got super frustrated by how many heavy, hardware-specific dependencies it imports at the module level ( flash-attn , triton, functorch , etc.). If you try to run it on older or budget GPUs like a T4 or V100, it just crashes on import. So I wrote Picotron ( https://github.com/Syntropy-AI-Labs/picotron ) to solve this. It's a clean-room rewrite that gets rid of all mandatory GPU-specific dependencies. It runs on pretty much any GPU that supports PyTorch (defaults to FP16 on older cards under compute capability 8.0, and BF16 on newer ones). It falls back to standard PyTorch SDPA by default, but still hooks into FlashAttention-2 at runtime if it detects you have it installed. I used an AI assistant to write a lot of the boilerplate/code modules, but I've got it working locally and just trained a tiny 2M model on FineWeb-Edu. Also added configs for: • GQA / MLA (Multi-head Latent Attention) • QK-Norm & logit soft-capping (Gemma 2 style) • Parallel FFN/Attn runs • ZeRO-1 wrapping on DDP Roadmap is pretty short right now: MoE prep (routing capacity factors and load balancing loss) Making dataset prep easier than streaming manually Check it out if you've been fighting with CUDA dependency hell: https://github.com/Syntropy-AI-Labs/picotron submitted by /u/Capital_Savings_9942 [link] [留言]

The Pocket Micro 2 has a larger battery, improved controls and even a 3.5mm headphone jack.

Back in May we here at Waggy Labs launched the beta release of our Web Component UI kit " Yumekit ". Yumekit is a pure web component UI toolkit. Upon its release, it was comprised of roughly 36 fully styled and fully functional UI components that work with just about every web architecture straight out of the box. No configuration or setup necessary, all one needs to do is include the Yumekit script (using either a CDN or installed through NPM) and start building. All components come styled out of the box with no need to include any style sheets. Last week, we launched version 0.5. With this latest release, that job is being made easier with the inclusion of new components that add several layout options as well as new Data, Navigation, and Utility components, bringing the total number of components to 51. For us, this toolkit has provided us a framework-agnostic solution for our internal tools as well as any client projects. With over 60 themes spread over 9 well-known (and some brand new) open source Design Systems all built directly into the library, we have plenty of options available to us to keep our designs fresh without needing to spend hours dealing with CSS. It's light-weight, dependency free, and well documented. New in 0.5 Animate The y-animate component allows you to animate entrances and exits for nested components using a few simple configuration attributes. Code The y-code component allows you to display formatted and colorized code, as well as providing a few easy and convenient ways for your users to copy the provided code. Help The y-help component provides a tutorial experience for users of your application with minimal configuration. Simply provide the elements to be highlighted, the messages to be shown, and it handles the rest! Paginator y-paginator provides a configurable set of pagination buttons to help your users navigate through large data sets. Sidebar We had originally included a y-appbar component (which we still do) that had a "Sideba

Your AI is making your content invisible. Not because it writes badly. Because it writes safely . Ask ChatGPT to summarize an article and it will produce a polished, agreeable précis that offends nobody and surprises nobody. The output is technically accurate and completely forgettable. The problem is structural: most people prompt their AI to confirm what an article says, not to find where it fights with the crowd . The result is a feed full of content that agrees with other content, in increasingly fluent prose, at exponentially increasing volume. If you want to be read, you need to stop prompting for summaries and start prompting for conflict. Why Agreement Is the Fastest Path to Obscurity There is a reliable body of research behind why contrarian content performs. Jonah Berger and Katherine Milkman's widely cited study, "What Makes Online Content Viral?" ( Journal of Marketing Research , 2012) , found that content evoking high-arousal emotions — anger, awe, anxiety — is significantly more likely to be shared than content that merely informs or reassures. Agreement is a low-arousal state. Surprise and contradiction are not. This is not a trick to manufacture outrage. It is a structural observation: the human brain is wired to pay attention to pattern breaks. An article that says "AI is changing content creation" registers as noise. An article that says "AI is making content creation worse, and here's the data" registers as a signal worth attending to. The distinction matters because the mechanism is cognitive, not emotional. You are not trying to provoke readers. You are trying to interrupt the predictive pattern they've built from reading a hundred similar articles before yours. The Problem With Generic AI Summarization When you ask an LLM to "summarize this article" or "give me the key takeaways," the model optimizes for coverage and balance. It is trained on human feedback that rewards thoroughness and penalizes controversy. The output tends to be accurate, ne

Hey everyone, I'd like to share my project along with a short explanation of the process and why it came about in the first place. To start off, I'm not exactly the best at cryptography/steganography, in my case it's always been something that sat in the background, as one of the sub-fields needed for another (main) field I'm actually interested in. For this project I tried to look up as much information as possible about what's currently considered best practice (I mainly relied on NIST for this), what implications exist, and what potential "attacks" exist against this way of hiding information, but I honestly can't say whether I covered everything, which is why I wanted to share this project here, mainly for the sake of learning. I'd be grateful for any feedback on what I could have done better / what I might have missed, etc. Right now, I consider this project closed at this point and will most likely not update it further, although I'd like to apply all the feedback to my own knowledge going forward. For over a month I did a lot of research into using ML models as a carrier for hiding data. I needed this as one of the stages for my main project. That's how I ended up on the topic of hiding information in model weights. Initially I assumed a simple method of directly writing data into randomly selected weights. I quickly concluded, though, that this would be absurdly trivial to detect, and potentially also to read. Next came the idea of using something like a deterministic coordinate map describing where to read the data from (location-id + position-id). The program wouldn't modify all the bits needed to write the message instead, it would write separate bits representing already-existing values (pointing to specific locations in the model) from which the existing 0s and 1s would need to be read. In practice, only parties A and B would know how to derive these positions. This way, someone unaware of the algorithm would only see what looks like noise of varying va