slaymaker1907

You can sort of work around it by placement new, but it’s still hugely inconvenient in the general case since the thing could have strict alignment requirements.

Oh and not just stack, it also breaks global variables because destructors often get run for those when something gets unloaded or the program stops.

Finally, because C++ gives you tons of control over how assignment works, it’ll probably break being able to use things within other objects unless you give those mark those classes as friend.

Besides this point, I mostly mentioned it as an example of probably the simplest in-memory yet disk-backed database imaginable. For example, if you want to implement any sort of transactions, you don't want to actually do anything like fsync until you start trying to commit the data.

It depends on what is meant by in-memory database. The most useful kind IMO is the one which actually saves everything to disk, but is not designed like a traditional RDMS in that it assumes everything, including indices, can be saved in memory. Therefore, you don't need a complicated buffer pool system and you don't need to touch disk at all after startup to service read queries. The most simple approach to such a database is just to MMAP a file.

This kind of workload is probably the most common in all of software development for the past couple of decades given how plentiful RAM is as well as most applications having some need for storing persistent data.

It can also execute a query incrementally. In fact, certain features rely on this behavior. “Watch live data” (in SSMS) for extended events is actually an infinite table-valued function. It’s not exactly rocket science to do in a database, you just need to model data sources and operators as iterators.

Lol, the commit message is just great https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/lin...

It's good that Linus is really exercising those 3rd party tools! They should send some money his way for helping them test their code.

For a really neat implementation of OOP and inheritance, I would recommend checking out Racket's class system (not to be confused with generics). It mostly solves the multiple inheritance problem by mixins and also has a great interface system.

150 countries, but missing a lot of key ones like the US, Israel, Russia, and China. (They absolutely should sign this, though).

I’m suspicious that all it will take is one major shock for the house of cards that is international law to come tumbling down just like it did before WW2.

So what we thought was automation was really just outsourcing.

Upon further reading, I think you might be correct. I initially thought a good signing process would be sufficient since it sounded like this malicious blob was secretly being included in the tarball by the build server, but it instead seems to be the case that the malicious binary was included in the repo as a test file.

You could probably still protect against this sort of attack using signing, but it would be much more laborious and annoying to get working. The idea is that you would somehow declare that OpenSSH binaries must be signed by a *particular* key/authority, that VS Code is signed by Microsoft, Chrome signed by Google, etc. Additionally, the config declaring all of this obviously needs to be secured so you'd need to lock down access to those files (changing key associations would need to require more permissions than just updating old software or installing new software to be useful).

I think it would help to try and secure signing infrastructure as much as possible. First of all, try to have 3 devs for any given project (this is the most difficult step). Make sure logging into or changing any of the signing stuff requires at least 2 of the devs, one to initiate the JIT and one to monitor.

Additionally, take supply chain steps like requiring independent approval for PRs and requiring the signing process to only work with automated builds. Don't allow for signing bits that were built on a dev machine.

Finally, I think it would help to start implementing signing executables and scripts which get checked at runtime. Windows obviously does executable signing, but it largely doesn't sign stuff like Python scripts. JS in the browser is kind of signed given that the whole site is signed via https. It's not perfect, but it would help in preventing one program from modifying another for very sensitive contexts like web servers.

Largescale use of electric planes still seem like sci-fi for the time being, but you did get me thinking that airships would likely produce a lot less noise pollution than planes.

Yeah, let's get rid of one of the most effective sources of green energy that works around the clock! The environmental concerns around dams are legitimate, but they need to be balanced against the consequences of how those energy sources will be replaced. There are also mitigation strategies that can be done instead, like the fish ladders that were mentioned in passing, to help mitigate the environmental impact.

Edit: I see climate change isn't even mentioned which is an enormous red flag when talking about hydro power.

> If we look at human anthropology, we see a species that treats solitary confinement and banishment from society as punishments — we are a society because we can cooperate and trust a little — but when are safely back in society, we start competing like mad (and cheating like mad) as though the society is there to be strip-mined.

I really like this quote. We simultaneously value trust and community, yet so many people also treat it as just another resource to turn into money and power. Alan Kay is a real gem.

I looked up the limit and as of 2021, tabs seem to have been limited to 16GB which is moderate in size for an in-memory dataset. However, I know WASM has a hard limit of 4GB without Memory64. Data size is all relative.

Sum types have definitely been making a big splash. I'd also look at how C++ has added concepts and Go has added generics. Local type inference is also commonplace too, even Java has it.

I think System76 also has a pretty simple evaluation process. You mostly just select the form factor you want and then configure it. Also, unlike Apple, they make it easy to get a machine exactly tailored to your needs. They don't force you to pay $$$ for an expensive processor when you just want a bit larger SSD and some extra memory...

Oh yeah, splitters are the one thing I haven’t tried to build myself because they’re so tricky. I’ve done a ton with circuit networks and trains, but belt balancers are far less intuitive to work with.

There's still the UAC prompt which should help mitigate risk, plus it's locked behind developer settings.

Talking about the ADHD thing, there's a similar problem with some research that claims stimulants cause Parkinson's disease. The study authors didn't seem to account for the fact that people with more severe ADHD would be more likely to be treated with stimulants and that severity of ADHD could instead be the causal factor.

Non-squash commits are kind of a nightmare to actually implement securely. You need to make certain that all the commits are properly assigned to an actual person (no impersonation) which would involve implementing commit signing infrastructure which a lot of orgs don’t want to do.

It can also get confusing as a reviewer if people do any rebasing after submitting the PR.

Why would you implement your own atomics? It seems very similar to std::atomic, except you need to do a bunch of platform specific hacks to get it to work. The only possible reason I could think of why you would do this is if you aren't using at least C++11. If you aren't using C++11, then you probably shouldn't be using threads in the first place.

Shared pointers are most definitely not zero overhead. The trouble is that they use atomic operations which can cause tons of problems for highly concurrent systems. You can use non-thread safe smart pointers, but at some point you have to ask whether that is really lower risk than just not using shared pointers at all (Rust gets around this with type checking).

I think you're missing the point. How a lot of projects operate is that the commits on PR branches are completely pointless since they will be deleted when the PR is merged and the PR description will become the real commit message for the commit on the main branch from the squash-merge.

The trouble is that Git is trying to do two things at once. It's trying to do remote synchronization as well as change tracking all at once.

An alternative is just to do "git commit --amend" every time you want to fix some small bug, but that has downsides in preventing reviewers from seeing what has changed between PR iterations as well as preventing you from going back to an earlier point in time for some branch. When you have less than a dozen commits, it is completely reasonable to just look at diffs and timestamps to determine which commit you want to go back to.

It's kind of annoying since with squash-merge too if you are trying to develop dependent things since merging gets nasty on the dependees.

I find it really ironic that they disqualified Babel considering that it was pretty anti-imperialistic and pro-China (though pre-CCP). They just hate Kuang because her grandfather fought against the CCP.

As someone with ADHD, that's a lot to ask. However, in my opinion what we really need is a common standard for banks to handle recurring payments for subscriptions. Asking me to review every single thing on every account is a ton to ask, but it would be a lot more manageable if recurring stuff had its own section and that I could cancel stuff from my bank app directly.

Sure there are a lot of complexities, but it's not that horrendous as someone who literally worked on recurring payments for a bank. You just simplify things by making it a pull system. A recurring payment is just authorization from the bank to withdraw up to X dollars every Y days/months/year (you want a design like this to avoid dealing with holidays and weekends on the bank side which vary for every country).

"We can have that new release deployed in about 6-8 weeks."

There are tricks you can do, but it introduces load on the TLB. You basically restrict accesses to 32 bits of memory and isolate that space in virtual memory with its own prefix.

I don’t think so. This entitlement is something devs have to explicitly opt in for.

I think this is an enormously bad idea. The whole point of using sun.misc.Unsafe is because you need to do something with basically no overhead, regardless of safety. In my opinion, they should just modularize it such that users must enable access to it explicitly. The MemorySegment API is nice, but sometimes you really want to skip bounds checking in a cross platform way.