Polarization itself doesn't bother me. When left-wingers polarize, they split into 50 different Communist parties that hold regular meetings and do nothing. When right-wingers polarize, they fund domestic terrorists like ICE.
I've been getting closer with the Unitarian Universalist church in my town. I'm an atheist and they're the only church in town that's friendly to atheism / humanism.
I miss that about dorm life in college. For 4 years I lived in an arcology with people who were the same age and economic class as me. Since the commute to anyone's place was 1-5 minutes on foot, you could get food, watch a movie, and drop out whenever without worrying about the sunk cost of fucking driving 15 minutes in a car-centric city from one detached SFH to another detached SFH.
Oh my god eat some beans. Eat some tofu, eat some black-eyed peas, eat some green peas, eat some lentils, eat some northern beans, eat some lima beans, eat some chickpeas
Yes it's the burden of proof. That's why writing Rust is harder than C++. Or why Python is easier than anything else. As a user and customer, I'd rather pay more for reliable software though.
n.b. Sorry for the long reply, this is actually a really complex and complicated topic in terms of language design, trade-offs, and empirics.
It's a trade-off in design which is not immediately obvious. If you want to make pointers not have a `nil` state by default, this requires one of two possibilities: requiring the programmer to test every pointer on use, or assume pointers cannot be `nil`. The former is really annoying, and the latter requires something which I did not want to (which you will most likely not agree with just because it doesn't _seem_ like a bad thing from the start): explicit initialization of every value everywhere.
The first option is solved with `Maybe(^T)` in Odin, and that's fine. It's actually rare it is needed in practice, and when it is needed, it's either for documenting foreign code's usage of pointers (i.e. non-Odin code), or it's for things which are not pointers at all (in Odin code).
The second option is a subtle one: it forces a specific style and architectural practices whilst programming. Odin is designed around two things things: to be a C alternative which still feels like C whilst programming and "try to make the zero value useful", and as such, a lot of the constructs in the language and core library which are structured around this. Odin is trying to be a C alternative, and as such it is not trying to change how most C programmers actually program in the first place. This is why you are allowed to declare variables without an explicit initializer, but the difference to that of C is that variables will be zero-initialized by default (you can do `x: T = ---` to make it uninitialized stack memory, so it is an opt-in approach).
Fundamentally this idea of explicit individual-value based initialization everywhere is a viral concept which does lead to what I think are bad architectural decisions in the long run. Compilers are dumb---they cannot do everything for you, especially know the cost of the architectural decisions throughout your code, which requires knowing the intent of your code. When people argue that a lot of the explicit initialization can be "optimized" out, this is only thinking form a local position of individual values, which does total up to being slower in some cases.
To give an example of what I mean, take `make([]Some_Struct, N)`, in Odin, it just zeroes the memory because in some cases, it is literally free (i.e. `mmap` must zero). However, when you need to initialize each value of that slice, you are not turning a O(1) problem into a O(N) problem. And it can get worse if each field in the struct also needs its own form of construction.
But as I said in my original comment, I do not think the `nil` pointer problem, especially in Odin since it has other array constructs, is actually an empirical problem in practice. I know a lot of people want to "prove" things whatever they can at compile-time, but I still have to test a lot of code in the first place, and for this very very specific example, it is a trivial one to catch.
P.S. This "point" has been brought up a lot before, and I do think I need to write an article on the topic explaining my position because it is a bit tiring rewriting the same points out each time.
P.P.S. I also find this "gotcha" people bring up is the most common one because it is _seems_ like an obvious "simple" win, and I'd argue it's the exact opposite of either "simple" and even a "win". Language designing is all about trade-offs and compromises as there is never going to be a perfect language for anyone's problem. Even if you designed the DSL for your task, you'll still have loads of issues, especially with specific semantics (not just syntax).
Can't find a non-paywalled link at the moment but the gist is it's because of phones and the fear of going viral on social media. Some concerts and clubs are now starting to institute phone bans at the door to create a more friendly atmosphere.
This seems a bit odd, you'd have to be dancing like a total loon before you got any viral traction. The vast majority of people already dance just by slightly moving their arms whilst gently shifting their weight from one foot to the other. Surely such people don't think anyone would watch videos of their rather lame perambulations?
Whereas the people who do dance like total loons would only welcome internet fame.
Berlin has banned mobile phones from clubs for pretty much ever, but only to prevent pics of people off their tits causing them trouble at work.
I think the chilling effect of phones is already stark in this way and we haven't hit peak bodycam-style always-on wearables every generation of tech leaders tries. When glassholes are actually here to stay this will be even worse (or maybe it will be so inevitable people won't care anymore?).
Good. I was tired of us acting like we could ignore the blatant act of information being prevented from its freedom by being some caste of monks who knew about the magic words to use the internet archive to avoid it.
