Li Hongyi is the son of Singapore PM Lee Hsien Loong, as well as a deputy director in GovTech Singapore (the Government Technology Agency). (He's also an MIT CS grad, and a past Googler.)

I suppose he wrote this for other people in the Singapore civil service.

That's essentially what Korean did. They replaced everything with their own morphophonemic orthography.

But even then they still use Hanja to disambiguate sometimes.

I was not even talking about Hangul, the point I made was on using a Latin alphabet. If we are revamping the whole writing system, why reinvent the wheel if the main goal is "efficiency"?

edit: obviously Kana has already been created

There have been notable Japanese people who argued that the Japanese writing system should adopt Latin alphabets since ~150 years ago.

https://ja.m.wikipedia.org/wiki/%E3%83%AD%E3%83%BC%E3%83%9E%...

I'm personally fine with both romaji and kana (learning kana is not a big cognitive burden anyways).

I'm even fine with kanji (or Latin or anything) if people learn it voluntarily. What's not ok is kids being forced to learn them in school.

The Wikipedia article on this provides some background information: https://en.wikipedia.org/wiki/Euphemisms_for_Internet_censor...

> The 2004 Chinese Communist Party announcement of the goal of constructing a "harmonious society" has been cited by the government of China as the reason for Internet censorship. As a result, Chinese netizens began to use the word "harmonious/harmonize/harmonization" (和谐) as a euphemism for censorship when the word for censorship itself was censored, particularly on BBSs. Following this, the word "harmonious" itself was censored, at which point Chinese netizens began to use the word for "river crab", a near homophone for "harmonious". In a further complication of meaning, sometimes aquatic product (Chinese: 水产) is used in place of "river crab".

That's because you are supposed to do bounds-checking yourself in Rust, not because they don't want to handle it gracefully.

It's like happens when you read out of bounds in C, except it fails more reliably.

You're supposed to write correct code in Java as well. The reality is that it doesn't always happen. C doesn't claim to handle the issue at all, and doesn't verify it, which is at least a performance gain. Rust does verify it, but issues an error type that is not guaranteed to be recoverable at all.

Then you disable overcommit.

For the general case though, because of the way programs have been written, it is easier to have overcommit on.

These aren't text files, but Google Docs files, which Google doesn't count against an account's quota.

OK, I did see that.

But I don't understand why Google would do that. For most users, aren't Google Docs files a substantial part of their usage? Or do people mainly store backups?

Simple, Google wants to encourage people to use their office suite so they indirectly subsidise it in this way.

FTA "A single google doc can store about a million characters. This is around 710KB of base64 encoded data."

This means that in order to reach the limit of the drive space given away for free, they'd need something like 15,000 Google Doc files (15GB) if they counted toward your space limit. I doubt a lot of paying customers even reach that.

The real limit (file size) is reached by binaries. Videos and PDFs, usually.

I see.

But then, I suspect (as others note) that Google will notice when you have 50GB of Google Docs full of base64.

Seems an iffy way to store stuff.

There's a good chance they won't. For privacy reasons, engineers can't just start peering at your files.

They'd have to write a base64 detectors and automate the detection and banning of the accounts without the engineer ever seeing your files.

Any bugs in that code, and they'll ban innocent people.

Wouldn't it be simpler to just set a generous limit for the number of Google Docs files? Say, 15 thousand?

I bet implementing such a limit would be 3 or more months of engineering effort.

Think about the difficulties. It has to take into account shared directories. It has to know about systems which auto-create documents (like results sheets for Google forms). It has to work with gsuite sysadmins who need to take ownership of files from deleted accounts. The UI to show when you have hit the limit has to be designed. And the support team has to be trained on how to resolve that error. And you're going to have to get that error message translated into 30 languages. Users already over the limit are going to be unhappy - are you going to write extra code to give them a grace period? How will you notify them of that? Will you have a whitelist of users allowed to go over the limit? How will you keep the whitelist updated and deployed to the servers? Who will have access to add/remove people from the whitelist?

The actual system itself has race conditions:. What if that 15000th file was simultaneously created in the USA and Europe? There is no way to prevent that without a cross-ocean latency penalty. Do you want to pay that penalty for every document creation? How do you deal with a net-split where cross ocean network traffic is delayed?

Finally, how will you monitor it? Will you have logging and alerting for users hitting the limit? Will there be an emergency override for engineers to remove the limit if necessary?

At big-web-service scale, simple engineering problems become complex problems fast...

OK, not simpler.

So what? They might end up nuking some accounts, when some symptom pops up. And there'd be no recourse, whether or not it was a false positive.

This runs on proot, which basically ptraces all processes under it and intercepts any syscalls that need privileges or deal with paths, and emulates them.

It works pretty well until you start to run many processes, and then proot starts to be a bottleneck. It's not multithreaded, so every syscall ends up going through a single loop. Any multithreaded code that makes a lot of syscalls will be reduced to being effectively singlethreaded.

Why is everyone focusing on the fact that someone spoke via Skype?

The fact is that

1. Jolovan Wham did organise a physical gathering of people 2. The gathering/assembly meets the definition as in the Public Order Act[1] 3. The venue, The Agora, meets the definition of a public place as in the Public Order Act

[1]: https://sso.agc.gov.sg/Act/POA2009

They could have been watching a recorded video and it would have been the same.

I'm not sure that a recorded video would have been the same. The source for the techcrunch article says:

> The Singapore Police Force in an earlier statement, said that Wham had organised an indoor public assembly featuring a foreign speaker, which required a Police permit.

Although given that political films are also banned, maybe a prerecorded video would have been illegal under a different law.

The problem is the intent of the gathering, not that it had a foreign speaker. (Not that I agree with the law, but that's what it says.)

And? Some laws are stupid and must be broken.

If you don't like a law, change it, don't break it and get yourself in trouble.

This is basically the difference between East Asian cultures and Western/American culture. We value a balance of order and individual rights, you guys value individual rights over all.

It is funny how in these kinds of discusions it is always "you guys have excesive amount of A and not enought of B, whilst we have a perfect balace of A and B" instead of "you value A more than we do, but we like B more".

Individual rights are just that -- not rights, not privileges and thus not subject to debate, thought they are of course frequently violated by totalitarian states to a greater or a somewhat lesser degree.

I know this is controversial, because the current rule is that you are not supposed to say that your moral system is right and the other guys system is wrong, but A is A and Freedom is not slavery, no matter how much that is yelled from the tops of mountains.

For a bit of historical perspective, this was the same criticism made of the civil rights movement in the 1960s. Good thing MLK didn't try to follow your advice.

How does that work when the law forbids you from assembling to effect political change?

Ah, I was wondering how Skype played a role. So there's no reason it shows up in the title.

I have a hard time reconciling the Linux kernel with any meaningful definition of simplicity.

Not when you want to do async I/O and must instead burn CPU cycles and battery life spinning in a select loop.

What?

select(), which originally appeared way back in the day in 4.2BSD, is a way to not spin — it only returns when a descriptor is ready.

NT's IO model gives you asynchronous wait on arbitrary event sources, including file IO — not just the network stack. It's actually quite nice if you get over the hideous type names and verbose CamelCase symbols.

In contrast, select(), from 4.2BSD through the current day, cannot be used for async IO on regular files. It simply returns immediately. If used naively this could result in a busy loop, I guess, although getting stuck in a blocking disk operation seems more likely to me.

One of the reasons all the BSDs have kqueue(2).

kqueue cannot be used for async IO on files, either. Same problem.

     EVFILT_READ         Takes a descriptor as the identifier, and returns
                         whenever there is data available to read.  The
                         behavior of the filter is slightly different
                         depending on the descriptor type.

                         Sockets
                             [Non-listen] socket descriptors return when there is
                             data to be read, subject to the SO_RCVLOWAT value
                             of the socket buffer.

                         Vnodes
                             Returns when the file pointer is not at the end
                             of file.  data contains the offset from current
                             position to end of file, and may be negative.

There's aio(4), but support and APIs vary wildly across platforms.

The Unix async model based around fds and select was really only designed for sockets, and has been extended to socket-like objects (pipes/fifos). Linux has added support for some other sources in the form of e.g. signalfd(), eventfd(), timerfd_create(); the BSDs just added it all to kqueue/kevent. Neither supports async file operations in the fd model (basic operations like read/write; nor more complicated operations like syncing a range, renaming a file, creating a file, etc).

Why would AIO be useful at all?

aio(4), or asynchronous I/O on files in general?

Both async I/O and select/poll are ways of multiplexing concurrent I/O activities onto a single thread of control. Both provide a way to initiate I/O and wait for completion without busy waiting. Both require timed-out waits if the thread must give periodic attention to something other than I/O.

Windows works on the new MacBook not because it has special drivers for NVMe-via-T2 but because Apple trusts Microsoft's EFI key.

So no, stop it with all this "Linux works if you just disable Secure Boot" nonsense. It doesn't. You can run Linux from a USB key, sure, but it can't access the internal NVMe SSD!

Judging by this post:

https://unix.stackexchange.com/a/479544

It looks like some kind of driver issue, not an intentional lockout.

To corroborate this, while I don’t have personal experience running Linux on T2 devices, I do know it’s possible to build xnu from source and boot the resulting unsigned kernel (in “No Security” mode) without the disk disappearing.

Please provide evidence for this causal link. It is true that (with Boot Camp enabled) the firmware trusts the Windows key and not the MS third-party key. It is true that Windows can access the disk and Linux cannot. It is not obvious that these are related.