- You can opt out (Computer Configuration > Administrative Templates > Windows Components > Windows Copilot > Enable the "Turn off Windows Copilot" policy)
- You won't get it if you're in the EU
- You'll only get it if you have an M365 app installed (not all windows users)
Hi. I am sorry about this issue. Can you email [email protected], and it will get resolved? I am also working on more systematic fixes for when customers get into this situation.
This is one of the reasons I am working on an enclosure-compatible open-source version of the 2nd gen Nest thermostat. It reuses the enclosure, encoder ring, display, and mounts of the Nest but replaces the "thinking" part with an open-source PCB that can interact with Home Assistant.
Nest has been pretty-badly supported in Home Assistant for over a year anyway, missing important connected features.
I've got the faceplate PCB done and working; the rotary encoder and ring working; and the display working but with terrible code with a low refresh rate.
I need to ship at the end of October to beat the retirement date. Plans to get some regular development report-outs and pre-orders are coming quite soon.
It's open source, and uses ESP32-C6 so it can be Wifi, BLE, or Zigbee, whatever software you intend to load onto it.
with movieIds as (select id from Movie where title = $1),
actorIds as (select Actor.id from Actor join ActorMovie on [...]
where ActorMovie.Movie in movieId),
alsoActedIn as (select id from ActorMovie where actor in actorId),
movieResults as (select * from Movie where id in movieIds),
actorResults as (select * from Actor where id in actorIds),
alsoActedInResults as (select * from Movie join ActorMovie on [...]
where ActorMovie.id in alsoActedIn)
select * from movieResults
full outer join actorResults on false
full outer join alsoActedInResults on false;
Not every database supports "full outer join on false," and sometimes you have to add "as not materialized" to the "with" subqueries in order for it to be performant, but it works in Postgres, and you end up with a results table that looks something like this:
# ASCII RPG
This repo uses Rust + Bevy (0.16.1), multi-crate workspace, RON assets, and a custom ASCII UI. The rules below keep contributions consistent, testable, and verifiable.
## Quick rules (read me first)
- Read/update CURRENT_TASK.md each step; delete when done.
- Build/lint/test (fish): cargo check --workspace; and cargo clippy --workspace --all-targets -- -D warnings; and cargo test --workspace
- Run dev tools: asset-editor/dev.fish; debug via /tmp/ascii_rpg_debug; prefer debug scripts in repo root.
- Logging: use info!/debug!/warn!/error! (no println!); avoid per-frame logs unless trace!.
- ECS: prefer components over resource maps; use markers + Changed<T>; keep resources for config/assets only.
- UI: adaptive content; builder pattern; size-aware components.
- Done = compiles clean (clippy -D warnings), tests pass, verified in-app, no TODOs/hacks.
- If blocked: state why and propose the next viable step.
- Before large refactors/features: give 2–3 options and trade-offs; confirm direction before coding.
## 1) Build, lint, test (quality gates)
- Fish shell one-liner:
- cargo check --workspace; and cargo clippy --workspace --all-targets -- -D warnings; and cargo test --workspace
- Fix all warnings. Use snake_case for functions/files, PascalCase for types.
- Prefer inline rustdoc (///) and unit tests over standalone docs.
## 2) Run and debug (dev loop)
- Start the app with debug flags and use the command pipe at /tmp/ascii_rpg_debug.
- Quick start (fish):
- cargo run --bin app -- --skip-main-menu > debug.log 2>&1 &
- echo "debug viewport 0 0" > /tmp/ascii_rpg_debug
- echo "ui 30 15" > /tmp/ascii_rpg_debug
- Helper scripts at repo root:
- ./debug.sh, ./debug_keyboard.sh, ./debug_click.sh, ./debug_world.sh
- Logging rules:
- Use info!/debug!/warn!/error! (never println!).
- Don’t log per-frame unless trace!.
- Use tail/grep to keep logs readable.
## 3) Testing priorities
1) Unit tests first (small, deterministic outputs).
2) Manual testing while iterating.
3) End-to-end verification using the debug system.
4) UI changes require visual confirmation from the user.
## 4) Architecture guardrails
- ECS: Components (data), Systems (logic), Resources (global), Events (comm).
- Principles:
- Prefer components over resource maps. Avoid HashMap<Entity, _> in resources.
- Optimize queries: marker components (e.g., IsOnCurrentMap), Changed<T>.
- Separate concerns: tagging vs rendering vs gameplay.
- Resources only for config/assets; not entity collections/relationships.
- UI: Adaptive content, builder pattern, size-aware components.
- Code layout: lib/ui (components/builders), engine/src/frontend (UI systems), engine/src/backend (game logic).
## 5) Completion criteria (definition of done)
- All crates compile with no warnings (clippy -D warnings).
- All tests pass. Add/adjust tests when behavior changes.
- Feature is verified in the running app (use debug tools/logs).
- No temporary workarounds or TODOs left in production paths.
- Code follows project standards above.
## 6) Never-give-up policy
- Don’t mark complete with failing builds/tests or known issues.
- Don’t swap in placeholder hacks and call it “done”.
- If truly blocked, state why and propose a viable next step.
## 7) Debug commands (reference)
- Pipe to /tmp/ascii_rpg_debug:
- debug [viewport X Y] [full]
- move KEYCODE (Arrow keys, Numpad1–9, Space, Period)
- click X Y [left|right|middle]
- ui X Y
- Coordinates: y=0 at bottom; higher y = higher on screen.
- UI debug output lists text top-to-bottom by visual position.
## 8) Dev convenience (asset editor)
- Combined dev script:
- ./asset-editor/dev.fish (starts backend in watch mode + Vite dev)
- Frontend only:
- ./asset-editor/start-frontend.fish
## 9) Tech snapshot
- Rust nightly (rust-toolchain.toml), Bevy 0.16.1.
- Workspace layout: apps/ (game + editors), engine/ (frontend/backend), lib/ (shared), asset-editor/.
Keep changes small, tested, and instrumented. When in doubt: write a unit test, run the app, and verify via the debug pipe/logs.
## 10) Design-first for large changes
- When to do this: large refactors, cross-crate changes, complex features, public API changes.
- Deliverable (in CURRENT_TASK.md):
- Problem and goals (constraints, assumptions).
- 2–3 candidate approaches with pros/cons, risks, and impact.
- Chosen approach and why; edge cases; test plan; rollout/rollback.
- Keep it short (5–10 bullets). Get confirmation before heavy edits.
First up: this isn't criticism of the original post in the slightest, it's a wonderful journey through figuring out how a weird device that wants to be on your wifi works.
If you have a device that speaks to an Android app, you want https://github.com/niklashigi/apk-mitm - it'll strip pretty much every known certificate pinning implementation from an apk, and it'll also rewrite the manifest so it'll trust the user-installed certs without having to root your device to modify the system store. Uninstall the original app, sideload the output of apk-mitm, and then you can use mitmproxy on a stock device.
The other thing is that if a device is providing encrypted data to an app, and the app is displaying the decrypted data, then the app inherently either contains the decryption key somewhere or downloads it from somewhere. https://github.com/skylot/jadx will turn an apk into something that approximates Java, and digging through that will often let you figure out what the key is. But some vendors will decide that the appropriate way to handle this is to kick the cryptography out to native code, at which point you're into having to RE something in Ghidra. Depending on your mindset this is either incredibly tedious or incredibly fun, but it's generally possible.
The author was able to build on top of work that had been done by others, but if you're ever faced with a situation where nobody else has done that work, don't just give up. It's worth spending time trying to figure out how code running on a device you own works, and even if you don't succeed in the end you're probably going to learn a lot in the process.
I've been running multiple Sensirion SPS30 PM sensors for years, and I'm honestly amazed how well they've held up. Particularly with respect to, within their spec'd error, how new/unused SPS30s report similar values to my heavily used ones.
Curious if there are any maintenance requirements for the bosch sensor.
Adafruit (an electronics manufacturer and retailer here in the United States) has been sharing insights in a video series called 'Tariff talk' as well: https://youtu.be/y36XchXA8BU
Similarly HYTE, mostly known for their PC cases, gives a remarkably detailed insight, both into their cost structure and how they are impacted by tariffs, in this video:
It's simple to enable on Windows, any surface with DXGI_SWAP_CHAIN_FLAG_DISPLAY_ONLY set will get excluded from screen capture APIs. No DRM is required.
DRM isn't always the reason for video not being capturable, though. Efficiency optimizations can also get in the way, such as hardware video overlays. Back when overlays were first introduced, attempting to capture the screen would often omit the video because it would only capture the chroma key in the primary surface. Even today, the DWM has to undo multi-plane optimizations and specifically composite the screen when screen capture is requested.
Open ID Connect is not OAuth. It is not done as part of the IETF, and the OpenID Foundation seems to have slightly lower standards for specs. For instance, specs can be updated with errata sets that go as far as as introducing significant changes in the behavior without changing the version number and then do URL is just magically switched to the new document ("incorporating errata set N") without warning. And to top it off, there is no changelog to be found (or at least I couldn't find it).
The original OAuth 2 RFC is a very easy read and it's clearer than most specs out there. It's certainly far easier to read than any W3C spec.
I think the main issue is that there are too many specs that have been added over the years, and you need to know the right ones to implement. Some specs should be mandatory (like Bearer Token Usage, PKCE, OAuth for Native Apps and Current Best Practice[1] and Browser-based Apps[2] when they come out of draft). Some are useful only for certain use cases (Device Authorization Grant, Token Inspection Endpoint and Token Exchange). Some specs are horrible abominations that would hopefully never be implemented (I'm looking at you RFC 9101 JWT-Secured Authorization Request).
The good news is that OAuth 2.1 incorporates some of the best RFCs I've mentioned into the core RFC. This would help make OAuth simpler by having one document to point out to. I hope it comes out soon, since at this point I still have to fight with people who think that using the Password Grant is a great idea and have no idea why they should implement PKCE or CSRF protection.
If you have money and little time and patience, Bambu labs p1 or x1 series is one of the easiest to set up out of the box, and you can get or add on the AMS (automatic material system) which makes it easier to do multicolor printing. (US $700+)
If you have little money and more time and patience, Creality Enders are a good basic introduction to all the nuances, pains and heartaches of 3d printing but will give you a better idea of fundamentals. ($100-300) Expect to lay out another $100 for filament, upgraded bed and other small parts like bed springs.
Don't buy a used machine as a starter because you'll just be taking on someone else's headache, but once experienced you can find some craigslist and offerup deals for spare parts or a small print farm, occasional like new "used twice" $50 printers.
It was a major pain to find how to disable this thing. In fact, if you google "AdvancedMicroDevicesInc-RSXCM" (with the quotes, to get a verbatim search) you won't find more than a handful of results talking about its existence.
It doesn't uninstall the settings panel itself, just the shortcut. Yes, the context menu shortcut is a standalone app package of its own. It's crazy.
After uninstalling this AMD crap the context menu went from taking a second to being almost instantaneous.
On other people's machines I've also remarked certain antivirus like Kaspersky causing major issues with 11's context menu performance.
I thought the new context menu was all about fixing the mistakes of the previous ones when it came to the nasty things people can do in extending explorer.exe but seeing the behavior of those new third party additions to the menu, I guess not.
I recommend Postgres FM podcast, e.g. available as video on Postgres TV yt channel. Good content on its own, and many resources of this kind are linked in the episode notes. I believe one of the authors even helped Gitlab specifically with Postgres performance issues not that long ago.
Richard Hamming’s The Art of Doing Science and Engineering is one that’s really shaped my philosophy on CS. It pushes for the importance of reasoning from first principles, experimentation, and taking on extraordinary work. There’s also a fascinating and prescient section on AI and the limits of computers and how we think about them. Stripe Press makes a nicely bound hardcover edition of the book, too:
Not exactly a launcher but Everything by Voidtools is the fastest way to find anything on windows. You get search results while typing, it becomes an essential utility after using it once.
I've found that the easiest way to effect change is by making the people who make decisions feel the pain of the problem. A lot of line levels do a lot of heroics in an attempt to keep pain from rolling up hill
Instead of the organization just doing the work to stop the pain, they throw bodies like so much human analgesic at the problem - I hope you'll let me torture this metaphor some more - and become addicted to this state of affairs.
Not only does each ORM have a different API and access pattern to do this, once you hit this point, you're managing the object model ALONG WITH custom SQL for migrations.
There is also non-trivial danger in letting your ORM decide what data types your database schema should use. Got UUIDs? The ORM will store them as strings. Need start and stop timestamps? A range type with an exclusion constraint may be the right tool.
What you appear to consider "advanced features" are what some others of us consider "perfectly normal." Let's be honest: most devs consider knowing the difference between a LEFT JOIN and an INNER JOIN to be an advanced topic.
Devs will wax poetic about the marginal benefits of monads in limited scenarios, but throw up their hands in defeat when you mention a window function for a dashboard. They'd rather calculate it in the app layer with all the added latency that implies.
My dislike of ORMs mainly stems from the tendency to treat modern SQL engines as glorified dumb bit buckets.
Where a CTE or LATERAL join or RETURNING clause would simplify processing immensely or (better yet) remove the possibility of inconsistent data making its way into the data set, ORMs are largely limited to simplistic mappings between basic tables and views to predefined object definitions. Even worse when the ORM is creating the tables.
SQL is at its heart a transformation language as well as a data extraction tool. ORMs largely ignore these facets to the point where most developers don't even realize anything exists in SQL beyond the basic INSERT/SELECT/UPDATE/DELETE.
It's like owning a full working tool shed but hiring someone to hand you just the one hammer, screwdriver, and hacksaw and convincing you it's enough. Folks go their whole careers without knowing they had a full size table saw, router, sander, and array of wedges just a few meters away.
Notably:
- You can opt out (Computer Configuration > Administrative Templates > Windows Components > Windows Copilot > Enable the "Turn off Windows Copilot" policy)
- You won't get it if you're in the EU
- You'll only get it if you have an M365 app installed (not all windows users)