skysight-inc/HackerNews huggingface dataset:
It's a full managed (bare metal) VMware environment.
Basically you get a dedicated cluster of vSphere hosts, with VSAN storage.

Some use cases are: migrating to cloud (for all kinds of reasons, like not wanting to invest in own datacenters and HW anymore) without having to refactor applications, hybrid applications where the front end lives in Google Cloud but the backend requires a more 'traditional' environment, using the cloud for DR, ...

Similar offerings exist at other hyperscalers:

* Amazon: VMware Cloud on AWS - https://cloud.vmware.com/vmc-aws

* Azure: Azure VMware Solution - https://cloud.vmware.com/azure-vmware-solution

* IBM: IBM Cloud for VMware Solutions - https://cloud.vmware.com/ibm-cloud

* Oracle: Oracle Cloud VMware Solution https://cloud.vmware.com/oracle-cloud

* Alicloud: Alibaba Cloud VMware Solution https://www.alibabacloud.com/press-room/vmware-based-cloud-t...

[Disclaimer: I work at VMware]
> But what I'm saying is, documenting big O complexity is useful, even if imperfect (and if the function has "tricky" complexity, the conditions where it gets bad should be documented too!).

Ah yes I totally agree on this point, it should be documented for those who are more cautious/mathematical in their engineering efforts. I'm just not one of those people! I prefer to focus on the structural behaviour of a team (if it's my responsibility) to ensure that cases like:

> two years later that the company is investing employee-years into horizontally scaling your application as it's slow under workload

Resolve correctly - if a team is set up to respond healthily to production slowdowns (of course the equation is different for software with a slow/nonexistent update loop) then IMO you don't need to invest as heavily into up-front optimisation and can instead invest into features, allowing (sample-based for busy paths) profiling in production to notify you when optimisation is warranted.

At the end of the day, up front optimisation is an exchange of time with your future self/colleagues. It's worth it in some cases, not in others - but knowing where the balance in a tradeoff lies in your circumstance is a good chunk of all engineering decisions!
I caused the guy who created Bitcoin to go into hiding. Accidentally
Ah, thanks for clearing this up - I've thought I had no idea what I was speaking about.
Seems interesting
Not to be negative, would be annoying to tell anyone about this app, all the extra effort to make sure they understand the name is woice.me and not voice.me
How would it help you knowing that it's O(n)? It needs to read all the characters of the float. Problem is that it's needlessly reading characters even after the float
Really? Can you give some examples? I know compilers are amazing but this seems too much.
But if you know the performance of an algorithm up front, you don't have to spend any time optimizing it in the first place. You just know what to do, because you know the performance.

For instance: suppose you are building a CRUD app on a SQL database. Do you (a) add indexes for important queries as you go? or (b) ignore indexes and later profile and see what queries are slow. No, of course you just make the indexes in the first place. Having to do the latter would mean that instead of having a fast app out of the gate, you have an app that gets slower over time and requires additional dev time to debug and improve. Profiling and fixing performance problems is a massive waste of everyone's time if the problem could have been dodged when the code was being written.

It's different if the optimization is significant engineering effort. Then, yes, put them off till it's needed. But most aren't, in my experience: most optimizations are totally simple, in hindsight, and the code should have been written that way in the first place.
My pet peeve with all emplace functions, make_unique etc. is that CLion won't let you command-click the calls to jump into the constructor being called. Are other IDEs better at this?
We're entirely browser focused.

The SAP support is through startup investment, like YC, we were part of SAP.io Berlin: https://sap.io/portfolio/
Interesting. I wondered why flutterapp.com (the AR/VR app) redirected to flutter.dev (the UI framework)... It led me to believe it was the same team. Apparently not. Thanks.
Kinda late. That, or rather the non existing web client to begin with, were the main reason i never used it.

Now most people in my circle have it removed anyway.
I mean keeping the history of decisions in code.
Reminds me a bit logic of a thief which just can't resist.
I don't know, I might say it as a joke, therefore seeing it said I assume they say it in the same manner as I would with the sound of innocent wonder that can be used to denote sarcasm.

I think as a general rule it is good to assume the best, even though I myself might not always be able to do so because of various limitations of understanding.
One problem here is that correct code relies on valid inputs in order to avoid UB -- Undefined behaviour is a runtime property of a running program, rather than (necessarily) a static property of an isolated unit of code.

In this way, UB is essentially the converse of Rust's `unsafe` -- we must assume that our caller won't pass in values that would trigger undefined behaviour, and we don't necessarily have the local context to be able to tell at runtime whether our behaviour is well-defined or not.

There definitely are instances where local checks can avoid UB, but it's also perfectly possible to write a correct program where a change in one module causes UB to manifest via different module -- use after free is a classic here. So we can have two modules which in isolation couldn't be said to have any bugs, but which still exhibit UB when they interact with each other.

And that's before we start getting into the processing of untrusted input.

A C compiler -- and especially the optimiser -- assumes[1] that the conditions for provoking UB won't occur, while the Rust compiler (activate RESF[0]) mostly has defined behaviour that's either the same as common C compilers would give for a local UB case[2] in practice or have enough available context to prove that the UB case genuinely doesn't happen.

[0] https://enet4.github.io/rust-tropes/rust-evangelism-strike-f...

[1] Proof by appeal to authority: I was a compiler engineer, back in the day.

[2] Signed integer wrap-around is the classic here: C assumes it can't happen, Rust assumes it might but is much less likely to encounter code where there's a question about it happening.
This (https://abseil.io/tips/112) is a much better explanation of this advice.
Vvoice
If you want to see hypersensitive people just look at this thread.

> If there was anything to be offended about, it would be that practice.

Yes, not the category of people typically playing them.

Let's write a variant of the joke to put it in perspective.

"Because the world today is not the world of yesterday. A capitalist oligarchy runs the world and forces us to consume in order to keep the gears of this rotten society on track. As such, the biggest market for video game consumption today is found in basements. It is a market of poor souls forced to compulsively consume digital content in order to forget the misery of their everyday life, their mom, or just any other brief free moment they have that they are not using to produce goods or services for the ruling class (if they have a job). These individuals need to keep focusing on their video games (because not doing so will fill them with tremendous existential angst), so they go as far as spending money on them to extend their experience, and their preferred way of doing so is by playing expensive video games and virtual-reality porn.

But what if someone were to find a way to pass a copy of the game to their friends (or, if they lack friends, other random people on the internet)? That would be terrible, because it would help players consume the content without paying. If that happens, they will have nothing that prevents them from thinking, and the tremendous agony of realizing their own irrelevance would again take over their life.

No, we definitely do not want that to happen, so let's see how to encrypt savegames and protect the world order."
The piece starts with:

> .. This introduction is an Easter egg and is not intended to be taken seriously.

> .. Please don't remove it :)

So sad we take people seriously when they make jokes but ignore their sincere, non-joke comments when it actually matters. I hope the change actually helps solving the problem, if it really exists.
> I can't answer those because as far as I can tell, none of that context was really mentioned in the piece. If the bar for understanding the documentation is "you have to go on twitter and ask the author a bunch of critical questions to explain the joke" then consider the group of people who you are limiting that documentation to.

It's really simple: "If you have questions: just ask, communicate, listen and don't jump to immediate conclusions from the get-go". That's not too high a bar to set, no?

Suppose someone turns to me and says "You have written a piece, that's how I feel and my conclusion is that you need to retract your statement." My first question to them will be: "Well, have you considered asking and listening to me first before you jump to that conclusion?"

> I see some people who have apparently suffered, making a specific request to another group of people to help reduce their suffering.

Did these people ask why the piece was included in the documentation in the first place? Did they try to understand the intentions of the author? Was their an open debate about this at any point?

If you don't find a debate online, have you asked them if they talked to the author directly, or are you joining a bandwagon without asserting whether or not their suffering might be caused by misunderstanding the intentions of the authors of that piece? Or worst, caused by an unwillingness to consider the intentions of the authors of the piece?
These are fake, posted here a few days ago.
For the note app, I open source it few days ago (https://github.com/djyde/plastic) but it's not production ready. But if anyone is interested, you can download the app from the `release` and have a try.

The main idea is I save the whole note in a json file. I designed a schema to save these bi-directional notes. The benefit of "just a json file" is everyone can develop their own application around this schema (Something like "an open standard schema for block-based note"). For example if I want to build a mobile app for it, I just need to make an app that read and write the json file.
I use atom and use searching all the time too. Mainly because its so easy to reach and execute trough shortcuts. Definitly faster than touching zhe mouse.
In a roguelite you end up paying real time, and not only that, you have mechanics that are designed around making spending that time as tempting as possible, while attempting to masquerade as something harmless.
Haskell is not that clever (or at least it was not a year ago). The memoized version is much much faster.
You have mentioned pretty much all the tools I wanted to mention (Repl.it, Katacoda, etc).

Hesitant plug: We do have a platform, https://iko.ai, we started for our own use to do ML projects for our clients, but I don't know if it's suitable for your case. It has real-time, no-setup, collaborative notebooks with most of the popular packages pre-installed (30GB+ images worth of libraries). They can also install additional libraries right on the notebook.

People can work together on the same notebook, see each other's cursors, changes, and selections. They can execute that collaborative notebook on their own environment.

We use that to train our models, but we also use that for our weekly calls: we write the agenda in the notebook, then be on a call and go over it point by point editing collaboratively, adding snippets of code for proof of concept or to reproduce a bug in the product. This way we have the meeting minutes, with the executable code, and the prototypes in the same place.

The platform does much more than that (training, tracking, scheduling notebooks, deploying models, + real time dashboards for model monitoring, etc...), but you don't need all that. We've onboarded students our colleague was supervising for their final year projects on ML.
I don't know about LLVM but GCC has had something like this for years as a standard optimization feature. You create a binary with special profiling code which writes to a file. After running the program a few times, you recompile with optimization that uses this file. I forgot the flags though.

Personally, I'm more interested in executable optimization. It decompiles an executable, performs whole-program optimization, and re-compiles it. I'd love to tinker around with optimizing other people's binaries (e.g. games) for my machine. There is something like that for LLVM but it's very experimental.
This kind of matches the performance I recorded when numpy is linked to vecLib for large matrix matrix multiplication in float32:

https://gist.github.com/ogrisel/87dcf2c3ab8a304ededf75934b11...

Note however there is currently no way to build and link numpy and scipy against vecLib to get correct results when calling LAPACK routines (to get Singular Value Decomposition for instance). It might be related to low level fortran ABI problems but I am not an expert so I don't know for sure.

It's possible to get a fully working numpy / scipy stack with OpenBLAS and gfortran by using the conda-forge distribution:

https://github.com/conda-forge/miniforge#download

The performance is not as good as with vecLib (see the linked benchmark) but it's already very good (e.g. compared to a similarly priced Intel or AMD laptop with OpenBLAS and maybe even MKL).
> All useful “value type” classes will override it with a real hash of the content

Well, this is necessary for a lot of sensible things you'd want to do with non-numeric value types as hash keys...

> including String

...except String is something of an intermediate case. There are loads of use cases where what you're really using is a set of constant strings, not variables that contain arbitrary character data. In that case, you should intern the strings, resulting in non-"value type" keywords where the only thing you care about for equality is whether two keywords do or don't have the same machine address.

I don't actually know how Java handles this, but I had the vague idea that two equal String literals will in fact share their machine address. And String is specifically set up to accommodate this; Strings are immutable, so in theory it could easily be the case that any two equal Strings must share their machine address, even if you got them from user input.
I've been using Amethyst [0]. It works, is simple enough to configure and get started and has most things I need.

I found the default shortcuts to be the wrong way around for my cognition so I swapped them but otherwise it's been good. I mostly use the fullscreen (usually for the laptop's screen) and "3-column with main in the middle" layouts.

[0] https://github.com/ianyh/Amethyst
> whoever wrote Bitcoin was a Windows programmer, though not an incompetent one.

It's worth pointing out that code of the first version was organized in a ridiculous way, even pro Windows programmers do not dump everything into one directory. So a widespread opinion is that it was written by an amateur without professional programming experience, albeit extremely bright, as organization aside, code worked very well.
Also, the piece that got taken down is a piece that essentially mocks morally bankrupt companies for abusing people. That's about as opposite for what the woke thing stands for (or at least is supposed to) as you can get.
I buy most of my music on bandcamp when it's available there. The genres I'm buying range from indie-synthwave stuff to classic rock to death metal to jazz and folk. I love to give them my money if I enjoy the music enough, but honestly I consider it more of a symbolic gesture. The midnight had at some point a letter that their music sales are cool and all, but they can only make a living because people where coming to their shows. They made an exclusive deal with amazon to bridge some time during the pandemic, but things are going downhill for them currently. I heard the same from fiddlers green when I saw them live, telling us the live shows and the merch are the thing that keeps them running. So I've got two artists telling me the money is in performances and merch, in addition to the statistics about the payments from streaming companies.
My question is, if there is "more work to do on the Web", why is Flutter Web considered stable?
A man who saves forgotten cats in Fukushima's nuclear zone
Oh snap, this was news to MSFT? How did they not register bitflips of windows.com and microsoft.com?

I think I checked this like 10 years ago, and Google had. (well, except the infinite set of subdomains where a dot and an n are one bit away)

And this is why ECC RAM should obviously be the default.
A problem with germanium transistors is their tendency to degrade over time until they either start leaking too much current also when unbiased or go directly to short circuit, no matter if they're used or not, so it's advisable to test a small stock before buying bigger lots that could contain many now defective parts. Speaking from experience as I had to ditch like 25% of a big lot purchased years ago in which many were shorted to death.

About the AC128, I stopped using it in pedals years ago. It was an ordinary low cost part that later became famous for being used in the original fuzz pedal; as a result it is today sold at outrageous prices, while any normal Ge transistor would work with no difference in sound. It's not the part number, it's the technology: Ge transistors are slower (as in narrower bandwidth) and their sound is therefore less harsh, warmer than Si ones. A pair of ultra cheap ACY* SFT* or many russian ones (less prone to leaks due both to higher [military] standards and their relatively shorter age as the soviets kept producing them long after the west stopped) would sound equally great once the circuit is being adjusted for bias and gain.
I haven't found the compiler ever optimizing something different because of constness. The various escape hatches means that it is really hard for the optimizing compiler to make certain assumptions, especially if it's connected to something with external linkage. A function with a const struct arg that you never take the address of? compiler emits memcpy!
> This is hyperbole to the point of being nonsensical.

I think you can only say this if you've never had aggressive compiler optimizations introduce security issues into perfectly reasonable-looking code.

Quiz, what's wrong with the following code?

int buflen, untrusted;
char buf[MAX];

/* `untrusted` comes from an untrusted source */

if (buflen + untrusted > MAX) {
return -EINVAL;
}

The answer of course is that integer overflow is undefined; so if buflen + untrusted is greater than INT_MAX, the compiler is allowed to do absolutely anything it wants; and making sure it's only allowed to do something sensible turns out to be extremely difficult.

EDIT For instance, in an earlier age, people might have done something like this:

if (buflen + untrusted > MAX || buflen + untrusted < buflen)

But the second clause relies on overflow. The compiler is perfectly justified in saying, "Well, overflow is UB anyway, so if it happens, I'm allowed to not do anything; so I'll just make this code more efficient by removing that check entirely."
So? That was an early adopter year. For the vast majority of people, the iPhone has always had an App Store.

Actually, that supports my point. The App Store came by because people wanted it. No one said: “oh no bloat my phone will slow down”.
Hence “blindly”. The blog post was a detailed, less sanctimonious version of your comment.
Fair enough, I know the test hops resulted in a lean but didn't know they had a significantly improved leg design.
Bugfixing isn't optimisation
Why Are So Many Base Jumpers Dying? (2016)
James Melouney and Selene Urban on Meditation, Authenticity, and More [audio]
The bug is, on ocassion, while executing a query, LiveData would hit EACCESS trying to open the table (?): https://issuetracker.google.com/issues/170228126

It had to do with their Invalidation tracker (a table, I believe, which is a living log of ordered updates that need to be delivered to observers).
Is prime factorisation used in SHA256 ?
Would I be able to solo mine from my CPU again ?
>it wouldn't be outside the norm, even more centrist than radio and TV.

That automatically centrist steering is exactly the problem with social networks, your get in to your bubble, and everyone else is your tribes enemy. But sure that happens on traditional media too...i can remember we someone said something against invading Irak (2003?), they got nearly hanged by the crowd. Even Bush said "be with us or against us", but the whole invasion was based on a single lie (that sadam has some C-Wapons) but that was forgotten, retaliation was the main thing.
Not op. But vscode, even thought its a bit faster in many cases, was literally the only popular editor i ever used that is able to crash so badly that you lose edited code. I use it sometimes today for haxe, but IMO they released a unfinished product a few years ago and losing code in the 20th century is just a traumatic experience that sticks. Never had any losses with atom.

Edit:// i never tried vs on windows. May it works better there? Atom definitly works less well on windows than on linux, so maybe thats why vs got so big by cloning atom
On web pages? Yeah I think so? Which website outclasses this?
Not bad for an entry level Mac laptop.

iPhone 11: 350
RX Vega 64: 800
Radeon 560X macbook: 41
That's not the reason, it was almost certainly due to Rosetta and nothing else.

Changing the processor architecture over for the first time was going to be a massive undertaking (I'm sure there are still folks there who have nightmares about universal binaries from '06). They had no way to run a wide public beta of the hardware before releasing, so had to play it as safe as possible.

The only sane way to migrate something so fundamental is to change absolutely nothing besides the processor, so that you have a side-by-side comparison between the previous generation and the new one out in the wild to debug problems that come up. If they had added [Face ID / a touchscreen / new mechanics for the keyboard] they'd need to debug whether those changes were causing the bugs rather than the M1 changes.

That's why I've fought myself to hold of - I'd expect the next MBP to be a fundamental redesign.

I can live without a touchscreen, but please just give me a Face ID laptop Apple.
This prompts the next question... what can those of us who don’t want this slide towards authoritarianism to continue, do about it?

Regardless of political/social viewpoints, I don’t think it matters if you consider your political views left, right, up, down, a, b or start... for the most part these views are compatible with free expression and “lowercase l” liberal democracy. Notwithstanding notable exceptions such as capital F Fascism or capital N Nazism, where being authoritarian is literally part of the political philosophy.

So how do we resist this trend? I’m not talking about rallies and counter-protesting, that won’t help shit when it’s happening in other countries. How do we make liberty and democracy better so that people want it enough to say no to the continuing pressure towards alternatives... ?
That works if you're a CEO of a company and don't have shareholders to respond to, or your shareholders also think alike.

If you're a lowly employee with a family, doing some open source or blogging or whatnot on the side, and that side activity attracts the wrath of professional victims? You're suddenly in risk of significantly derailing your life (and that of your family!), possibly damaging it permanently. So you capitulate, just to survive.