How big are the commitments here? I’m having trouble finding actual dollar amounts. Does this actually represent an infusion of money into these SMR efforts, or are these “commitments” tied to so many missable targets that it’s actually meaningless?
Oklo in particular seems to be total vaporware, I can’t find a single technical picture anywhere of anything this company’s reactor is seeking to do. They seem to raise money based on a rendering of a ski lodge.
A huge, concrete investment in TerraPower would be more interesting, but as a molten salt SMR which has never been built, this also looks extremely non-committal.
SMRs in general seem like a dead end, we’ve heard about them for decades and they don’t seem to be any closer to making nuclear power buildouts less expensive.
Everything that makes proven nuclear power plant design expensive seems to revolve around the same drivers of expense for all long-term construction: large up front capital requirements, changing regulations, failure to predict setbacks, and pervasive lawsuits. SMRs purport to tackle a couple of these (shorter-term builds, fewer setbacks), at the cost of considerable efficiency, but so far this seems like an inferior alternative to “just get better at building proven nuclear plant designs”.
Many of the levels in that game take place on tiny planetoids with spherical surfaces and central gravity. "Spherical" sells it short, there were some truly wild topologies around which Mario could run and jump.
It's an elegant rendering trick, but if their worlds are represented as a torus, then I expect this would make rotation on a spherical globe view unintuitive.
One example of this: I would expect each location would not have a single antipode (opposite coordinate) but would instead have three. If you were to start at location A, rotate travel 180 degrees along the latitudinal axis to location B, then 180 degrees around the longitudinal axis... on a sphere you would expect to be back at location A, albeit upside down. But on a torus, you are in a completely different location, which is the 'C' antipode. Rotating 180 degrees latitudinally from here will bring you to point D, the last of the antipode set.
Wonderful write-up of attempting to tackle this problem. I believe there must be a significant number of people who have played both Minecraft and Super Mario Galaxy, and had something like this sequence of thoughts - although you have followed it all the way to an actual demonstration, and written up your thoughts along the way so clearly.
The vertical distortion is the biggest issue IMO, there are a few reasonably satisfying ways to approach the horizontal tiling of each “shell”. For example, you can make your world a donut instead of a sphere, and now you have a perfect grid at each level! Of course, this introduces a level of distortion between the interior and exterior, so you also twist the donut once, and now you’ve both solved your distortion problem and invented the stellarator fusion device.
Rust uses the traits “Send” and “Sync” to encode this information, there is a lot of special tooling in the compiler around these.
A type is “Send” if it can be moved from one thread to another, it is “Sync” if it can be simultaneously accessed from multiple threads.
These traits are automatically applied whenever the compiler knows it is safe to do so. In cases where automatic application is not possible, the developer can explicitly declare a type to have these traits, but doing so is unsafe (requires the ‘unsafe’ keyword and everything that entails).
There are tantalizing ways to create fusion which don’t require these precise conditions. For example, a simple farnsworth fusor device gets fusion reactions just by causing atoms to cross paths at super high speed until they collide - they simply don’t collide often enough to release anywhere near a net energy gain.
Inertial confinement fusion, such as the National ignition facility, does generate comparable pressures and temperatures to the core of the sun within the fuel pellet for an extremely small moment during an implosion. This is done by focusing a lot of energy on small target.
Plasma confinement techniques don’t utilize high pressure to create fusion; they rely on extreme temperatures which are significantly hotter than the core of the sun, which can produce fusion events in a plasma which is only pressurized to around 1 atmosphere (they also rely on different fuel types than the sun which fuse much more readily). The key is once again focus, a large amount of energy is put into a small amount of gas. The obvious issue with this is that the extreme temperatures would destroy any physical container rapidly - but given the electromagnetic nature of plasma, it can be contained using a strong magnetic field without reaching the surface of its physical container.
This would work very well for medicine/procedures which are known to work very well, to both doctors and consumers. This includes medicine which is already OTC (pain relievers), but also probably anything they can do at an urgent care: x-rays for broken bones or sprains, throat cultures, antibiotics (drug resistance is complex for this but people generally know they work).
Where costs will inevitably get complicated are:
1. emergency medicine, where the purchaser is in severe pain or possibly unconscious.
2. conditions without cures, or possibly even well-established treatments, and there is thus active experimentation and disagreement
Both of these are unpredictably expensive to an extraordinary degree, and the second category is sometimes rare enough that economies of scale don’t come into play for individual conditions.
I think government coverage of emergency medicine, aka ERs for severe injuries, is relatively uncontroversial due to its nature of treating unconscious patients.
However, that other category is very large in modern medicine. It includes all chronic conditions without cures, for which many options are available and improved techniques are constantly sought - and it includes complicated conditions where treatment has risks involved, which is basically a huge range of surgeries.
The problem in these areas is that the consumer does not have adequate understanding of the efficacy of what they’re buying, yet they’re driven to buy it strongly by pain and suffering. They are likely to want to do whatever a doctor or hospital tells them to do.
What is needed here is a consumer advocate with medical knowledge to keep prices consistent. In the US, this is provided by a mixture of regulation, medical malpractice lawsuits, and insurance companies.
Insurance companies are now failing in that role, but removing them entirely without any sort of replacement is going to leave the courts as the major vehicle to manage the costs - that isn’t a system renowned for efficiency.
I work with this algorithm quite a bit in a personal project. (I've changed from calling it WFC to Model Synthesis; Paul Merrell earned the naming rights, unless we discover an even earlier description.)
I mentally divide it into two important components:
1. Cross-correlation (the 'wave function')
2. Label selection (choosing where the 'collapse' occurs)
The "cross-correlation" is exactly what it sounds like - given an incomplete model and a set of example patterns, this data structure represents the cross-correlation of every place that any of the patterns would individually fit in the incomplete model. I think this is the most useful structure in the algorithm, and is a form of iterative 'feature detection' over the incomplete model.
I think there are many interesting things which can be done with this which aren't in the basic algorithm, such as:
- Having larger indivisible 'patterns' and collapsing such patterns all at once. Although example patterns are always broken down into discrete cells, larger patterns can exist where each cell gets a unique label and very limited transition set. The cross-correlation will detect where they can be placed, and if one is chosen the entire pattern could be chosen at once.
- Partial seeding of labels, e.g. selecting portions of the incomplete model and artificially limiting the available labels in that area, without collapsing it.
- Addition of information to labels which aren't easily expressed in an example pattern, such as rudimentary counting of distances.
The 'label selection' portion (in WFC terms, this is the algorithm used to choose which space to 'collapse') is where all of the random generation comes into play. If using Model Synthesis for full world generation, this is what should be focused on for generating more interesting types of environments.
However, given the common label selection algorithms I've seen and used, I think that Model Synthesis excels mostly at adding small-scale, largely self-similar patterns onto constraints provided by a larger structure. I think that other proc-gen methods better lend themselves to generating large-scale structures. A combination of the two - generating a large-scale structure to serve as a constraint, and allowing model synthesis to fill in interesting detail - seems like a good path to explore.
This release has Observer and Hooks which in my opinion really elevate the ability to express complex, reusable structures in the ECS.
For example, one of the well-known challenges in the paradigm is working with hierarchies or graphs - observers are a powerful tool for communicating between specific entities, and should make this a lot easier to express.
Hooks offer the ability to enforce cross-component consistency in a way that wasn’t previously available.
I think there’s some possibly good investment advice to extract here, if you’re able and willing to invest in fusion startups: based on the need to compete with renewables alone, commercial success implies that highly complex reactors simply may not have a market based on construction cost, even if they do generate power.
Of the fusion startups mentioned in the article, I’d say that makes Zap Energy the one worth gambling on (if you’re a gambler that is), as its success apparently depends on exploiting a fluid dynamics effect which was not well known in the past (“shear flow”). If this sufficiently solves the confinement problem, the resulting device looks ludicrously simple in comparison to contemporaries.
Of course it may not work at all, I sure don’t know if it will; but if you had to invest in one of these, that seems like the one where successful power generation actually creates a marketable product.
Peaker plants are considerably less efficient than base load gas energy, because the constantly running plants use a combined cycle. In both types of plants, the fuel is burned in a gas turbine to directly generate power; however, in the combined-cycle plant the waste heat from this is used to generate steam to run steam turbines, capturing additional power; this actually generates over twice as much useable energy per unit of fuel. Peaker plants cannot effectively use this mechanism as it has a much longer start-up time.
Combined cycle is a major reason that gas power plants are so attractive; the inability to use it in Peakers is a reason why they are so unattractive.
The C++ smart pointers dont prevent multiple threads from mutating the pointed-to data at the same time; multiple threads can both access a unique_ptr at the same time and mutate its contents. Rust requires shared pointers (Arc) to also explicitly implement some sort of Mutex-equivalent runtime safety check in order to mutate the data. Rust also has explicit notion of thread ownership, and whether individual types are safe to pass to different threads; if a construct is not thread safe, Rust will prevent you from using it in multiple threads.
As a benefit of the thread-safety notion, Rust can have two reference-counting pointer types: Arc, which uses atomic reference counting and is roughly equivalent to std::shared_ptr, and Rc which does not use atomics. Rc cannot be used across multiple threads at the same time, and the borrow checker will prevent you from doing this.
Rc is appropriate for data structures which internally benefit from multiple pointers (e.g. graphs) but where all of that information is internal to a single data structure - this becomes available without paying the price of atomics.
Nuclear actually is safe by pure incident metrics, even when counting higher casualty estimates for Chernobyl.
The safety, of course, is not intrinsic: nuclear material is obviously very dangerous, especially in a running reactor.
The safety record stems from the considerable regulation around building and operating these reactors, and the fact that the reactor has so little external surface area once running:
* A very small fuel acquisition operation in comparison to fossil fuels.
* Likewise, no externally released pollution outside of accidents, which is rare.
* sites chosen for construction are picked for their stability, and are heavily engineered, meaning you also don’t have the
installation worksite deaths which run up numbers for wind and solar.
But again, this is only realized if the operational safety onsite is maintained. That said, it’s not the only dangerous power generation site: dammed hydroelectric can be a considerable danger depending on what is downstream.
In general, I think nuclear would be very popular if natural gas and solar were not available; however, the costs to keep it safe are too high for it to be economical compared to those two sources.
I recently learned that Godot forbids auto in its core C++ codebase, their rationale was based on code review:
> Keep in mind hover documentation often isn't readily available for pull request reviewers. Most of the time, reviewers will use GitHub's online viewer to review pull requests.
`using` directives and typedefs are not forbidden, so this would avoid situations where a type is never explicitly declared.
Having worked in large code bases that used `auto` almost exclusively when possible… I’m not sure I agree. However, I understand.
I think that the SQL-on-top, and optimistic model, are definitely things that can have a workflow-dependent performance impact and are relevant.
All databases do suffer under some red line of write contention; but optimistic databases will suffer more, and will start degrading at a lower level of contention. “Avoiding contention” is database optimization table stakes, and you should be structuring every schema you can to do so; but hot keys are almost inevitable when a certain class of real-time product scales, and they will show up in ways you do not expect. When it happens, you’d like your DBMS to give as much runway as possible before you have to make the tough changes to break through.
SQL-on-top becomes an issue for geographic distribution; without “pushing down” predicates, read-modify-write workloads, table joins, etc. on the client can incur significant round-trip time issuing queries. I think the lack of this is always going to present a persistent disadvantage vs selecting a competitor.
And again, given FDBs multiple-full-secondary model, it’s only a problem when working in real time, slower queries can work off a local secondary. But latest-data-latency is relevant for many applications.
They absolutely were, yes. There are very valuable application profiles where FoundationDB's design is excellent, and you can see that from its internal usage at large companies like Apple and Snowflake.
FoundationDB has, in my experience, always been well regarded in DB development circles; I think their test architecture - developed to easily reproduce rare concurrency failures - is its best legacy, as mentioned in a comment above and frequently before.
However, since these topics are always filled with effusive praise in the comments, let me give an example of a distributed scenario where FDB has shortcomings: OLTP SQL.
First, FDB is clearly designed for “read often, update rarely” workloads, in a relative sense. It produces multiple consistent replicas which are consistently queryable at a past time stamp, without a transaction - excellent for that profile. However, its transaction consistency method is both optimistic and centralized, and can lead to difficulty writing during high contention and (brief) system-wide transaction downtime if there is a failover; while it will work, it’s not optimal for “write often, read once” workloads.
Secondly, while it is an ordered key value store - facilitating building SQL on top of it - the popular thought of layering SQL on top of the distributed layer comes with many shortcomings.
My key example of this is schema changes. Optimistic application, and keeping schema information entirely “above” the transaction layer, can make it extremely slow to apply changes to large tables, and possibly require taking them partially offline during the update. There are ways to manage this, but online schema changes will be a competitive advantage for other systems.
Even for read-only queries, you lose opportunities to push many types of predicates down to the storage node, where they can be executed with fewer round trips. Depending on how distributed your system is, this could add up to significant additional latency.
Afaik, all of the spanner-likes of the world push significant schema-specific information into their transaction layers - and utilize pessimistic locking - to facilitate these scenarios with competitive performance.
For reasons like these, I think FDB will find (and has found) the most success in warehousing scenarios, where individual datum are queried often once written, and updates come in at a slower pace than the reads.
That said, overhead always needs to be considered; the overhead cost of using a CPP co-routine would be considerable for implementing a state machine that transitions rapidly.
Co-routines (when used as an async primitive) are an an alternative to callbacks.
Callbacks exist to avoid the overhead of marshalling async results back to the original calling thread: instead of having the calling thread poll until the child thread(s) pass their results back, the calling function returns after kicking off the children, and one of the children directly resumes the work directly when the results are present. This is a significant performance gain.
However, callbacks have famously poor ergonomics, so many structured alternatives have been created: Promises/Futures, Async/Await, and CPP Coroutines.
Oklo in particular seems to be total vaporware, I can’t find a single technical picture anywhere of anything this company’s reactor is seeking to do. They seem to raise money based on a rendering of a ski lodge.
A huge, concrete investment in TerraPower would be more interesting, but as a molten salt SMR which has never been built, this also looks extremely non-committal.
SMRs in general seem like a dead end, we’ve heard about them for decades and they don’t seem to be any closer to making nuclear power buildouts less expensive.
Everything that makes proven nuclear power plant design expensive seems to revolve around the same drivers of expense for all long-term construction: large up front capital requirements, changing regulations, failure to predict setbacks, and pervasive lawsuits. SMRs purport to tackle a couple of these (shorter-term builds, fewer setbacks), at the cost of considerable efficiency, but so far this seems like an inferior alternative to “just get better at building proven nuclear plant designs”.