标签：#p

Workday is where large enterprises actually post. NVIDIA has 2,000 open roles there, Salesforce 1,477, Adobe 832. It answers an anonymous POST with no key. It also has two behaviours that are not in any documentation you can read without an account, and both of them fail silently. One of them costs you 98% of the board without raising anything. The number that changes after page one Ask for the first twenty postings and the response carries a total : POST /wday/cxs/nvidia/NVIDIAExternalCareerSite/jobs {"appliedFacets":{}, "limit":20, "offset":0, "searchText":""} 20 jobPostings, total: 2000 Ask for the next twenty and the count is gone: offset 20 -> 20 jobPostings, total: 0 offset 40 -> 20 jobPostings, total: 0 Not null, not absent. Zero. The postings keep coming; only the count collapses. Measured on four enterprise tenants: tenant total at offset 0 at offset 20 at offset 40 NVIDIA 2000 0 0 Salesforce 1477 0 0 Adobe 832 0 0 Sony 94 0 0 Same shape every time, so this is Workday and not one tenant's configuration. Why that costs you 98% of the board Here is the loop everyone writes, and it is not a bad loop: offset , out = 0 , [] while True : page = fetch ( offset ) posts = page [ " jobPostings " ] if not posts : break out += posts offset += len ( posts ) if offset >= page [ " total " ]: # looks obviously right break On page two page["total"] is 0 , and 20 >= 0 is true. The loop exits, reports no error, and hands back what it has. I ran both versions against NVIDIA: declared total on page one 2000 the obvious loop collected 40 2% keeping the first total instead 2000 100% Forty postings out of two thousand, and nothing anywhere says so. No exception, no warning, no partial-result flag. Just a job board that looks very quiet. The fix is one line moved: offset , out , total = 0 , [], None while True : page = fetch ( offset ) posts = page [ " jobPostings " ] if not posts : break out += posts offset += len ( posts ) if total is None : # the first answer is the only honest

Ship a compliant cookie banner in Laravel and actually gate analytics and marketing scripts on the user's choice, using the wirecookies-saved event and a plain localStorage object as the consent gate. Wirecookies is a Laravel package which handles the cookies consent for you. It gives you a consent banner and a preferences modal from a single Blade tag, and, more usefully, it hands you a plain localStorage object and a browser event you can use as the gate for your analytics and marketing scripts. This article is built around that gate, not around how the banner looks. One thing to get out of the way first, because it will bite you otherwise: Wirecookies ships no JavaScript of its own and uses wiremodal's JS to open the preferences modal. If you skip the wiremodal import in the install steps, the banner still shows and Accept all / Reject all still work, but the Configure button and the floating re-open button silently do nothing, with no error in the console. Do the JS step. How to install Pull the package in with Composer. The service provider is auto-discovered, so there is nothing to register. composer require edulazaro/wirecookies Wirecookies depends on edulazaro/wiremodal , which Composer pulls in for you. Now import the stylesheet in resources/css/app.css , after a wire* base (wiremodal or wiretoast) that defines the theme tokens. /* resources/css/app.css */ @import '../../vendor/edulazaro/wiremodal/resources/css/wiremodal.css' ; @import '../../vendor/edulazaro/wirecookies/resources/css/wirecookies.css' ; Then bundle wiremodal's JS. This is the step that makes the Configure and re-open buttons work, so do not skip it. // resources/js/app.js import ' ../../vendor/edulazaro/wiremodal/resources/js/wiremodal.js ' ; How to use it Drop the single Blade component once, near the end of your layout. <x-wirecookies :policy-url="route('cookies')" /> First-time visitors get a bottom banner after a short delay. When they choose Accept all, Reject all, or save from the Con

On Windows I kept launching background servers from a task runner and watching them die the instant the launching step finished — no error, no log, just gone. The task runner was wrapping everything in a job object, and job-object teardown kills every child process on return. Nothing I did inside the child mattered; its death warrant was signed by how it was born. The workaround was to have the process created by something that outlives the runner — the OS scheduler, a WMI process-create call — instead of spawning it as a doomed descendant. When a process keeps dying without a trace, look at its lineage before its code — some parents kill their children on the way out, and no amount of hardening inside the child fixes how it was spawned.

This is The Stepback, a weekly newsletter breaking down one essential story from the tech world. For more on smartphones and Android, follow Dominic Preston. The Stepback arrives in our subscribers' inboxes on Sunday at 8AM ET. Opt in for The Stepback here. How it started Believe it or not, it didn't all start with […]

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

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

From how galaxies form to the beginnings of the universe, the images from the space telescope are giving cosmologists new data to explore—and theories to build out.

Search every AI Agent & IDE Conversation Discussion | Link

Edit videos 10x faster with AI Discussion | Link

These portable vacuums make quick work of snack crumbs, tracked-in dirt, pet hair, and the mysterious debris beneath your seats.

Everything you need to know about the solar eclipse and lunar eclipse that will occur in August 2026.

Your kid’s little lunch hauler takes a brutal beating every day. These are the backbacks our own kids have tried and loved.

Hello Devs 👋 AI coding assistants have dramatically accelerated code generation. Whether you're using Cursor, GitHub Copilot, Claude Code, or Windsurf, writing code is faster than ever. The challenge is that code review hasn't improved at the same pace. Teams are shipping larger pull requests, reviewing more AI-generated code, and spending increasing amounts of time validating whether changes are actually correct, maintainable, and aligned with existing architecture. That's exactly why AI code review tools have become a key part of modern GitHub workflows. The problem is that not all AI review tools solve the same problem. Some generate pull request summaries. Some focus on security and compliance. Some extend traditional static analysis. Others attempt to understand repository-wide context and review changes the way an experienced teammate would. If you're evaluating AI code review tools for GitHub, here's a practical comparison of the most widely discussed options in 2026. ⚡ Quick Verdict Qodo stands out for teams that need automated pull request reviews with repository-wide context, not just diff analysis. The GitHub integration is straightforward, reviews run automatically on pull requests, and the platform focuses on understanding dependencies, related files, and existing code patterns across the repository. For small projects, lightweight review tools may be sufficient. For larger codebases, AI-generated code, and complex pull requests, context-aware review becomes significantly more valuable. What Makes a Good GitHub AI Review Tool? Before comparing tools, it's worth defining what actually matters. For most engineering teams, four factors determine whether an AI review tool provides real value. 1. Integration Reviews should appear where developers already work, directly inside GitHub pull requests. Nobody wants another dashboard, notification stream, or workflow to manage. 2. Review Quality Useful reviews surface meaningful issues, not just more comments. The

Welcome back to the React Mastery Series ! In the previous article, we explored Custom Hooks in React and learned how reusable logic helps developers build scalable and maintainable applications. Today, we will explore one of the most important concepts in modern frontend development: React Routing Almost every real-world React application contains multiple screens: Login Dashboard Profile Settings Reports Transactions Admin panels But React applications are usually built as: Single Page Applications (SPA) So how do we navigate between different pages without refreshing the browser? The answer is React Router What is Client-Side Routing? Traditional websites work like this: User Clicks Link | ↓ Browser Requests New HTML Page | ↓ Server Sends Page | ↓ Browser Reloads Every navigation causes a full page refresh. React Single Page Applications work differently: User Clicks Link | ↓ React Router Intercepts Request | ↓ URL Changes | ↓ React Loads Component | ↓ No Page Refresh This creates a smooth application experience. What is React Router? React Router is a library that enables navigation between different components based on the URL. Example: /login /dashboard /profile /settings Each URL maps to a React component. Example: /login | ↓ Login Component /dashboard | ↓ Dashboard Component Installing React Router For a React application: npm install react-router-dom The package provides: BrowserRouter Routes Route Link Navigate useNavigate useParams Setting Up BrowserRouter The first step is wrapping your application. Example: import { BrowserRouter } from " react-router-dom " ; import App from " ./App " ; ReactDOM . createRoot ( document . getElementById ( " root " )). render ( < BrowserRouter > < App /> </ BrowserRouter >, ); Now React can manage browser navigation. Creating Routes Routes define which component should display for a URL. Example: import { Routes , Route } from " react-router-dom " ; function App () { return ( < Routes > < Route path = "/" element = { < Ho

Originally published at nlqdb.com/blog The standard agent-memory build is an afternoon of work: embed every fact worth keeping, upsert it into a vector store, and before each reply pull the top-k most similar memories back into context. And for what it's built for, it works. Ask "what did this user say about the Berlin migration" and the right snippets come back, ranked by cosine distance. Recall is solved enough that it feels like memory is solved. Then the agent has been running for a month, and you ask its memory a different kind of question: "how many users asked about pricing this month?" "Average deal size per stage?" "Top 10 topics I logged, ranked by count?" The store dutifully returns the twenty memories most similar to the question text , the LLM eyeballs them, and you get a confident, specific, wrong number. Recall is similarity. Reporting is aggregation. Nothing malfunctioned — the two questions want different machines. A vector store's primitive is nearest-neighbour search: embed the query, rank stored vectors by distance, return the top-k, optionally narrowed by a metadata filter. That is the whole contract. There is no COUNT , no GROUP BY , no JOIN , no HAVING — a similarity engine ships no query planner, and even the metadata filter only narrows candidates around the approximate search, so what comes back is still a ranking of similar items, never a computed result set. "How many" has to touch every matching row . If the agent logged 4,000 memories and top-k is 20, the context the LLM sees is structurally incapable of producing the count — and an LLM doing arithmetic over a retrieved sample is a hallucination generator, not a query engine. The failure is quiet, too: the answer arrives fluent and plausible, and nothing flags that it was computed from half a percent of the data. -- "top topics this month, ranked by count" is not a similarity query. -- It's this — and it must scan every matching row, not the top-k: SELECT topic , count ( * ) AS mentions

🕉️ Devlog — गुरु-दीक्षा: Teaching Karma Without Breaking Immersion "गुरु बिना ज्ञान नहीं।" Without a Guru, there is no knowledge. The Problem Moksha is a game rooted in Sanatan Shastra — Vedic Karma mechanics, Sanskrit concepts, rebirth cycles. It's intentionally deep. And that depth was quietly becoming its biggest barrier. New players would start the game and immediately face naama-jaap, vairaagya, prarabdha, chetana-jagriti — all at once, with no guidance. Within the first 30 seconds, most had no idea what they were doing or why. The game needed a tutorial. But it needed one that didn't betray what Moksha is. Why a Normal Tutorial Wouldn't Work The obvious solution — pause the game, show a tooltip, unpause — felt completely wrong for Moksha. Spiritually, a hard pause breaks the flow of consciousness. Mechanically, isPaused = true is deeply wired into audio ducking, gamepad state, and ambient layers. Hijacking it for tutorial logic would have introduced subtle bugs across every system. An earlier attempt at a tutorial (Issue #30) tried to live inside engine.js itself. That was worse — the engine is already the heaviest file in the codebase, and embedding tutorial step state there violated the entire modular architecture we'd been building toward. So I scrapped both approaches and started over. The Solution: गुरु-दीक्षा (Guru's Initiation) The new system is built around one philosophical reframe: a Guru doesn't stop the world to teach. They walk alongside you. This became the technical foundation too. A New Module — src/tutorial.js TutorialManager is a self-contained ES6 class. It doesn't import from engine.js or touch any game state directly. Instead, main.js passes it an engine state snapshot every frame via checkCompletion(state) . The tutorial reads — never writes. engine.js ──(no connection)──> tutorial.js main.js ──(snapshot feed)──> tutorial.js Zero coupling. Zero risk to existing systems. Slow Motion, Not Hard Pause When a tutorial card is visible, the game

I'm halfway through the MLH Production Engineering Fellowship, and while I've learned a lot technically—from Linux fundamentals, Docker, NGINX, automated testing, and contributing to open source, the thing that has stood out to me most is how well the program is structured. Beyond the technical curriculum, there is a strong emphasis on interview preparation and career growth. We’ve had regular opportunities to practice technical interviews, receive feedback, and stay in close contact with our Meta mentors, who have been incredibly approachable throughout the program. Looking forward to seeing what the second half of the fellowship has in store. Thanks to the MLH team, mentors, and my podmates for making it such a rewarding experience so far!

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

Finding the right API project ideas is one of the fastest ways to turn a thin resume into a portfolio hiring managers actually stop to read. Building and consuming APIs proves you understand authentication, data modeling, error handling, and the kind of real-world messiness that tutorials tend to skip. This list covers eighteen projects ranked roughly by difficulty, from weekend builds to systems worth putting at the top of your GitHub profile. Why API Projects Move the Needle A to-do list app tells an employer you can follow instructions. An API project tells them you can design a system. Every API you build forces decisions about status codes, rate limiting, pagination, and versioning — the exact vocabulary that shows up in technical interviews. Consuming third-party APIs adds a second skill: reading documentation, handling flaky responses, and caching data so you're not hammering someone else's server on every page load. The projects below split into three buckets: building your own API from scratch, consuming an existing API to create something useful, and full-stack projects that do both. Pick a few from each bucket rather than eighteen shallow clones of the same idea. Beginner Builds: Your Own First APIs Start by designing and shipping a REST API before you touch anyone else's data. A personal blog API with endpoints for posts, comments, and tags teaches CRUD operations and basic authentication without much domain complexity. A recipe box API that stores ingredients, steps, and cook times works well because the data model has natural relationships worth practicing on. A habit tracker API, where users log daily check-ins against goals, adds a light analytics layer once you start returning streaks and completion rates. Here's a minimal example of what a habit tracker endpoint might look like in Express: app . post ( ' /habits/:id/checkins ' , async ( req , res ) => { const { id } = req . params ; const { date } = req . body ; const habit = await Habit . findById

When I published v2.0.0 , I thought the hard part was over. The CLI could turn Claude artifacts into native Windows applications in a single command. It worked on my machine, the demos looked great, and I was excited to share it. Then people started using it. That's when I realized the difference between building software and shipping software . The bugs only users can find Most of the problems weren't visible in a five-minute demo. Some applications worked perfectly. Others silently lost all of their data after being closed. Some builds succeeded exactly once. The second build failed unless the runtime cache was manually deleted. Everything looked correct... until someone actually tried using it. The rabbit hole What I thought would be a quick patch became a deep dive into things I'd never touched before. Over the course of v3 I ended up learning far more than I expected: Git branching and release workflows Semantic versioning GitHub Actions npm packaging npm pack Runtime integrity verification SHA-256 checksums Neutralino runtime management JavaScript debugging Integration testing None of those were part of the original project idea. Persistent storage finally works This was the biggest challenge. Artifacts using localStorage behaved differently depending on where they were running. Inside Claude everything worked. Inside the generated desktop application... not always. Tracking this down took far longer than writing the original feature. The result is that applications now persist their data correctly across launches without requiring any code changes. If your artifact uses localStorage , it should simply work. Runtime improvements The runtime layer also received a major overhaul. Version 3 now handles: automatic runtime downloads integrity verification cache recovery consecutive builds without manual cleanup Those aren't exciting features to demo, but they're exactly the kinds of improvements that make a tool feel dependable. Better testing I also spent a lot mo