- locally create a recovery key and use it to wrap any other essential keys
- Split that or wrap that with two or more keys.
- N - 1 goes to the cloud to be used as MFA tokens on recovery.
- For the other, derive keys from normalized responses to recovery questions, use Shamir's secret sharing to pick a number of required correct responses and encrypt the Nth key.
You can recover an account without knowing your original password or having your original device.
Tree and graph structures can be queried using SQL (with more or less difficulty depending on how you have chosen to encode and index them), but it's not a particularly simple and straightforward language to use for such a task.
If you use https://dexie.org/ on top of IndexDB, you can turn it into a fairly useful document store with secondary indices, an improved query building interface, and reactive queries. It's doing exactly what you would expect on top of IndexDB if you did it yourself, but saves a ton of boilerplate. They have a sync service to go with it, but in my usage I managed that myself.
You wouldn't run this in the browser. On the frontend, this would be useful for Electron apps (which run an embedded Chromium for the UI and a local node server for business logic and interfacing with the operating system) on MacOS. On the backend, this might be useful if you have a node-based API and want to share some Swift code between your iOS frontend and node backend.
It's not fully homomorphic encryption. The compute is happening in the plain on the other side, and given the scale of models they are running, it's not likely that all of the data involved in a computation is happening inside a single instance of particularly secure and hardened hardware. I don't think it's reasonable for most individuals to expect to be protected from nation-state actors or something, but their claims seem a little too absolute to me.
That's becoming less the case. As Apple's advertising and services revenue grows and hardware sales slow, they have increasing incentive to mine your data the same as any company does. They already use quite a bit data on the location and content personalization front. I would argue that Apple perhaps cares about protecting your data more from malicious third parties (again like any company should - it's never good for FAANG when data leaks or is abused), but they are better at it (and definitely better at marketing it).
This is it to me. The argument that we are different because we have a current state that includes more inputs and other kinds of inputs than (current model state + context) seems thin. You could just expand context to include current physical state and expand output to include generating things like motor control in addition to words. The big difference between us and current AI is our (somewhat illusive) stream of consciousness. We operate on a combination of noisy decaying context and continuous training. Embody an LLM (or LLM-like architecture) with the right I/O, starting motivation, and the ability to continuously update its own state, and I think you'd have a hard time arguing that it isn't sentient.
That's the thing that would prevent me from buying a Vision Pro down the line. It's going to be an iOS-like walled garden experience. If it could run arbitrary macOS apps on device, it would be infinitely more useful (but probably cannibalize the MacBook market and why would Apple ever roll out a new product line that doesn't force developers to pay them 30%?)
Wouldn't you typically want to run that output through an RC (low pass resistor-capacitor) filter to average out the voltage and eliminate high frequency PWM noise? Is that built into the pico?
I recently spent a few days hacking flow-based layouts and pages into a flex-box-based layout system, and I can confirm that layout and formatting is hard. Figuring out how and when to shift elements to the next page, especially when you have a table with columns containing text and objects of different sizes, is a challenging exercise in picking good heuristics.
I have terrible news about systems built on private health insurance (USA): it will still take 666 days to see a specialist, and you will need a referral from your PCP who may also decide they want to see you in person first. This may be its own scheduling nightmare. Then you may find out that your preferred specialist is out of network for your private insurance. The waits are a generally a supply and demand issue more than a beurocracies issue, but I can assure you that multiplying the number of beurocracies involved in getting healthcare doesn't speed anything up.
I just want a language where await is the default behavior and I have to specify when I want to capture a future as a value and do something with it later. Most of the time I want an emulation of a synchronous thread of execution even if it's actually async. It's crazy to have to constantly specify the common case and to have the possibility of surprising behavior at best if I accidentally forget to await something somewhere.
Couldn't you say that about any American news source, but maybe swap the three hyphenated last names for a brunette white man and a blonde white woman or something? That's just the state of our national conversation. Also this article isn't about any of those topics.
By that do you mean exposing a non-uniform memory hierarchy as separate addressable spaces (but with coherent views from each hardware thread) or something like thread-local scratch pads?
Either way, C is equipped ok for that - at least as well as most systems languages C++, Rust, etc. - simply because dealing with allocation and raw addressing (at least raw within the process memory space) is a fundamental part of the experience. Throw in a few compiler extensions (because you'll need to change the compiler to make use of this anyway) for things like where to locate static allocations and use library functions that add dynamic allocation in specific spaces. It will get hairy, but it's at least possible with some very careful programming.
Kotlin compiles to the native architecture on non-JVM targets. It works just as well as using Swift on non-Apple targets, that is to say it's a bit of a pain development-wise but runs fine once you have your tool chain and interop code setup. Honestly versus either, I'd recommend dart/flutter. Insanely productive, native compiled code, performant UIs that reasonably emulate native (although I'd recommend avoiding that and going stylized - users are more willing to accept something different than something close but not quite right). And interop with C++ is pretty easy.
* Technically Apple forked WebKit from KHTML, but it's been 20 years and 10s of millions of lines of code since then. Chris Lattner and Vikram Adve created LLVM at UIUC. Chris was later hired by Apple who supported its development.
I didn't create the tool, so I can't claim to know the author's intentions. To me, this would be very useful in a variety of circumstances:
- the 15 minute video containing 3 minutes of useful information
- tutorials that you're trying to follow step-by-step that have been tightly edited such that actually doing each step while following along is impossible
- the video equivalent of listicles in which you're really only interested in the list, not the padding
- quickly getting an idea of whether or not it's worth your time to watch a lengthy video by quickly scrubbing through the content
I'd like clarification of whether politics is meant to cover matters of policy or strictly partisan politics and news about the lives of political figures. Surely regulatory policy with regards to technology, communications infrastructure, and similar is of interest.
Yes! I do the same. I serve my web applications from the same statically compiled service that serves the backend API. In CI, I run an npm build process then embed the output. Makes running a local test or demo instance a snap.
Someone should tell that to our government. Meanwhile we've (USA) been taking spending shortcuts and borrowing against our future to enable GDP growth over the same time period with no return in sight.
One reason, but to be fair MBA types can have the same lack of empathy. Their interactions can turn into (actually kind one of the things the author complains about) treating people purely as capital and relationships as means to financial end.
I would say the average ultra runner is probably less hard on their body overall compared to someone training for / regularly running fast marathons (~3 hour and below). Both are probably running a lot of base milage at an easy pace. Marathoner is probably putting in more speed workouts, running on pavement / asphalt / concrete. Ultra runner is probably spending more time on soft surfaces and running with less repetitive motion on trails and is more likely to be doing some supplemental strength training and hiking hills.
Anecdotally for me, running ultramarathons has been a net positive. The 50+ mile races themselves are probably not good for you (potentially loss of sleep, operating into and past exhaustion, running high calorie deficits while cramming mostly junk food in just to get enough sugar and electrolytes to keep moving, risk of hyponatremia or dehydration, etc.), but the training leading up to it is. Regular checkups and a visit with a cardiologist for an unrelated (genetic) condition point to me being quite healthy despite not going to a lot of effort in other areas of my life. Heart is in especially good shape.
Not OP, but they said that you pick up performance, not specifically in reading. The performance you gain is larger aggregate write throughput (and read generally - although reads that require spreading queries across shards and aggregating results will likely perform a little worse). You also gain scale in that you have turned something that was limited by scale up into something limited by scale out (while giving up some data guarantees and performance on some queries).
As to why you can't really have foreign keys, basically, sharding schemes like this sit at an intermediate layer between the application and the various DB clusters that are the shards. You CAN have strong data consistency (and useful foreign keys) within a shard because it's all inside a single database; however across shards, you CAN NOT. The sharding layer doesn't perform checks for you, so if you have two logical tables that are partitioned differently across the shards, you can't have a foreign key that will be enforced correctly as the foreign key of a given row in one table may live on a different shard in the other table. The local database within the shard would reject the insert. Transactions across shards can also be tricky to impossible.
Good question - and one that tells me something. You're familiar with modern front-end development and that's something we can dig into. Why would you want to avoid full page refresh? When would I use a SPA versus more traditional SSR? What about serving something mostly static with progressive enhancement? What frameworks might you consider for developing such a SPA? Which have you worked with in the past? What did you like about them? Any you're looking to work with in the future? How do these frameworks work - i.e. are you someone that hacks on them and is concerned with shadow DOM and optimizing diffs and re-rendering and data binding...
That's why I really like this question - it's just such a cool jumping off point.