标签：#r

When building Cypress automation that interacts with AWS services, the first step is verifying that your test framework can successfully authenticate and communicate with your AWS account. In this article, you'll learn how to connect Cypress to AWS and perform a simple authentication test using AWS Security Token Service (STS) and the GetCallerIdentity API. This approach helps confirm that: AWS credentials are correctly configured. Cypress can invoke AWS SDK operations through Node.js tasks. The automation environment is connected to the expected AWS account. Establishing this connection first provides a solid foundation before automating interactions with services such as AWS Lambda, Amazon S3, Amazon DynamoDB, Amazon SNS, or Amazon SQS. Prerequisites Before getting started, ensure you have: Node.js installed A Cypress project Valid AWS credentials: AWS Access Key ID AWS Secret Access Key AWS Session Token (if using temporary credentials) AWS Region Note:If you're running Cypress in an AWS environment (such as AWS CodeBuild, an EC2 instance with an IAM role, or GitHub Actions using OpenID Connect), you may not need to provide credentials manually. The AWS SDK can automatically retrieve credentials from the execution environment. Step 1: Install the AWS SDK Install the AWS STS client package: npm install @aws-sdk/client-sts For this connectivity test, we only need the AWS Security Token Service (STS) client. The package provides: STSClient – Creates a client for communicating with AWS STS. GetCallerIdentityCommand – Returns details about the authenticated AWS identity associated with the configured credentials. Step 2: Configure AWS Credentials For local development, create or update your cypress.env.json file. { "AWS_ACCESS_KEY_ID" : "" , "AWS_SECRET_ACCESS_KEY" : "" , "AWS_SESSION_TOKEN" : "" , "AWS_REGION" : "" } Populate the file with your AWS credentials. Example: { "AWS_ACCESS_KEY_ID" : "your-access-key" , "AWS_SECRET_ACCESS_KEY" : "your-secret-key" , "AWS_SES

Well-structured status lines in vim and shell prompts with version control symbols are a nice quality-of-life improvement. Unfortunately, not all monospace fonts come with the necessary PowerLine glyphs. For example, my favourite font is Operator Mono , and it too doesn’t have PowerLine symbols built in. Thanks to the NerdFonts font patcher , I was able to generate a font variant that has the necessary symbols. I simply ran the tool as a Docker container in my fonts directory: $ mkdir HCo_OperatorMonoSSmNF $ docker run --rm -v $PWD /HCo_OperatorMonoSSm/OpenType:/in \ -v $PWD /HCo_OperatorMonoSSmNF:/out \ nerdfonts/patcher --windows --powerline --powerlineextra Now my spaceship shell prompt sparks even more joy.

Part: 4 of 18 About this series This series documents the engineering evolution of a production-ready algorithmic trading platform in Python. It focuses on architecture, state management, execution, real-time data processing, persistence, and the engineering decisions that transformed a simple trading bot into a production-ready platform. In Part 3: Building a Production-Ready Position Manager for Algorithmic Trading , I described the component responsible for maintaining persistent position state throughout the entire trade lifecycle. Read Part 3 here: https://dev.to/pydevtop/building-a-production-ready-position-manager-for-algorithmic-trading-55n4 The Position Manager could remember every open position. The next challenge was deciding what should happen to those positions as market conditions continuously changed. Project Website This article is part of the engineering story behind the Bybit Signal Trading Platform . If you'd like to learn more about the project, see additional screenshots, features and technical details, visit: https://py-dev.top/application-software/bybit-signal-trading-bot The Problem Was Never Stop Loss If someone had asked me during the first weeks of development where the Stop Loss logic should live, I wouldn't have hesitated. Inside the Trade Execution Engine. Where else? The engine already received TradingView webhooks. It validated incoming requests. It calculated Take Profit. It opened positions. Adding one more calculation felt completely natural. The implementation looked something like this. signal = receive_signal () validate ( signal ) entry = execute_order ( signal ) stop_loss = calculate_stop_loss ( entry ) take_profit = calculate_take_profit ( entry ) Simple. Readable. Everything related to opening a trade existed in one place. At that moment there was absolutely no reason to introduce another component. There was only one trading pair. Only one open position. No persistence. No restart recovery. No Break Even. No Trailing Stop.

I run a pipeline that generates explainer articles. LLM in the middle, structured output, published in several languages. It had been running for a while and the articles looked good: clean layout, a chart, and near the top of each one a confident little box with a statistic. Something in the shape of "68% of people never change the default." A number, a source, an authoritative ring to it. Not one of those numbers had been researched. The pipeline had never looked up a single statistic in its life. It asked the model for a number and printed whatever came back. I did not find this through a clever eval. I found it while cleaning up something unrelated and actually reading the prompt. The field that forced a lie The output schema had a required field. statistic.text and statistic.source , described in the prompt as an "eye-catching stat" for the top of the article. Required. Every article had to have one. The prompt also, helpfully, told the model what to do when it did not have a real number. It said to round to a safe order of magnitude. And it said to strip the year off the source, so the article would look evergreen instead of dated. Read that back slowly. The instructions were: always produce a statistic, make up a plausible magnitude if you have to, and remove the one piece of metadata that would let anyone check it. That is not a prompt that occasionally allows a hallucination. That is a prompt that requires one, every single time the model does not happen to know a real figure. So it produced them, confidently, in every language, each wearing a real-sounding source: a named institute, an industry association, a government statistics office. None of it had been looked up when it was written. This was content people actually act on, which is exactly the category where being wrong is not a rounding error. There was a second engine doing the same thing in the chart code. The block that generated the data visualization asked the model for "actual statistics from

How I went from toggling a single GPIO pin to deploying intelligent, low-power firmware on the edge — and the lessons that shaped me along the way. The first program I ever ran on a microcontroller did exactly one thing: it blinked an LED. No operating system. No framework. No safety net. Just my code, a register, and a clock ticking a few million times a second. When that LED finally blinked at the rate I intended — not too fast, not stuck on — I felt something I hadn't felt writing software before. On a bare-metal system, nothing happens unless you make it happen. There's no runtime quietly cleaning up after you. That mix of total control and total responsibility is what pulled me into embedded systems, and it's the same thread that eventually led me to running machine learning models on the edge. This is the story of that journey — from a single blinking pin to intelligent devices that sense, decide, and act on their own. The Bare-Metal Beginning Bare-metal firmware is where you learn what a computer actually is. When you write to a memory-mapped register to toggle a GPIO, or configure a UART peripheral one bit at a time, there's no abstraction hiding the hardware from you. You read the datasheet. You read the reference manual. You get the clock configuration wrong, and nothing works — no error message, just silence. Then you fix it, and suddenly bytes are streaming out of a pin at exactly the baud rate you configured. Most of my early growth happened writing low-level peripheral drivers — UART, SPI, I2C, GPIO, ADC — on ARM Cortex-M platforms. These are the unglamorous building blocks, but they teach you the discipline embedded work demands: Every byte and every milliwatt matters. On a resource-constrained MCU, you don't get to be careless with memory or power. Timing is a first-class citizen. An interrupt that fires 50 microseconds late can break the whole system. The hardware is always right. If your code and the oscilloscope disagree, the oscilloscope wins. Th

I sat the Claude Certified Architect exam expecting questions about model parameters, context limits, and API flags. I got something else. The exam barely tests trivia. It tests judgment: given a broken agent and four plausible fixes, which one actually addresses the root cause? The interesting part was how few ideas the whole thing rests on. The same handful of rules kept deciding the "right" answer, and they are the same rules that decide whether an agent holds up once real users touch it. Below are the twelve I kept running into, plus the four traps that look like solutions and are not. This is my own study material, derived from publicly available exam guidance. It reflects how I build, not an official Anthropic position. The twelve rules Enforce determinism in code, not in prompts If a rule has to fire every single time, it is not a job for a prompt. A prompt is a suggestion the model usually follows. "Usually" is not a guarantee. When you need a guarantee, put it in a hook, a gate, or an allowlist. Code enforces. Prose requests. Pick the cheapest fix that hits the root cause Before you build a subsystem, try the levers that cost minutes: a sharper tool description, an explicit acceptance criterion, a config change. Most "we need to build X" moments dissolve once you test the cheap fix first. Reach for the classifier only after the one-line change fails. Bad tool selection? Start with the descriptions When an agent keeps picking the wrong tool, the description is almost always the culprit, not the model. Tool descriptions are the primary signal the model uses to choose. Rewrite them to say exactly when to use the tool and when not to, before you go anywhere near few-shot examples. Over-engineering is almost always the wrong answer Narrowing scope and improving the prompt beat a new subsystem far more often than engineers expect. Every subsystem you add is one more thing to debug, monitor, and keep in sync. Complexity is a cost you pay forever, not once. A bigge

Xreal's XBX a01+ is the best pair of budget AR glasses we've seen yet.

A practical introduction to WebGPU, WGSL, render pipelines, compute shaders, and the future of high-performance graphics on the web. Your browser can stream 4K video, run a complete code editor, render complex 3D scenes, and host multiplayer games. But for years, web developers accessed the GPU through an API based on an older generation of graphics programming. WebGPU changes that contract. WebGPU is not simply a faster version of WebGL. It is a new approach to graphics and parallel computation on the web—one built around explicit pipelines, modern GPU architecture, compute shaders, predictable resource management, and a shader language designed specifically for the browser. This article expands on the progression presented in the uploaded High Performance Graphics: Introduction to WebGPU material: why WebGPU matters, how it differs from WebGL, how WGSL works, how the rendering pipeline is constructed, and how compute shaders extend the GPU beyond graphics. WebGPU is not WebGL 3.0 This is the first mental model to correct. WebGPU does not build on WebGL. WebGL exposes a browser-friendly version of the OpenGL ES programming model. WebGPU instead uses concepts associated with modern GPU APIs and provides a portable abstraction over the graphics capabilities available on the user’s system. WebGPU and WGSL are W3C standards for accessing GPU acceleration from web applications. The API supports both graphics rendering and general-purpose parallel computation. ( W3C ) WebGL │ └── OpenGL ES-style state machine WebGPU │ ├── Explicit pipelines ├── Explicit resource bindings ├── Command encoding ├── Compute shaders └── Modern GPU execution model The difference is architectural, not cosmetic. In WebGL, you frequently change global rendering state and then issue a draw call. In WebGPU, you describe the pipeline and resources more explicitly, record commands, and submit those commands to the GPU. WebGL mental model Change state ↓ Change more state ↓ Bind resources ↓ Draw WebGPU

We consulted preparedness experts and WIRED’s team of testers for the essential gear to keep on hand in case of wildfires, earthquakes, and lord knows what else.

A new technical analysis published by the Cloud Native Computing Foundation (CNCF) argues that the future of agentic AI will be built not on entirely new infrastructure, but on the mature cloud-native ecosystem that already powers modern distributed applications By Craig Risi

New report says our ability to tie weather damages to climate change is improving.

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

FCC chair has been gifted at least $63,000 worth of tickets by CBS or its parent company.

Really interesting piece of cryptographic history : In November 2023, a large cache of his wartime papers—nicknamed the “Bayley papers”—was auctioned in London for almost half a million U.S. dollars. The previously unknown cache contains many sheets in Turing’s own handwriting, telling of his top-secret “Delilah” engineering project from 1943 to 1945. Delilah was Turing’s portable voice-encryption system, named after the biblical deceiver of men. There is also material written by Bayley, often in the form of notes he took while Turing was speaking. It is thanks to Bayley that the papers survived: He kept them until he died in 2020, 66 years after Turing passed away...

Quick, comfortable, roomy, and agile for a large electric SUV.