jaxrtech

“Even Jon Skeet cannot parse HTML using regular expressions.”

I wish there was a way to just repurpose existing operating system support for CJK language IME for English.

Is there an equivalent to caniuse.com for gauging the level of instruction set extension support on x86 and ARM in the wild?

I'm a well constructed system, you could probably get this down to one PostGIS query with some joins and spacial indexes that should run in <100ms.

"web scale"

If Rust was a higher-level language, then I'd say yes, just automatically handle running Futures in parallel, join them when you actually need to resolve the data, and pretend that they look like synchronous functions in the 80% of cases. Though things like `select!` wouldn't make any sense mixing the two.

I continue to find the "function coloring" argument misses the point unless you're arguing from a developer experience perspective. Why should two fundamentally different things look and function the same? Want this the ultimate pitfall of early RPC implementations where everything looks synchronous?

In Rust, a lot of the friction is due to how async functions/futures fundamentally differ in model of execution and how that interplays with the rest of the language. Other languages get to hand-wave a lot of these problems away with a GC. (It certainly could be less of a pain nonetheless.)

- Futures don't execute until polled, can partially execute if something isn't ready (and would block), can partially execute and be arbitrary cancelled and dropped. There is no equivalent in sync functions unless you make them co-routines.

- Since you can "pause" futures if something would block, you need a place to store the function's state for when it's resumed. Now you must be consider if the async function's state is `Send` if the future wants to move to a different thread to continue executing -- which is why you see `pin!` used. Sync functions don't care about this since you always run to completion on the same thread, and the stack is ephemeral.

- Likewise, the `Future` returned by the async function is going to need to encapsulate it's state that it saves. In the general case, this is a compiler generated anonymous struct that changes if any state saved across `.await` changes, hence the opaque `impl Future`. This is why you see `BoxedFuture` a lot to abstract this away at the expense of an allocation. Ideally, the new associated types with lifetimes can avoid this with traits.

So if all functions were co-routines (i.e. functions that can be resumed and re-entered) they would all have the same "color". But all you really did was "lift" all sync functions to be "async" functions with no internal await points.

(IMHO, if the C# team back in the day decided to implement full blown co-routines into the language instead of just `async/await` as a compiler trick, I think many other projects would have followed suit with a more general co-routine solution instead of treating `async/await` as this special thing which is just a specific compiler generated implementation of co-routines.)

Various thoughts:

It seems to me that the fundamental definition of a function/method should be a compile time executed function that generates a syntax tree always (assuming the compiler dog-foods itself or can parse and interpret it). Much like Python has metaclasses or Rust's procedural macros but it's just assumed by default.

It's kind of unfortunate that a language with managed effects & capabilities hasn't gone mainstream. Maybe it doesn't have the right ergonomics yet.

I never can tell if chargebacks are truly a feature or a bug.

This vaguely reminds me of Adobe's ColdFusion except in the browser for better or worse.

I still kills me that (correct me if I'm wrong) the original version of SmallTalk on the Xerox Park Alto had a native arbitrary precision Fraction type.

If NeXTStep used "Display PostScript", then what display API did the original WorldWideWeb browser render to?

Perhaps this is one of the reasons that I've seen Linux deployments use XFS (e.g AWS). If you page through the filesystem documentation, once you hit a certain directory size, it actually switches over to using b+ trees like a RDMS would.

https://www.kernel.org/pub/linux/utils/fs/xfs/docs/xfs_files... (section 16.2 on PDF pg 127)

Was seeing how far I had to scroll to find this perfect quote. How long before all the required readings are banned? I don't understand how you could run a philosophy course without immediately offending someone at this rate.

Just fair warning. 99% of the time, ncdu is great at intuitively finding what is taking up space. Know that unlinked, but in-use files still take up "physical" disk space.

Be weary on machines that have not been restarted I'm a while. The free space reported on the file system layer may not be the same as the amount of space taken up by files.

i.e. It's possible that delete files may still be referenced by processes still running since the space will not be reclaimed until they are killed or close the fd. This commonly happens with GB of log files you deleted but at still `open()`.

That seems to be the greatest difference between Windows and Linux from an OS & file system perspective. - Windows treats files similar to a row in adl database with locking behavior: "This file entry must be deleted from the system. Tell me if I'd be locked out by another process". - Linux treats files as reference counted resources: "I no longer need this file in this directory. The underlying data can still be referenced. You can unlink it."

This is fantastic. This is almost identical to what I've been having to remember in the back of my head every time I go create a new project haha. I've also settled on the anyhow + thiserror deal. Rust is not batteries included -- it's nice for those experienced or beginners to know which batteries to use without going on some expedition to find them.

The more challenging part is working in niche areas, https://lib.rs definitely helps as well.

So is this the use-case for going through the trouble of having a private Root CA that all your machines trust?

Or have the train get your delivery drones close enough to the last mile for the battery to last :^)

A lot of the time, I ask myself, "why don't we seem to have a tool with robust source-to-source transformation?" You could call it "cross-language refactoring". I wouldn't be surprised if someone with the code-base the size of Google has some internal tool. Maybe this is just wishful thinking. The closest thing I've seen is in academic research, e.g. [1].

[1]: Koppel, Solar-Lezama - Incremental parametric syntax for multi-language transformation (2017) - https://dl.acm.org/doi/10.1145/3135932.3135940

From my understanding, Chromium/WebKit/V8 and Firefox/Gecko/Spidermonkey are the last (major) contenders in the browser engine space. After Opera switched to WebKit in 2013. And Edge in 2020. I'm sure there are numerous lesser known ones...

The speed at which I could get TBs of new drives or SSDs overnighted by Amazon without paying extra shipping (in the city, granted) is incredible.

I realize now that the problem was with my browser forcing HTTPS and the site using old TLS or something causing it to fail

Would agree in large part. I think the ones that were successful, they're successful enough that you forget it was an acquisition.

One off the top my head is Google Docs[1] which, for the longest time, I was pretty sure it was in-house tech. It's actually a number of acquisitions for the collaborative editor tech and then MS Office support.

It seems now that most incumbents have enough cash to not care about being that strategic about acquisitions.

[1] https://en.m.wikipedia.org/wiki/Google_Docs#History

You should be able to see inode usage with `df -i`, no? I usually use `df -Tih` (print the file system type, list inode usage, in human-readable format).

I've had the other case where `df` says the disk is full with plenty of inodes left, but then `ncdu` says there is plenty of space (supposedly).

Lo' and behold, you have some borked process still holding GBs of log files open that you thought you "deleted" -- really unlinked from a directory.

tl;dr: Don't forget `lsof +L1` to find pesky processes that are holding files open that you unlinked from a directory but have yet to be actually marked as deleted on the filesystem [1]. The space on disk won't be freed until the process closes the files or is terminated. (Technically, the open files are associated with a mount point, not the file system itself, which makes dealing with symbolic links across file systems somewhat confusing.)

[1]: For example, see https://unix.stackexchange.com/a/141639/332116)

It's also the case that `char` in Rust is a 32-bit primitive. Though, `String` being UTF-8 is convenient until you need to do Unicode operations on actual chars...

It is surely better than dealing with UTF-16 "surrogate pairs"[2] in most pre-UTF-8 tech where a `char` is 16-bits but can't fit all Unicode codepoints without another 16-bit `char`.

[1] https://doc.rust-lang.org/std/primitive.char.html#representa...

[2] https://stackoverflow.com/a/54922477/809572

Or at least in my experience using pskill from the Sysinternals Suite, even if you kill a process (at least on earlier versions of Windows), it would not do the same as a SIGKILL (as in "tear down the process, don't wait for it whatsoever"), and would otherwise hang or be waiting for something else.

Are there any fairly good off-the-shelf auto-summarizers with modern NLP?

Tangential, but this is one of the main reasons I never liked Ruby on Rails with Active Record when I first took a look at it. Not having DB-level foreign keys by default always drove me insane. Isn't maintaining data integrity/correctness half the point of using a SQL database lol?

If you were ready to throw away a bit of archival quality, I wonder if writing Apache Arrow straight to disk and then just mmap your columns back in for a query.

Why not have some ML-rendition of BitTorrent designed for sharing pre-trained models? At least then you're not paying for AWS egress ha

My guess is that the npm package itself got hijacked? The latest version on npm is v11.1.0 (updated 3 days ago) while master on GitHub is v10.1.0 (updated 9 months ago).