They could apply a different policy to their web-based dashboard GUIs (if these do exist) than to the web browser.
11,150 karma · joined February 25, 2014
Does the PS5's WebKit use JavaScriptCore with JIT enabled? Have to wonder if Sony will respond by disabled its JIT, to narrow the attack surface.
That's good, but it seems like how-hanging fruit. Boost offers intrusive_prt for this. [0]
make_shared goes half way, and performs a single allocation to return a shared_ptr to a new object. It eventually made its way from Boost to the standard. [1][2]
See also [3] which contrasts the two. (As you can imagine, intrusive_prt is slightly more efficient.)
[0] https://www.boost.org/doc/libs/latest/libs/smart_ptr/doc/htm...
[1] https://www.boost.org/doc/libs/latest/libs/smart_ptr/doc/htm...
[2] https://en.cppreference.com/cpp/memory/shared_ptr/make_share...
(I'm not creata, but I imagine this is what they had in mind.)
Or are pools used to avoid that?
I figure it would be possible to add support for deletions, but it would cost us: we would lose guaranteed contiguous placement of elements with neighbouring indices, and (unless no deletions are made) we'd need a private data structure to correspond vector indices to addresses, and to determine where to locate new elements. This would of course bring us back to continually paying the price of indirection overhead, and simple lock-free modifications would not be possible.
My completely unsupported guess is the cache behaviour wouldn't be too bad unless deletions (of elements that aren't at the end of the vector) are common. I imagine the cache behaviour of a linked list must depend greatly on what the allocator gives you. Presumably using a pool, specific to that particular list, could help there.
https://www.boost.org/doc/libs/1_92_0/doc/html/container/non...
The Linux kernel uses them, at least some of the time they're used with their lock-free RCU pattern. I'm not sure if it's for performance reasons though, I think they're using it in contexts where correctness requires the absence of blocking operations.
I'd expect a lock-free non-linked-list solution would also be possible, but I don't know enough to state that definitively.
creata's comment [0] mentions the works of Agner Fog, which seem very good, and are freely available.
I haven't read C++ High Performance [1] but it looks like it covers the sorts of topics you'd expect, although it looks like it doesn't cover computer architecture in detail e.g. branch prediction. There are books on that too, of course.
[0] https://news.ycombinator.com/item?id=49868657
[1] https://www.packtpub.com/en-us/product/c-high-performance-97...
What you've written mostly makes sense to someone who already has a solid understanding of SIMD and of C++ (although I can't say I follow all of it), but the target audience is people who don't. For them, each point needs a much lengthier explanation.
High-performance programming is a big topic. The scope is far too broad for a single blog post, which naturally gives only cursory discussion of C++ and computer architecture. The article isn't bad considering, but I do think it's the wrong format. A blog series, or even a book, would be more fitting.
Please include a description of what you're linking to. People aren't likely to follow a link to an unknown YouTube video.
The example questions given in the article do not assess wrote learning.
> It's been distilled to the point that the lowest of the lowest common denominators can pass.
Have pass rates been increasing? Unless I missed it, the article doesn't say so.
> forced to learn things they will never use
A computer science degree is not a coding academy, it's a basic grounding in an area of study. A computer science graduate should have some understanding of theoretical computer science and of computer architecture, say, even if they're unlikely to apply these topics directly in their careers.
> My hope is that this is a wake up call to teachers / professors to find a better way to evaluate students. To determine who has actually come away with a real understanding, vs those who were running around copying the assignments off of their peers anyway.
Academics are already aware of the importance of fair assessment, but it isn't easy, especially with LLMs in the mix.
> These same people are now just skipping the peers and going straight to the all knowing oracle. It's the same as it ever was, degree mills.
Students that cheat, and degree mills, are two different things.
The SPARK subset of Ada comes pretty close to enforcing purity of Ada functions, although it still permits them to read globals. [0]
It's not just an oversight. The core of the Ada language was designed deliberately. [1]
[0] https://learn.adacore.com/courses/intro-to-spark/chapters/01...
[1] https://en.wikipedia.org/wiki/Ada_(programming_language)#His...
That strikes me as backward. The higher the expected monetary value of good grades, the more students will prioritise grades over deep learning.
That student presumably performed poorly on the test. Your approach is working as intended here, isn't it?
Also, is the AI-generated exam guide all that different to a human-written guide they could have downloaded a decade ago?
SIMD is parallelism without concurrency.
Their process is still very deliberate, they go to some lengths to avoid getting it wrong when they add new features to the standard. New features have to get through their preview phase successfully before becoming final. [0]
They're also pretty committed to not breaking existing source code or bytecode.
[0] https://openjdk.org/jeps/12 JEP 12: Preview Features
As Ron Pressler (pron here on HN) has been emphasising recently, [0] the 'sweep' phase of a moving garbage collector is unaffected by the size or number of dead objects in the heap (at least in the typical case, where there are no finalizers). This isn't the case here though (it uses free lists), or in any C++ GC.
The policy of running all destructors on the same thread doesn't really seem like 'high performance' architecture either, even if there are good reasons for it.
Still a neat project though. I rather like this:
> Oilpan uses a Clang plugin that statically verifies, among many other things, that no heap objects are accessed during destruction of an object
I'm not sure I understand this:
> Oilpan is a garbage collector written in C++ for managing C++ memory that can be connected to V8 using cross-component tracing that treats the tangled C++/JavaScript object graph as one heap.
In what sense are they treated as one heap? How can they be, given that V8 uses a moving GC for its JavaScript heap? Does it just mean there's some mechanism for a C++ object to refer to a JavaScript object, and vice versa?
[0] https://youtu.be/xr73mR7ii9M?t=1081 Principles of Memory Management in Java, September 2026
LG Smart TVs logging USB filenames and viewing info to LG servers https://doctorbeet.blogspot.com/2013/11/lg-smart-tvs-logging...
HackerNews discussion (178 comments): https://news.ycombinator.com/item?id=6759426
You said the flight doesn't contribute to preventing harm to anyone. Interfering with medical care is a clear form of harm, that's why I focused on it.
> it's not common to fly for medical care (yes, very rich people may have a different perception, but that's all it is)
That's incorrect on both counts: it's common, and it's not just rich patients. Please take a look at the Medical tourism Wikipedia article I linked above. Cost-reduction is a major motivation of medical tourism.
From [0] :
> in 2016 nearly 144,000 UK citizens travelled abroad for medical treatment. The survey suggests a steady increase since 2000, even though the 2016 sample of 250,000 travellers represent 0.23% of the total number of travellers entering or leaving the UK.
See also [1].
[0] https://doi.org/10.58248/PB38 Outward medical tourism (2020)
[1] https://pmc.ncbi.nlm.nih.gov/articles/PMC3812100/ Medical Tourism: A Cost or Benefit to the NHS? (2013)