fathyb
Not sure what you meant by that, you always could `mmap` files into memory on iOS. Back in the 32 bits days there was a ~700 MB limit due to the address space, but there aren't anymore nowadays with 64 bits. If `didReceiveMemoryWarning` is called on your app, then you need to free resident memory but the kernel will take care of dumping file-backed memory pages for you.
I’m not sure if it changed, but last time I heard HN was running on FreeBSD: https://news.ycombinator.com/item?id=16076041
> just imagine how much performance could be gained if game vendors didn't ignore it
In the case of FreeBSD, Sony used it as the base for the OS on PlayStation since PS3.
> An investigation based on the largest leak of documents in British political history. The Labour Files examines thousands of internal documents, emails and social media messages to reveal how senior officials in one of the two parties of government in the UK ran a coup by stealth against the elected leader of the party.
About us: Zscaler is the leader in cybersecurity and zero trust digital transformation and a fast growing cybersecurity company from Silicon Valley named Leader in Gartner MQ for Secure Web Gateway and SSE multiple years in a row.
Mission: We're building the future on Remote Browser Isolation [1] at Zscaler and we're looking for talented engineers to help us. We are fully cloud native and we probably run the most scalable Kubernetes infrastructure in the world.
About the team: You will work within a small team with agile mindset to help shape up a brand new project using Chromium, GPUs, WebAssembly, and Rust. If you feel comfortable working on a low-level environment, can learn fast and not only code features and fix bugs, but also design architecture to lay the foundation for others' work you might be a great fit!
To apply, please email me at [email protected].
Reminds me of an Archer bit: https://youtu.be/c9uuITbtl-g?t=2
- Oh my god, Slim Goodbody!
- No! No, this is absolutely not that trademark character. Just a unitard with the systems of the human body on it. On a guy.
- On a guy named TV's Michael Gray.
It's before. You can code sign and verify macOS binaries with any certificate you wish, including a self-signed one (useful in case you want your private iTerm fork). Note the plugin should be signed with the same certificate as the iTerm app [1], just using a paid account won't work.
[1] https://gitlab.com/gnachman/iterm2/-/blob/b0e6b336a6be9bca00...
Heroin is close to fent in lethality, and oxycodone is next in line [2].
[1] https://nida.nih.gov/publications/research-reports/prescript...
[2] https://www.cdc.gov/nchs/data/nvsr/nvsr67/nvsr67_09-508.pdf - Figure 1.
My point is: if you're comfortable working with a slightly obscure microcontroller, then you won't have much problems. LLVM supports WebAssembly out of the box, so it mostly feels like programming for one of those.
Anecdotally: we run a large Rust app in under 1 MB of WebAssembly at Zscaler.
In case you absolutely do not care for WASI but love WebAssembly for the web.
I'd start with that, it's an obvious red flag. Switching between both should create huge differences. Also look into `wasm-opt` from the Binaryen project for post-link optimizations, `wasm-ld` from LLVM isn't that great at DCE.
OpenGL ES 2.0 is probably the most portable GPU rendering API there is, it pretty much runs anywhere. That said, using Metal or D3D should definitely bring noticeable improvements, especially when it comes to memory bandwidth (eg. on Metal no need to send pixels to the GPU memory for atlas-based text rendering).
They removed the hypervisor framework in addition to the kernel support for virtualization a few months ago unfortunately.
Also note you can get precise JavaScript measurements (and threading, eg. using pthreads and Emscripten) by adding some headers: https://developer.mozilla.org/en-US/docs/Web/API/Window/cros...
I would also find it confusing if I found code doing something like network retries using `CACurrentMediaTime`.
That's for slices, for dynamically sized types (eg. `Box<dyn ToString>`) it contains a pointer to the virtual table.
> Because they lack a statically known size, these types can only exist behind a pointer. Any pointer to a DST consequently becomes a wide pointer consisting of the pointer and the information that "completes" them (more on this below).
Your `Locker` does not do what `Arc` does, even at compile time, because it does not allow concurrent access, like an `Arc<AtomicBool>` would. Your `Locker` is more like an `Arc<RwLock<T>>`.
Best equivalent you can get in C++ is `Arc<T>` = `std::shared_ptr<const T>`.
https://doc.rust-lang.org/std/sync/struct.Arc.html
> Shared references in Rust disallow mutation by default, and Arc is no exception: you cannot generally obtain a mutable reference to something inside an Arc. If you need to mutate through an Arc, use Mutex, RwLock, or one of the Atomic types.
I guess you could get the final pieces to get something similar by creating `Send` and `Sync` traits in C++: https://doc.rust-lang.org/nomicon/send-and-sync.html. I think the main pain point here is that you cannot auto-derive `Send` and `Sync` so it would end up being very verbose.
I mentioned Chromium because they also differentiate between thread safe and non-thread safe shared pointers.
If anything, Rust shared pointers are more similar to C++ std pointers because in Chromium the reference count is inside the class, which is very handy because you can reconstruct a smart pointer from a raw pointer (like `this`), at the cost of needing `T` to extend `base::RefCounted`.