mhenr18
Joined 14 years ago
Joined 14 years ago
I'd be happy to talk more about this if you're interested - email is in my bio.
https://randomascii.wordpress.com/2019/10/20/63-cores-blocke...
A few months later, some other people in my team were struggling to diagnose an issue in production where a legacy webapp was struggling to scale up and fully use all 64 cores of the server we needed it to run on. I stepped in to help and remembered that post I'd seen on HN. We used ETW (through Windows Performance Recorder and Windows Performance Analyzer) to profile our app and I looked into the Wait Analysis. Turns out that Entity Framework 6 uses a ReaderWriterLockSlim to guard a cache, and that particular lock performs extremely poorly under heavy contention. Heavy in our case meant that for a single page build of one of this app's "hot path" pages, this lock would be taken a few hundred thousand times. We weren't the first to discover this:
https://github.com/dotnet/ef6/issues/1500
What some other people in my team were struggling with for about two weeks was resolved in a single day thanks to me goofing off and reading HN. (We ultimately used a fork of EF6 that didn't suffer from this issue to solve our problem)
I have other machines that I use for my day job, but it's such a fun little computer to use.
We deal with large hospitals and airports, so it's normal for us to have tens of thousands of components mounted at once - pagination isn't a viable solution for our purposes.
We've had to tap basically every optimization that React apps can do when managing large numbers of elements - however this has been worth it for us:
- We can use the same code to render interactive plans on the client, and to render to print-quality PDFs on the server - We can use the same framework in our UI and plan rendering
The downside is that it's more CPU intensive than alternatives like a WebGL renderer, but for now that's a tradeoff worth making.
I'm actually quite happy with the facial recognition cameras at the Australian border - they make things a lot faster than they used to be from my experience.
Suppose there is enough on-street parking for other non-residential uses. You don't want these spaces being constantly used by car owners who are living in apartment complexes that aren't meant for them. As a local government, you have to play the game of not letting them park using parking restrictions while potentially also managing by-laws that allow residents to get parking permits that let them bypass some restrictions.
This doesn't really apply in high-density urban areas, but I could see it being tricky to manage in growing areas.
(Although, I guess from a non car-owner's point of view you wouldn't care about whether other drivers are being inconvenienced by a lack of parking, because the knock-on effects wouldn't affect you.)
Winter time is standard time, and DST is in effect during the summer months to better make use of the extra light available during summer by winding clocks an hour forward. The idea being that you get an extra hour of sun in the afternoon.
Our nohoist section currently looks like this in order to get things to behave:
"nohoist": [
"**/electron/**",
"**/electron",
"**/electron*/**",
"**/electron*",
"**/canvas-prebuilt/**",
"**/canvas-prebuilt"
]
These are likely going to require auto-ejection due to being native and having postinstall scripts.Would it make sense to not bother with hoisting of ejected modules when using YPnP, given that YPnP solves the same problems as hoisting in a more global way? We'd be able to get rid of the nohoist section in that case.
It's not fantastic if you're working on an Electron app where there might be one specific feature that requires a native module in order to hit an OS API that you can't do from a browser sandbox (and that Electron itself doesn't expose).
Rather than pursue total deprecation/eventual removal of postinstall/native modules, I think a package.json "allowNativeDependencies": "never" | "devOnly" | "always" option that defaults to "devOnly" if not specified is the way to go.
My main experience was with Line Rider. I didn't create it, but I became involved in the community and started making tweaked versions with tools that made it easier to create tracks (as opposed to versions that let you do things like change the physics or the rider).
Every line you added to a track caused a new MovieClip to be added to the scene that had a line drawn in it. By the time you had around 3,000 lines or so you'd start to get reduced framerates. 3,000 lines sounds like a lot, but is tiny when you consider tracks that have accompanying artwork.
A few years ago, we released a JS + WebGL rewrite of Line Rider that has a physics engine that's bug-for-bug compatible with the original (you can play it at https://www.linerider.com/ if you're interested - sorry if that's too self promotional). With access to WebGL and a massively faster ECMAScript runtime, the JS version runs multiple orders of magnitude faster than the original Flash version.
It's now possible to work with tracks that have hundreds of thousands of lines without experiencing frame rate drops as opposed to just a few thousand lines. So as for web platform tech underperforming from a runtime point of view, I disagree.
The problem is that all the ingredients are there to make something great, but the developer effort required is monumental in comparison to how fast it was to make something work with Flash Pro.
Front-row seats and exit row seats are paid upgrades because of the extra space. They aren't paying economy - they're paying slightly more.