标签：#programming

I built a simple mobile World Cup Bingo game and would love some feedback. The idea is simple: - Create your own World Cup bingo card - Follow the matches during the tournament - Earn points as events happen - Compete against friends - Check the final leaderboard when the tournament ends There's a free version and an optional Pro upgrade (R$4.90) that removes ads, unlocks exclusive themes, allows unlimited cards and gives up to 3 free swaps per game. I built it mainly because I wanted something more casual and social than fantasy football apps. Would love to hear what football fans think: https://bingo-da-copa.vercel.app/ submitted by /u/No_Net_1962 [link] [留言]

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

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

submitted by /u/West-Chard-1474 [link] [留言]

submitted by /u/Old-Illustrator-8692 [link] [留言]

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

Why Studying Open Source Code Is Important ​ Reading open-source frameworks teaches things that textbooks usually cannot. ​ For example, from AsyncTask we learn: ​ real-world concurrency design ​ serialization strategies ​ thread scheduling ​ producer-consumer patterns ​ executor frameworks ​ synchronization tradeoffs ​ Theory vs Reality ​ A textbook may say: ​ "synchronized prevents race conditions" But Android source code shows: ​ Why do engineers use synchronization ​ WHERE they used it ​ WHAT problem they were solving ​ WHAT tradeoffs they accepted ​ That is real engineering knowledge. ​ Why Great Engineers Read Source Code ​ Engineers who study frameworks like: ​ OpenJDK ​ Android ​ Linux kernel ​ OpenFOAM ​ FreeCAD ​ develop: ​ architectural thinking ​ systems intuition ​ debugging maturity ​ performance awareness ​ concurrency understanding ​ far beyond ordinary programming. ​ What You Are Actually Learning ​ Here My small example contains concepts from: ​ JVM monitor implementation ​ object lifetime ​ static memory model ​ synchronization semantics ​ concurrent scheduling ​ executor design ​ Android framework architecture ​ This is exactly why studying framework source code is powerful. ​ You stop seeing programming as: ​ "writing syntax" and begin seeing it as: ​ "designing systems" ​ That transition is what separates an average coder from a strong software engineer. ​ ​ submitted by /u/sommukhopadhyay [link] [留言]

Hey everyone, I’ve been developing a real-time post-processing engine called Shade Elements , and it is finally live. It essentially transforms your entire Windows operating system, applications, and games into a living canvas. The main goal was to build something insanely powerful but completely non-invasive. Instead of injecting into game files (which triggers aggressive anti-cheat software), Shade Elements uses a custom C++ DirectX 11 engine to operate entirely as a screen-space overlay. It hooks the display compositor directly, meaning you get zero input lag and zero ban risks. Here is what the engine can do: 70+ Stackable Shaders: You aren't limited to one effect. You can stack a CRT curvature filter over a VHS tape glitch, add realistic Phosphor Burn-in, or drop an ASCII visualizer over your favorite game. Window-Aware Technology: The engine actively reads your Z-order. You can use the Bokeh Depth of Field shader to automatically track your active foreground window, keeping it razor-sharp while blurring out your messy desktop behind it. Temporal Memory: The pipeline utilizes history buffers, allowing for buttery-smooth Motion Blur or the ability to "Save State" a snapshot of your screen mid-render and composite it back into the pipeline later. Live Customization: Every shader has real-time sliders (Intensity, Radius, Speed, etc.) that parse dynamically. Plus, global hotkeys let you kill the overlay instantly without tabbing out. I would love for you to try it out and tear it apart. I’ve set it up so the first 100 downloads are completely free! You can check it out and grab a copy here: https://compaces.itch.io/shade-elements Let me know what you think of the tech, or if you have any requests for new shaders to add to the vault! submitted by /u/Wackedout1 [link] [留言]

A field guide to the practice that's reshaping how software gets built with AI agents. TL;DR — Spec-Driven Development (SDD) makes a precise, executable specification the source of truth and treats code as a generated, verifiable artifact. The spec declares intent ; the code realizes it. In 2026 it went mainstream because AI agents are great at writing code and terrible at guessing what you meant. Jump to: Why now · Specs vs. executable specs · Maturity model · Workflow · Tooling · EARS · Worked example · Caveats · Bottom line Why now? The "vibe coding" backlash The movement defines itself against "vibe coding" — the term Andrej Karpathy popularized in early 2025 for loosely prompting an AI and shipping whatever comes back. Vibe coding is great for throwaway prototypes and miserable for anything that has to be maintained. SDD is the disciplined counterweight: if AI writes most of the code, then the specification becomes the highest-leverage artifact a human produces . The skill that matters shifts from typing the implementation to defining the intent precisely enough that a machine can't get it wrong. Raw specs vs. executable specs This is the single most important distinction in the whole topic — and the one most "SDD explainers" skip. Traditional design docs SDD specs Read by Humans Humans and agents Enforcement Advisory — devs may diverge Executable — tests fail on drift Lifecycle Goes stale, becomes archaeology Living, continuously validated Lives in A wiki nobody opens The repo + CI/CD "Traditional specs are read by humans, while SDD specs are executed as BDD scenarios, API contract tests, or model simulations." — Deepak Babu Piskala, Spec-Driven Development: From Code to Contract in the Age of AI Coding Assistants (arXiv, Jan 2026) [2602.00180] Spec-Driven Development:From Code to Contract in the Age of AI Coding Assistants The rise of AI coding assistants has reignited interest in an old idea: what if specifications-not code-were the primary artifact of softw

"Intelligence isn't about searching everywhere—it's about knowing where not to search." Artificial Intelligence is often associated with neural networks, large language models, and autonomous systems. But long before modern generative AI, computer scientists were solving a much deeper question: How do intelligent systems make decisions efficiently? Whether you're building search algorithms, recommendation systems, autonomous robots, or distributed systems, the architecture of intelligence teaches timeless lessons about solving problems under uncertainty. Let's explore five powerful ideas that shaped AI—and why they matter far beyond computer science. ✈️ 1. The Pilot's Dilemma: Why Blind Search Fails Imagine you're a pilot. Suddenly, one of your engines fails. In the next few seconds, there are hundreds of switches, buttons, and controls available. If you treated every control equally, you'd spend precious time trying random combinations. That is exactly how uninformed search works. Algorithms like: Breadth-First Search (BFS) Depth-First Search (DFS) have no knowledge of where the solution might be. They simply explore. Start ├── Option A ├── Option B ├── Option C └── ... The larger the search space becomes, the less practical this strategy is. A pilot doesn't blindly flip switches. They use additional knowledge : Engine pressure Fuel flow Hydraulic readings Warning systems Those clues dramatically reduce the number of possibilities. This is exactly what AI calls Informed Search . Instead of exploring everything, intelligent systems use knowledge to eliminate impossible paths before searching them. 🧠 2. Heuristics: The Cheat Code of Intelligence The secret behind informed search is something called a heuristic . A heuristic is simply an educated estimate. Mathematically, h(n) represents the estimated cost from the current state to the goal. One important rule always holds: h(goal) = 0 Once we've reached the goal, there's no remaining cost. Example: Finding Bucharest

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

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

Internmaxxing Somebody on your timeline this week called intern code "API slop."...

How to Access 50+ Chinese AI Models Through One API The Chinese AI ecosystem exploded in 2025-2026. DeepSeek dropped training costs by an order of magnitude. Qwen 3 ships 19 variants from 0.6B to 235B parameters. GLM-5 competes head-to-head with GPT-5 at 3% of the price. There's Kylin, Yi-Lightning, Hunyuan-T1, MiniMax-M1, Step-2-16K, and 40+ more models from a dozen labs. The models are incredible. The fragmentation is not. Every lab has its own API. Different auth headers. Different response formats. Different streaming protocols. Different error codes. If you wanted to try 5 models from 5 Chinese labs last year, you'd need 5 SDKs and 5 billing dashboards. Nobody has time for that. This is exactly the problem AIWave was built to solve. One API Key. 50+ Models. Zero Code Changes. AIWave is a unified API gateway that aggregates 50+ Chinese AI models behind a single endpoint. It speaks the OpenAI API format, which means every existing tool, SDK, and codebase in your stack works without modification. Here's what that looks like in practice: from openai import OpenAI # Point to AIWave instead of OpenAI client = OpenAI ( base_url = " https://api.aiwave.live/v1 " , api_key = " sk-your-aiwave-key " ) # Use DeepSeek V4 Pro response = client . chat . completions . create ( model = " deepseek-v4-pro " , messages = [{ " role " : " user " , " content " : " Explain MoE architecture " }] ) # Switch to GLM-5 — change one string response = client . chat . completions . create ( model = " glm-5 " , messages = [{ " role " : " user " , " content " : " Explain MoE architecture " }] ) # Try Qwen 3 235B — same thing response = client . chat . completions . create ( model = " qwen3-235b " , messages = [{ " role " : " user " , " content " : " Explain MoE architecture " }] ) That's it. Whatever you're already using — the OpenAI Python SDK, LangChain, LlamaIndex, Vercel AI SDK, a custom fetch wrapper — continues to work. You change the base URL and the model name, and suddenly you have acce

Every Solana program eventually hits the same question: where do I put my data, and how do I find it again later? Programs are stateless, so a program's data lives in separate accounts, each at an address. The moment you store something, you owe an answer to a problem databases tend to hide from you: what address does this live at, and how does the program find it again tomorrow? Program Derived Addresses are Solana's answer. The name scares people off, but the idea is mostly "an address you compute instead of remember, that only your program can control." The problem, in code Say each user gets a counter account. The normal way to make an account is to generate a fresh keypair and store data at its public key: import { Keypair } from " @solana/web3.js " ; const counter = Keypair . generate (); // counter.publicKey is something random, e.g. 7Hx4...9fT // create the account at that address, write count = 0 It works. But the address is random, so nothing connects this user to that address . Tomorrow, when the user comes back to increment, how does your program find their counter? You're forced to keep a lookup table somewhere: // the mapping you now have to store and never lose const counters = { " 9fYL...user1 " : " 7Hx4...9fT " , " B2k9...user2 " : " Qz1p...4dR " , // ...times ten thousand users }; Lose that table, lose the data, even though the accounts are right there on chain. You're storing files in a warehouse and writing the shelf number on a sticky note. The fix: compute the address from what you already know What if the address were a function of the user instead of random? Give a function the word "counter" and the user's public key, and it hands back a fixed address. Same inputs, same address, every time. No table. That's a PDA. PDAs are 32-byte addresses derived deterministically from a program ID and a set of seeds. The seeds are the meaningful inputs you pick (here, "counter" + the user's key). With @solana/web3.js , the library Anchor's client uses: im

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

Efficient C++ Programming for Modern 64-bit CPUs, Chapter 4/part 2 Here comes the 2nd installment of (VERY DRAFT) Chapters from my (and Dmytro Ivanchykhin's) upcoming book, "Efficient C++ Programming for Modern 64-bit CPUs" . Comments are extremely welcome (as before, we're committed to fixing all the issues highlighted in comments). Second part of Chapter 4 (the one on CPU Physics and CPU Cycles): https://6it.dev/blog/infographics-operation-costs-in-cpu-clock-cycles-take-2-80736 . In addition to some interesting data (in particular, micro-research on the progress of MUL/DIV ops since 2017), it has that visualization of the different times quite a few ppl here have asked for. DISCLAIMERS: - it is VERY DRAFT (editing is coming) - this is not a book on optimizations (though some techniques will be covered in Appendices A and B in Vol. 2) - this is a book on de-pessimizations; for optimizations - please refer to the excellent book by Denis Bakhvalov (though we're sure that de-pessimizations should be seen as a prerequisite for optimizations 😉). submitted by /u/no-bugs [link] [留言]

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. I boot up my machine. The desktop loads. And before I open my editor, before I check Slack, before I do a single productive thing, I right-click an empty patch of desktop and hit Refresh . Then I do it again. And again. I am a person who can explain event loops and reason about cache invalidation, and yet here I am, mashing F5 on a static wallpaper like it owes me money. If you've never done this, congratulations, you're better than me. If you have ... welcome. You're among friends. First, let's kill the myth There's a folk belief that refreshing the desktop is a tiny act of system maintenance. A little spring cleaning. A gift to your hardworking CPU. It is not. Manually refreshing your desktop does not : free up RAM reduce CPU load clear some mysterious cache make your PC faster in any way, shape, or form All it does is tell Windows Explorer to redraw the current view . That's it. That's the whole feature. What's actually happening under the hood Here's the part that's actually interesting (we're devs, we live for the "actually"). Windows doesn't repaint your entire screen on every frame, that would be wildly wasteful. Instead it leans on a composition engine that, with help from your GPU when one's available, only redraws the regions that changed since the last frame. Already drawn elements get cached and reused. Icons, the taskbar, your wallpaper they're all mostly static, so mostly left alone. When something genuinely changes (you save a file, delete a folder, plug in a drive), the OS detects it and tells the composition engine: "hey, this little rectangle changed, repaint just that." The desktop refreshes itself, automatically, all day long, without you ever touching anything. So the manual Refresh button is really just a manual overrid

"Email verification" sounds like one thing, but it's really a stack of checks of increasing depth and cost. Knowing what each layer actually proves helps you pick the right level instead of overpaying for verification you don't need. Layer 1: syntax The cheapest check: does the string look like a valid email address? A pragmatic regex catches obvious garbage ( asdf , a@@b , trailing spaces). It's instant and free, but weak on its own: nobody@asdf.asdf passes syntax and can't receive a single message. Layer 2: domain and MX records Next, does the domain actually accept mail? Every domain that receives email publishes MX (mail exchanger) records in DNS pointing to its mail servers. A quick DNS lookup tells you whether any exist. No MX (and no fallback A record) means the domain can't receive mail, so the address is undeliverable no matter how it's spelled. This single step removes a large class of fakes and dead domains. Layer 3: SMTP mailbox check The deepest level connects to the domain's mail server and begins the motions of sending a message to ask whether that specific mailbox exists, without actually delivering anything. It's the only layer that can hint a particular inbox is real, but it comes with real caveats: It's slow (a live connection per address). Many servers are "accept-all" and say yes to everything, so the answer is often meaningless. Lots of providers block or throttle these probes, and outbound port 25 is blocked on most modern hosting, so it's frequently unavailable anyway. SMTP checks matter most for cleaning old, cold lists, and far less for stopping junk at signup. The heuristics layer Alongside those, useful verification adds signal that has nothing to do with deliverability per se: Disposable detection: is it a throwaway provider? Role detection: is it info@ or admin@ rather than a person? Typo suggestions: "did you mean gmail.com?" for gmial.com . A deliverability score: one 0–100 number that rolls it all up so you can just threshold on it.

How I Cut My Multimodal AI Costs by 97% — A Freelancer's Guide Last month I almost killed a side gig because of a single line item on an invoice. A client wanted me to build a document-processing tool that could read scanned PDFs, pull text out of photos, and answer questions about charts. Easy enough — except I'd quoted the job assuming I'd use GPT-4o for the vision work. When I actually ran the numbers, I realized the API bill would eat my entire margin. I'd be working for free. Maybe worse. So I did what every freelancer does when the big-name vendor gets too expensive: I went hunting. And I landed on Global API, which routes to a bunch of multimodal models I've honestly never heard clients talk about. After a few weeks of testing, I figured out which ones are worth my billable hours and which ones aren't. This is everything I learned, plus the exact code I'm shipping to clients. Why Multimodal Even Matters for Solo Devs Two years ago, "multimodal" was a buzzword you'd hear at conferences. In 2026 it's table stakes. I've personally used vision models to: OCR receipts for an expense-tracking app (boring but pays the rent) Convert screenshots of legacy code into editable source for a Y2K-era company migration Read bar charts from PDF reports for a finance client who hates spreadsheets Analyze medical imaging samples for a startup MVP (this one was scary) Every one of those jobs started as a quick conversation with a prospect and turned into real invoices because I could say yes. The bottleneck was never capability — it was always cost. When GPT-4o charges north of $10/M output tokens, a single 2,000-token response on a tricky chart costs me about two cents. Multiply by 10,000 images per month and you've got a $200 API line item before you've paid yourself. That's a problem when the whole job is worth $400. So I tested every multimodal model I could find on Global API. Here's the lineup I ended up evaluating. The Contenders Nine models, three providers, one freelanc