efaref

So "freedom of speech" is where you can say what you want, except that if you say the wrong thing to the wrong person, then there are potentially serious repercussions, up to and including imprisonment.

I'm curious to know what not having freedom of speech would look like.

If freedom of speech is so limited, does it even exist as a freedom anymore?

You could say I have the "freedom to take anything I want" except I mustn't take anything that belongs to somebody else. Do I really have any freedom with that restriction in place?

Personally I don't think we have freedom of speech (in the UK, certainly legally we do not). You have to be careful of what you say and who you say it to. Maybe that's OK, and free speech was a failed experiment. But to claim we have that freedom whilst restricting it thus is just wankery.

You can call my fears "horse manure" if you like, but that doesn't really change the fact that I have them. Based on how I've seen some of my (now ex-)colleagues treated when they have spoken up, I don't think they are at all unfounded.

And yes, people have been discriminated against for who they are, or what they believe, for a long long time. It was wrong then and it is wrong now.

I'm not really sure what the amendments to the US constitution have to do with a post about British workplaces, but I think you have a very different view on "freedom of speech" than the classically liberal one that it is arguably founded upon. That's OK, of course.

In the UK we don't have and have never had freedom of speech. In fact, we have some of the harshest libel laws in the world. There are very many consequences for saying or publishing things that you're not allowed to here.

But this post is about people self-censoring their opinions, particularly in the workplace, for fear of repercussions, and that is something that absolutely is getting worse. Like many others I steer clear of all of these topics myself, as even though I hold "approved" opinions on them. I fear that someone may wilfully misinterpret something I say and cause me irreparable harm by going on some weird crusade to have me fired and my life ruined, as that seems to be what normally happens these days.

If one has fear then one is not free.

Limiting it to legal consequences is not enough. There are also physical and psychological safety consequences that are relevant. You're not, for example, free to speak your mind if expressing wrongthink will result in a punch to the face.

In the context of a workplace (being the topic of this post, after all), one such consequence is the loss of your job. Something that is very real these days, with so-called activists doxing people and trying to get them fired just because they dared to express a dissenting opinion.

This is exactly the problem. "I do not agree with what you say but I will defend to the death your right to say it" has been replaced with "freedom of speech doesn't mean freedom from consequences". The latter is, of course, utter nonsense. Repercussions or retaliation for expressing wrongthink is the literal definition of a place that does not have freedom of speech.

The implementations for Rust and Julia are different in a way that means the comparison is not really apples-to-apples.

The Julia implementation replaces the input list with a Julia object, which is of course trivial for Julia to iterate over.

The Rust implementation is asked to convert the list-of-list-of-floats back to Python types, and then back into Rust types. Of course converting 100M floats back and forth is going to take a non-trivial amount of time.

The equivalent in Rust would be to wrap the return value in a PyObject that contains the Rust `Vec<Vec<f64>>`, and the Rust code could then just iterate that directly. It would even be made safe without the GIL as you'd implement your own mutex on the Rust side if you wanted it to be mutable.

If you do this then it runs in about 1.2s on my laptop.

The true zen of source control is that they are both.

While the compile times are a bit slower, one of the advantages of the strict type system is you don't need to compile to an executable quite as often.

Most of the time your IDE's messages (or "cargo check" output) is sufficient to find all the things the compiler will complain about.

I usually find that once I've fixed all of those, I compile it once and it just works.

Using TFA's analogy, that's a workaround where you use the neighbour's toilet.

So that's why they killed the audio jack on modern phones.

There's a translator for C99 to (unsafe) Rust: https://github.com/immunant/c2rust

So probably you can give me any C program and I'll be able to give you an equivalent Rust program. It'll probably perform about the same, too.

How many threads can you spawn before the system grinds to a halt? If you're processing thousands of requests per second and each request gets its own thread then you will start to queue on thread spawning. Don't forget that each thread gets its own stack taking up megabytes of memory.

The async concept has been used for decades in pretty much every product I've worked on professionally, from enterprise raid controllers to network protocol implementations and telephony software. An engineer I respect once told me that really it's the only way to write services at scale, and anything else is just a step on the road until you reinvent it. He was probably exaggerating, but it is very important, and nearly ubiquitous.

Having used custom frameworks for async code in C and C++, it's really refreshing to have it baked into the language and well supported. It's yet another arrow in Rust's fantastic quiver.

I think the people who mocked the senator for the "series of tubes" comment would also be the kind of people to brag about their "phat pipe".

> systemd has long since outstripped what’s required of an init system

I think this is the fundamental disconnect.

systemd isn't an init system. It's a collection of useful programs for general running of a system, including but not limited to an init program.

Rust's type system is more expressive than Java's so you can end up with much nicer to read code with stricter and more obvious invariants. There also tends to be way less of the `EnterpriseJavaBeanFactory`-style code in idiomatic Rust.

I've found that once you fully get this, Rust is actually easier to write code with. Especially refactoring. You can make sweeping changes to complex code and be satisfied that once it compiles it will most likely work.

Fearless refactoring is one of the prime benefits of Rust.

"Income tax" isn't the only tax on income.

There is National Insurance (which is a flat 2% above ~40k).

There is the tapering of the personal allowance, which amounts to another 20% between £100k and ~£125k.

There is the stealth income tax of Employer's national insurance, which is spun as a tax on the employer, but all employers realise that they need to pay this extra ~13%, so obviously they factor that into salaries.

There is the withdrawal of child benefit for people who earn over 50k, which, again is an effective income tax on high earners with children.

Finally, there are things like the withdrawal of pension relief, which effectively increases your tax by making you pay tax on pension contributions that you wouldn't have had to pay tax on if you earnt less.

All of these can combine to an effective income tax rate of over 50%, by which I mean of the money that leaves your employer's account at the end of each month, more of it goes to the inland revenue than goes to you.

In the UK at least it's pretty easy to get close to, if not over, 50% if you're earning Google SWE salaries. The marginal rate hits 62% at £100k, and that's not including the "stealth" payroll tax known as Employer's NIC.

Seems to me like мат is just "yo mama".

Conversely, have a touch bar, and no one needs to learn keyboard shortcuts.

The touch bar works best for things accessed sufficiently infrequently that muscle memory won't be a thing.

The touchbar is basically the 2010s equivalent of old-school function key overlays: http://www.hamstuff.com/Overlays/overlay.htm

It does also provide some useful feedback as it can display things, too.

This is mostly because of a long history of crummy graphics drivers on Windows led to countless bluescreens. In the past, if your Windows machine bluescreened, it was a safe bet that the graphics driver was the cause.

Microsoft had enough telemetry telling them this that they spent a large effort restructuring the graphics driver subsystem so that it could crash and burn and be restarted without affecting the rest of the system.

Although Linux already has the isolation, it doesn't have the clean recovery. Since the year of the Linux desktop hasn't arrived yet, Linux is yet to make this journey.

So "everyone else does it" is a valid defense?

Apple charges $1k for their monitor stands. I think they can afford to build their stuff at a factory that doesn't use modern slavery.

1 iBuck: $999.

iCloud leaks?

Spam filtering is an arms race. Spammers know how to download all the existing spam filtering software and tweak their emails to make sure it gets past it.

We can name the two different classes of people that result as "Elons" and "Murlusks" after him.

Because thorium reactors don't produce weapons-grade plutonium.

> D vs rust - D is 100% more familiar to anyone with C or C++ background

I had the opposite experience. I have a long history of C and C++ development, yet I found D pretty impenetrable (my team inherited some D code to maintain). Rust, however, was easy to use out of the box.