This is something that I've been hoping to see for a while. The traditional model of web apps, with a database backend but doing manual de-normalization, adding manual caching and cache invalidation, or using manually created and expensive materialized views, seems complex, fiddly, and fragile.
The database engine should be able to build the necessary cache of intermediate state from the queries used by the application; and this shows that that is in fact possible.
EditShare | Linux Application Developer, DevOps | Boston, MA; Warsaw, Poland | Remote possible
EditShare sells storage, backup, workflow, and asset management systems for professional digital video ingest, playout, and editing.
EditShare is seeking a highly-talented developer eager to work on GNU/Linux-based video storage and archiving products in our Watertown or Warsaw offices. Technologies in our products span the entire computing stack, from low-level kernel modules and optimizations, to high-performance distributed storage and network applications, to user-facing cross-platform and web-based client applications. We even run and support our own GNU/Linux distribution!
Cabot Creamery in Vermont is another fairly well known example of this; it actually happens to have joined with a larger but less publicly visible coop known as Agri-Mark.
The Rust team took the approach of targeting application code on the three primary Tier-1 platforms, macOS, Windows, and GNU/Linux, as the goal for API design and portability of the standard library.
Besides the standard library, it also has the core library, which is a small subset that is appropriate for all environments, even those without allocation or those with different strategies for allocation.
With this goal in mind, many of the decisions make sense. A portable application can't rely on getting errors on out of memory situations. Many people don't write code that handles out of memory, or if they do they don't test it, which can lead to significant bugs. Error handling for out of memory is cumbersome if it is required for every operation which could allocate memory, such as pushing to a Vec.
Additionally, Rust 1.0 didn't have some of the later features to make error propagation simpler, so functions which could return errors were more cumbersome to use.
For now, anyone who wants to use Rust in those situations, but still wants allocation support, needs to implement their own allocator and collections with fallible operations. Once the allocator API and fallible collections support lands, much more of the Rust standard library will be usable in such an environment.
LLD has implemented --gc-sections for wasm
LLD has implemented DWARF debugging information sections for wasm
LLD has natively implemented concatenation of custom sections for wasm
LLD has gained the ability to place the stack first in a wasm module's memory layout, reducing the corruption that happens on a stack overflow
LLD option to not merge data segments
Some SIMD generic float intrinsics have been fixed
LLD optimizing further the size of release binaries
LLD supports @-file syntax
Other things which mention LLVM 7 in the Rust bug tracker:
https://github.com/rust-lang/rust/issues/52323 "emscripten already supports the wasm backend in LLVM7, so we should move the current emscripten-llvm from version 4.0 to that, so that we can remove all the workarounds lying around for LLVM < 5.0 (LLVM 5 is the new minimum supported version)."
edit to add: rustc stable 1.29.0 already uses LLVM 7, and nightly is already using LLVM 8; rustc frequently switches to the new LLVM release when it is branched, it doesn't wait until it is released:
It may be impossible for you to get what you're looking for out of a "portable assembler." There's a fundamental tension between low-level control, optimization, and portability. Either you will have code that will run dog-slow on certain architectures, as the compiler has to jump through hoops to do things like unaligned reads and writes that you ask it to do, or it will simply fail to compile certain architectures, or you will encounter undefined behavior on other architectures.
Whichever way it happens, you'd have to rewrite the code for different architectures. If you're rewriting the code on different systems, why aren't you just using an assembler instead of a portable assembler?
However, Rust may be the answer you're looking for.
Right now, in safe code, all operations are well defined; there are a few compiler and standard library bugs which allow undefined behavior, but that's not intentional and many of them are just waiting on some compiler refactoring to land before they will be fixed.
In safe code in Rust, you can pass around references (bare pointers with no GC), work with byte arrays, allocate things on the stack or on the heap, etc. It does provide some restrictions in what you can do to make it possible to check statically that all of your code is safe.
There is also an unsafe subset; this allows the "I know what I'm doing" kind of manipulations you can do in C. Of course, this means that you could encounter undefined behavior; if you do something incorrectly, it could cause arbitrary behavior. The compiler has to be able to rely on certain guarantees that you uphold, because otherwise it could perform not even the most basic of optimizations, nor in many cases even know how to correctly compile the code.
There is an active effort to specify the exact guarantees applied to unsafe code. Right now it's "whatever the current compiler and LLVM happen to do", which is not particularly good in terms of guarantees.
The idea is to try to make something which will be amenable to validating the code. If undefined behavior is sufficiently well specified, then you can compile the code in an instrumented mode which will detect undefined behavior (at significant cost in speed), and you can run your test suite in that mode to get reasonably good guarantees that you don't have UB in your program (as long as your test suite has sufficient coverage).
Clang and GCC have similar modes, undefined behavior sanitizers, that compile code with instrumentation that can detect certain classes of UB. Since C's memory model wasn't designed with this in mind, and C has a fairly weak type system, they can't cover everything.
The hope with the current work on Rust is that a memory model can be formally defined such that all UB could be detected by such a sanitizer, so as long as you have sufficient test coverage, you can be confident of avoiding UB.
Of course, there are other tools you can use as well to avoid UB, like formal proofs of correctness, but it can be quite difficult to fully specify the language in a formal system, and writing proofs of correctness in such systems is not a trivial task.
Air New Zealand already offers the Skycouch, in which an additional portion of the seat folds up to make them wider and you can lay across all three seats: https://www.airnewzealand.com/economy-skycouch
I've flown on it once. It's not as nice as a real bed, you can't fully stretch out without sticking your legs into the aisle, but it's a heck of a lot nicer than trying to recline in a normal economy seat.
I don't know exactly how much it cost, since someone else had bought the tickets for me, and may have used frequent flyer benefits to offset the costs. I think you basically pay the cost of each extra seat, so it's not cheap, but cheaper than upgrading all the way to business class to get seats that recline all the way to flat. If you have someone you're comfortable sharing with, then you only pay for one extra seat for the two of you.
I've just purchased this. For a 9 hour flight from Auckland to Honolulu, it's $230 USD additional per couple. Basically you're paying $230 for the extra seat, for more seat pitch, and for a leg rest that turns into a flat surface. It's really great!
That is a brilliant idea especially for couples with children on long hauls.
Not many people will pay for business on their own dime (business class generally not worth the multiplier -- it's a captive market for consultants and the wealthy), but some might consider buying an extra seat an extra seat if the price is right.
I can't sleep on airplanes, primarily because I can't sleep while sitting up. Even totally exhausted, I'll fall asleep for 20 minutes at most, before something becomes painful and wakes me up.
It's completely miserable on a transpacific because I arrive so very exhausted.
Still, business is WILDLY more expensive. There's no intermediate step to paying several times more. Is actually sleeping worth a few hundred dollars to me? Yes. A few thousand? No.
Premium Economy is a thing now and I’ve become a die hard. Is business worth $5000 more? No. But I’ll spend $400 more for a person sized seat and better food.
Premium Economy doesn't really solve the problem of not being able to lay down -- I can't sleep well when sitting, even in a Premium Economy seat that has a bit more recline.
But in a lay-flat seat, I can easily sleep for 7 - 8 hours (though still need a couple glasses of wine to kick-start it since bedtime on the plane doesn't usually coincide with my body's clock)
BA has one of the densest business class seats in the business, yet it takes up twice as much space as premium economy and 4 times as much space as business.
A quick look on the Uk-singapore route shows business as 5 times the price as economy.
But business is roughly double the price of economy. Do you need to buy an extra seat at the same price, or is it just a small premium available when they think the plane will be underbooked?
Note: China Airlines also has these seats, branded "Family Couch".
I think the target price for the Skycouch seat is somewhat below retail for just buying a third seat, so in that respect it's a pretty good deal if you're already flying longhaul economy with a partner. I mean, I'd flat out pay the retail price to guarantee an empty third seat in a row, and Skycouch has other benefits. That said, while it's an improvement, nobody's going to have a relaxing time trying to have two people sleep lying down on that couch unless they're tiny, and the two people better be very comfortable with close contact.
In theory you can always just reserve and buy an empty seat next to you, but ticketing and check-in procedures are mildly trickier to guarantee that it'll stay empty. I've considered it for flying longhaul solo before but these days I'd generally rather just pay the premium for an upgrade rather than gamble with nonstandard ticketing arrangements.
Are you referring to Wilaiwan's in Montpelier? Excellent place that's only open for weekday lunch, and Saturday lunch when the Farmer's Market is running in the summer.
They usually cook large batches of three dishes, and are open 11 AM to 2 PM or whenever they run out, whichever is sooner; and they do seem to frequently run out, I've found that going at 1:45 is not a good plan.
Yes. Absolutely. It's incredible. The best Thai food I've ever had. I used to go in high school and I recently was back in New England and drove all the way just to go to Wilaiwan's. I got all three options and cleaned all three dishes. A near heavenly experience.
> I got all three options and cleaned all three dishes. A near heavenly experience.
Wow! That's a lot of food!
However, you inspired me to hit them up for lunch again. Work from home and usually eat lunch at home, but went out and had Wilaiwan's today. Excellent as always; I ought to do that more often.
