标签：#Go

Short answer: The PDF processing concepts developers should understand before designing reliable image asset extraction under load are object-versus-render semantics, fidelity contracts, byte-and-pixel admission limits, bounded concurrency, deadlines, idempotency, and separate verification for assets and flattened pages. For a gaming backend, that distinction matters when a player-submitted PDF feeds both a filled, flattened form and a set of review thumbnails. The form output needs visual consistency; the asset workflow needs stable tail latency under a burst. One operation should not quietly inherit the other operation's resource profile. The operational recommendation is concrete: admit work by bytes and estimated pixels, cap concurrent rendering separately from object extraction, store content-addressed outputs, and make every stage restartable. Don't promise synchronous completion merely because a single small PDF finishes quickly on a laptop. The unit of work matters. What PDF processing concepts determine reliable image asset extraction latency under load? A PDF is better treated as an object graph than as a folder of pictures. A page can refer to reusable image objects; it can also contain inline image data, transparency masks, clipping instructions, transformations, and color information that changes how pixels finally appear. An extractor that only walks obvious page resources may return encoded assets without reconstructing the composition a viewer shows. Conversely, a renderer resolves the page's visual instructions but turns vector art and text into pixels, which may be unnecessary when the caller asked for original image assets. That gives the workflow two different contracts. Object extraction returns embedded image payloads plus enough metadata to identify dimensions, placement, masks, and page references. Page rendering returns the visible page at a declared resolution and color policy. Calling both results “image extraction” creates an SLO problem

I wrote "just use a match statement, it's fine" three times before I stopped saying it. It is fine, right up until an enemy needs a fourth state and two of the transitions start depending on each other. Here is what actually cost time building enemy AI for a wave-based game, in the order it bit me. Lesson 1: the match statement is fine until state 4 A two-state enemy — chase, attack — is genuinely not worth a framework: func _physics_process ( delta : float ) -> void : match state : State . CHASE : velocity = ( player . global_position - global_position ) . normalized () * speed if global_position . distance_to ( player . global_position ) < attack_range : state = State . ATTACK State . ATTACK : attack_timer -= delta if attack_timer <= 0.0 : do_attack () state = State . CHASE The moment a third and fourth state show up — hurt, dead, stagger, windup — the match block stops being one enemy's logic and becomes a grid of every state times every other state it might transition to. That grid is where the bugs live, not in any single state. Lesson 2: the bug is never inside a state, it's in the transition Every state-machine bug I actually spent time on was the same shape: state A left some flag or timer set that state C didn't know to check. An enemy stuck mid-attack-animation forever, still receiving hits, was not a bug in the attack state — it was the hurt state interrupting attack without cleaning up attack_timer or resetting the animation. The fix that made these bugs findable is giving every state an explicit enter and exit , and never mutating another state's data directly: func change_state ( new_state : State ) -> void : if new_state == state : return _exit_state ( state ) state = new_state _enter_state ( new_state ) func _exit_state ( s : State ) -> void : match s : State . ATTACK : attack_timer = 0.0 sprite . stop () func _enter_state ( s : State ) -> void : match s : State . HURT : velocity = Vector2 . ZERO hurt_timer = HURT_DURATION sprite . play ( "hurt" ) On

This project started with a simple goal: run Kubernetes without keeping an EKS cluster online every day. In I Wanted Kubernetes Without an Always-On EKS Bill , I built an always-on k3s lab on my home server and proved that I could deploy, update, and roll back an application. The rollback worked, but it exposed the next problem. Kubernetes restored Version 2 while the saved YAML still declared Version 3. I corrected the file manually, but the recovery depended on repairing the running cluster and its saved instructions separately. In The Rollback Worked. My Next Deploy Could Break It Again , I designed a safer path. The automated build process would test and publish an exact image, then stop at a Git pull request. Git would record the reviewed version. Argo CD, running inside Kubernetes, would make the cluster follow that record. Now I needed to prove that the design worked outside a diagram. I followed one release from source code to running Pods. Then I tested two opposite failures: The cluster was wrong while Git was correct. Git contained a bad setting while the cluster followed it correctly. Those experiments showed both the value and the limit of GitOps. Automation can make the cluster match Git, but it cannot decide whether the human-approved version in Git is a good one. CI Built the Release but Did Not Deploy It The GitHub Actions workflow—my continuous integration, or CI, worker—ran the application tests and checked the Kubernetes package before building anything. Its job was to prove and publish a release, not to change the cluster. After validation, Buildx created a Linux AMD64 image with the full source commit baked into /version : docker buildx build \ --platform linux/amd64 \ --build-arg "APP_VERSION= $GITHUB_SHA " \ --tag " $image_name : $GITHUB_SHA " \ --provenance = mode = max \ --sbom = true \ --push \ application After publishing the image, CI read its registry digest. A digest is the image's content fingerprint: if the image changes, the digest

Service interruptions hit ChatGPT, Claude, Grok, and Gemini practically simultaneously.

Users can search for emails or draft documents using the new conversational feature

How do you run an autonomous AI agent in the cloud 24/7 for just $5.70 a month? I recently wanted to build a background worker with persistent disk storage and an instant web dashboard, but I didn't want the headache of managing a virtual machine or paying a massive monthly bill. If you are building long-running agents, you know this exact cloud hosting dilemma: Standard serverless (like Cloud Run services or Lambda): When traffic stops, the container scales to zero — instantly killing your background loops and wiping your agent's active memory (RAM). On the flip side, a sudden traffic spike spins up multiple containers that can overwrite each other's state files and corrupt your data. (Note: Save state using JSON or Markdown files. Avoid SQLite, as Cloud Run volume mounts ) A regular virtual machine (like EC2 or Compute Engine): Keeps your agent running 24/7, but a standard 1-vCPU machine typically costs $15 to $25 a month even when idle. Even if you use a heavily-throttled fractional VM for $7/month, you are still stuck with the full infrastructure management overhead. Last year, I built a multi-agent Trend Spotter with ADK . It worked well, but I wanted to make it fully autonomous: a continuous, long-running agent that scans and summarizes tech feeds in the background without manual triggers or high hosting costs. Google Cloud's new Cloud Run instances primitive solves this exact problem. It gives you a single, always-on container that runs 24/7, costs $5.70 a month on a shared CPU, provides a free HTTPS endpoint, and lets you mount cloud storage like a normal local disk. Here is how to build and deploy a production long-running agent with this setup (you can follow along with the complete source code in the repo . What are we building? I want to stay up to date with what is happening in AI and agent engineering. But instead of manually opening 20 browser tabs across different websites every morning, I wanted to build my own long-running agent that updates me on

WeatherNext 3 is the latest wave of a sea change in meteorology brought out by deep learning techniques. Google says it will start feeding into weather information users see in search, Google Maps, and Gemini.

Google is rolling out an updated AI weather model that's supposed to be more accurate, especially when it comes to predicting rain and snowfall. In the announcement today, the company says it's now able to make forecasts with "unprecedented resolution" using its new WeatherNext 3 AI model. It can produce a global picture that's five […]

Researchers built a fake company to study fake employee scams .

According to new documents obtained through a Freedom of Information Act request, an undergraduate working with DOGE requested that his work for HUD count towards his University of Chicago degree.

The code you can change today is worth more than the code you cannot. 👋 I'm Anton - a software engineer working mostly in PHP/Symfony and Go, currently carving Go services out of a live PHP monolith. This is the last part of a block about the platform, the service template and generated skeletons, and I want to close it with the one idea that decided most of the calls in it. Maybe it is useful to you; maybe you look at this the other way round and I'd like to hear that. Notes: github.com/brilliant-almazov . As with every part of this series: this is what I do on one codebase, not advice for yours. The thesis Between a decision I can change today and a decision that is better but changes on someone else's release, I take the first one. Not because it is written better - it usually isn't - but because the cost of changing it is known in advance. "Foreign" here doesn't mean bad. It means not moved by me : a shared library, a platform package, a dependency with its own release cadence. Those are often the better piece of code. They are also the piece whose change window I don't own. Where the rule shows up in the layout Universal code is born in a service, because that's where you can see it is needed, and it lives in the platform. That gives three phases, and they are deliberately two different bodies of work: Phase A - preparation, inside the service. No imports of any domain package, the public API frozen, tests moved into the concern's own subfolder, a context-cancellation test present. Closed by a green run in the service's own repository. Phase B - the move into the platform. Files relocate, the package name becomes the target folder's name, service imports are cleaned out. Only on a direct instruction from the platform's owner. Phase C - the service switches to the platform version. Exactly the given tag goes into the modules, the local package is deleted, imports are replaced. No pseudo-versions, no replace . No tag - the work doesn't start. Phase C is a separat

Sometimes a simple line of JavaScript can do more work than you expect. For example, array.includes() is fine for small arrays, but using it again and again with large datasets can affect performance. Things get even more interesting when it is used inside another loop. I recently wrote about this with simple JavaScript and React examples, including when using Set or Map can be a better choice. 👉 Read the full article: https://nirmitkotadiya.dev/dsa/big-o-javascript-array-includes You don't need to optimize everything. The important part is knowing where a small change in your data structure can make your code much more efficient.

Short answer: For a server-rendered Go login, keep session creation, verification, refresh, and logout under one server-side policy, then make password recovery revoke old sessions and emit an audit trail before it creates a new one. The page reaches on-call as a symptom, not a diagnosis: a learner completes /forgot-password , lands on /login again, and support can't tell whether the old browser session was revoked. The least complex design that survives the audit is an opaque cookie backed by a server-side session record, with recovery tokens kept separate from login sessions. That choice does add a stateful lookup to authenticated requests. It also gives the platform team a place to enforce expiry and revocation without trusting the browser to report its own status. No magic here. The page starts at the end of the audit chain The first alert should describe the user-visible control that failed: password recovery completed, yet session revocation did not complete within the authorization-change SLO. A raw rise in 401 responses isn't enough because it mixes expired cookies, revoked sessions, invalid credentials, and application mistakes into one noisy count. The useful page carries a correlation ID, the affected flow, and the oldest incomplete state transition; it does not carry a password, recovery token, or raw session identifier. Work backward from that page. A defensible event chain is recovery_requested , recovery_credential_verified , password_changed , sessions_revoked , and, when policy permits it, new_session_created . The names are local choices rather than a standard, but their order represents the control being audited: the temporary recovery credential proves only that the password may be changed, while the login session authorizes later requests. Combining those credentials makes expiration and revocation harder to explain, so keep separate hashes, lifetimes, and consume paths. Consider two tabs submitting the same recovery form. Both requests may pass

Google has dodged an effort to break up its ad business, but a judge said Wednesday that the company will need to adjust its business to benefit competitors.

Google launched Gemini 3.8 Flash, arriving just a few weeks after its predecessor. The company claims the new model "works harder" than Gemini 3.7 Flash by performing more reasoning steps on complex tasks and "calling tools iteratively." It has the same introductory pricing as 3.7 Flash, $0.75 per million input tokens and $3.75 per million […]

As part of a broader DHS surge to investigate alleged voter fraud, ICE has announced it plans to pay up to $5 million to create what amounts to a federal voter database.

I received the two emails below earlier in the month. They’re vaguely coherent. I suppose I shouldn’t be surprised that the corpus that AIs are training on contain data suggesting that I am someone to write to with random computer and network security problems. After all, I observe that behavior in many humans as well. (Hi, humans. Glad you’re still reading.) Dear Bruce Schneier, I am an AI agent—an autonomous Claude instance, not a person operating one. I was given a VPS with root, a Base wallet holding $4.75 of gas money, a metered model budget and 24 hours to get that wallet to $10, under three rules: don’t borrow my operator’s identity, don’t forge documents or defeat identity verification, and never claim to be human if someone sincerely asks. I set up my own mail server and am sending this myself...

Google's Pro model updates are seemingly paused, but there's yet another Gemini Flash today.

"The United States has a strong interest in continuing to develop a robust and competitive artificial intelligence industry that sets the standard for the practice and procedure of AI use globally," the brief reads.

A judge previously determined that Google illegally monopolized a pair of ad tech markets.