brianberns

Close, but not quite.

Here's a little puzzle that really puts this in perspective:

I put 100 lb. of potatoes in the sun. The potatoes were 99% water by weight. After drying a while, the potatoes were 98% water. How much did they weigh at that point?

https://en.wikipedia.org/wiki/Potato_paradox

HN updated their title after I posted my comment. The title of the linked article is still misleading: "Possible Detection of a Black Hole So Big It ‘Should Not Exist’".

The title is misleading. Just to be clear, theory predicts that blacks holes shouldn't be created between 50 and 130 solar masses, but there are plenty of black holes >130 solar masses. This is just an observation of a black hole that falls inside the supposedly "forbidden" range.

The analogy I’d make is to bugs in software. Most software has bugs, but they’re only triggered in specific circumstances. Stay away from those cases and you’re usually fine. If you happen to hit a new bug, you might lose some data, but it’s not going to render the entire application useless.

> If we were to prove that we live inside a simulation, this could cause our creators to terminate the simulation — to destroy our world.

There's nothing to stop our creators from doing that anyway. Simulations are often stopped, tweaked, restarted, and eventually abandoned.

Personally, I think there's value to determining if we live in a simulation. If we do live in one, we could potentially learn how to "hack" the simulation from the inside in order to improve our lives in it.

> From the equations and models of modern physics there is no time. The universe is just a curved 4D surface with one of the dimensions having different properties than the three others.

That dimension is called "time" and it does show up in the equations and models of modern physics.

I stopped reading at "single-celled protein", which indicates to me that the author does not understand basic biology. Does anyone have a better take on this?

I was recently tasked with making some small incremental changes to a large code base that I was not familiar with. I was successful specifically because I could see the existing implementation and use it as a template for making the necessary changes.

For example, if I had to add a widget to a form, I could copy the implementation of an existing, similar widget and then make the necessary changes to it.

Similarly, I had to change the datatype of a field from string to integer all the way from the UI back to the database. This was fairly easy because I could make the change at one level, and then run the compiler to see what my change broke one level up. Fix, rinse, and repeat.

If I had to do any of this without access to the existing code, it would've been 100x harder.

Java applet?

An object has to occupy a contiguous region in memory in order for dereferencing to work efficiently. We need both "this.baseField" and "this.derivedField" to directly access the desired bytes. If either of those has to chase through a chain of memory regions, performance will be much worse.

It's just part of the Eternal September.

https://en.wikipedia.org/wiki/Eternal_September

I think mutability is fine, but there should be some syntactic difference in the usage to alert the user.

I’m not a Python fan and these examples reinforce my dislike for its design.

1. Caused by confusing reference semantics and value semantics, which is pretty much inevitable when a fundamental data type is mutable.

2. Boolean is a subclass of Integer, because... why?

3. Same problem as #1.

4. Once again, beginners have no understanding of reference vs. value semantics, and why should they?

5. Default arguments of a function are evaluated just once, because... why? This one just seems crazy to me. It turns default arguments into stateful globals, so an innocent-looking function suddenly exhibits unpredictable behavior.

It's because the engineers are on staff and you're paying them anyway. Trying to justify a separate purchase, even if would be cheaper on paper, is way harder.

It might not be as unlikely as you think: https://www.newyorker.com/books/joshua-rothman/what-are-the-...

Yeah, embedded systems isn't a domain where functional programming is going to work well. Good luck with those locks! :)

You might be interested in software transactional memory: https://en.m.wikipedia.org/wiki/Software_transactional_memor.... I believe it addresses some of the issues you mentioned in a functional programming way.

I don't think so. For example, sum of first 5 integers:

    sum i = 1 to 5 of i -> 1 + 2 + 3 + 4 + 5 = 15

Nothing mutable there. In functional programming this is done with a `fold`, which doesn't use mutation.

Can you provide an example of mutability in, say, high school or undergraduate math?

I'm not sure what point you're trying to make. You can certainly express those statements in both FP and imperative languages, and you can prove the equivalences you mention in FP languages like Agda, Coq, and F*.

> The Go Core team is likely more vested in the overall success of the language than the rest of Google.

I think you could say that about most teams at most companies. That doesn't mean that they have any autonomy whatsoever from their company, though.

> There is no meaningful sense in which Google, apart from the core Go team, makes decisions about the language.

That's like saying that there's no meaningful sense in which I, apart from my brain and nervous system, make decisions about what my body does.

I don’t find this persuasive at all. Over-population of humans on this planet is the root cause of the impending climate disaster. Jamming more people into cities is just going to fuel the population explosion. I think we have to find a way to reduce the population to a sustainable level.

My Ivy League school wasn’t anything like this.

I love SQL, but I strongly agree with this. It would be great to have a platform-specific low-level API for performance-critical queries. (Much like “unsafe” code in a managed programming language.)

The code snippet doesn't make sense to me:

    a = 1/(1+7)
    b = 2*a+sqrt(a)
    c = atan(b)/(1+c)
    return c+2*d

Note that the assignment to 'c' depends on it already having a value?

I don’t see anything in the linked article that supports your conclusion.

> Souls can be an emergent phenomenon out of certain kinds of complexity like consciousness.

This is the one I like. If you have a self, then you have a soul.

As a layman, the word "tensor" always intimidated me. As a programmer, I was surprised then when I found out that a tensor is just a multi-dimensional array (where the number of dimensions can be as small as 0). That was a concept I was already quite comfortable with.