[1] New whitehouse/government employees are being asked when their moment of “MAGA revelation” occurred. This. is. not. normal.

[2] Trump is a convicted felon, adulterer, conman, etc...

[3] See his response to many crises in his first term including his initial and continued denial of Covid

Apple also works with competing terrestrial cellular network companies.

It's also a USP for Apple in the mobile market right now.

Globalstar is entirely abstracted away from the consumer. In that manner, it’s similar to TSMC. (Though far less critical.)

Why is this substantial? My understanding is that packages shouldn't be touched once published. It seems likely for any change to not apply retroactively.

I could never get Docker to work on my ADSL when it was 2 Mbps (FTTN got it up to 20) though it was fine in the Montreal office which had gigabit.

You still need to tune it but there are many "center frequencies" that can be tuned instead of just one. So, you wouldn't have to tune far but you would still have to tune :) If you had a knob like most radios in the 80's it would save you from cranking the knob several times to get the dial into the right range before fine-tuning.

Reading up to this point, I had to chuckle a bit. I have struggled with the Haskell type system more than I care to admit; It's almost never "we just don't have to care" when comparing to most other popular languages.

That being said, this article does a nice job of gently introducing some of the basics that will trip up somebody who is casually looking through code wondering what *> and <*> and <* do. As usual, there is a steep learning curve because of stuff like this all over the codebase. If I walk away for a month, I need to revisit >>= vs >> and other common operators before I can be productive. It probably doesn't help that I never actually speak to a human about these concepts so in my head it's always ">>=" and not "bind."

But I like <|> , it feels very clear that it has a sort of "or" meaning.

thing <- getThing

case thing of

writing this:

getThing >>= \case

Not so much because it is less code, but fewer variables to name.

The difference here seems to be that \case is a lambda?

Haskell’s >>= is doing something slightly different. ‘getThing >>= \case…’ means roughly ‘perform the action getThing, then match the result and perform the matched branch’

Whereas ‘getThing |> \case…’ means ‘pattern match on the action getThing, and return the matched action (without performing it).

The >>= operator can also be used for anything satisfying the Monad laws, e.g. your actions can be non-deterministic.

Interesting! I thought Elixir was mostly macros all the way down, like this article shows:

https://evuez.net/posts/cursed-elixir.html

Being able to pipe into def, defp, defmodule, if, etc. is fantastic! But apparently you say at least in the case of case, it's not a macro, and it's just a function which returns a monad—I guess it's the same effect afterall? Is that why people say Haskell can get away with lack of Lisp-style macros because of its type system and laziness?

Interesting. Probably it's just me, but I first learned monads using >>= (in OCaml), so at the beginning I found the Haskell do notation more confusing (and indentation rules didn't help). >>= is just a function and I understand its signature well. On the other hand, "do" is a syntactic sugar that I sometimes had to "mentally desugar" in some cases.

Struggling with Haskell type system is not an experience of somebody who has developed an intuition about Haskell type system. Granted, it is not a binary thing, you can have good intuition about some parts of it and struggle with others.

I think they way you put it is, while technically true, not fair. Those "most other" languages are very similar to one another. It is not C# achievement, that you don't struggle with its type system coming from Java.

This is like people struggling with Rust because of burrow checker, well, they have probably never programmed with burrow checker before.

FYI it's "borrow" (as in when someone lends something to you) not "burrow" (which is a tunnel/hole)

I think use makes master: the more you use it, the more mastery you will have and the better intuition will follow.

Given how many important projects maintained by smart people have dealt with bugs that safe Rust makes impossible, I'm inclined to doubt that.

But it shifts the need to memorize undefined behavior with the need to memorize the borrow checker rules.

If you are dealing with common system level needs like double linked lists, rust adds back in the need for that super human level memory of undefined behavior, because the borrow checker is limited to what static analysis can do.

IMHO, the best thing Rust could do right now is more clearly communicate those core limitations, and help build tools that help mitigate those problems.

Probably just my opinion, and I am not suggesting it is superior, but zig style length as part of the type is what would mitigate most of what is problematic with C/C++

Basically a char myArray[10];, really being *myArray is the main problem.

Obviously the borrow checker removes that problem, but not once you need deques treeps etc...

If I could use Rust as my only or primary language, memorizing the borrow checker rules wouldn't be that bad.

But it becomes problematic for people who need to be polyglots, in a way that even Haskell doesn't.

I really think there's ways for Rust to grow into a larger role.

But at this point it seems that even mentioning the limits is forbidden and people end up trying to invert interface contracts, and leak implementation details when they're existing systems are incompatible with the projects dogma.

It is great that they suggest limiting the size of unsafe code blocks etc....but the entire world cannot bend to decisions that ignores the real world nuances of real systems.

Rust needs to grow into a language that can adjust to very real needs without and many real needs will never fit into what static analysis can do.

Heck C would be safer if that was the real world.

I really do hope that the project grows into the role, but the amount of 'unsafe' blocks points to them not being there today, despite the spin.

With one massive difference: the borrow checker will tell you when you're wrong at compile time. Undefined behaviour will make your program compile and it will look like your program is fine until it's not.

I'd take that trade.

You have a choice: Fight the borrow checker on the front end until your code compiles, or chase down bugs on the back end from undefined behavior and other safety problems. No single answer there, it depends on what you're doing.

Cognitive load is a big issue. In Rust I find this comes in a couple of phases, the first being figuring out what the borrow checker does and how to appease it. The second is figuring out how to structure your data to avoid overusing clone() and unsafe blocks. It's a bit like learning a functional language, where there's a short-term adaptation to the language, then a longer-term adaptation to how you think about solving problems.

You mention doubly-linked lists, which are a good example of a "non-star" data structure that doesn't nicely fit Rust's model. But: for how many problems is this the ideal data structure, really? They're horrible for memory locality. Those of us who learned from K&R cut our teeth on linked lists but for the last 20 years almost every problem I've seen has a better option.

rust-analyzer is the tool that does this. Having it flag errors in my editor as I write code keeps me from getting too far down the wrong road. The moment I do something Rust thinks is goofy, I get a red underline and I can pause to consider my options at that moment.

To give an example, you use `>>=` after `readFile` to do something with the contents. You use `>>` after `putStrLn` since `putStrLn` doesn't return a meaningful value.

Yeah, I've noticed there's a lot of virtue signaling form some Europeans, especially amongst the wealthier Germans, Benelux, and Nordics who have this "holier than though" posture on how much better they are than Americans(wide brush stroke here) for being non-materialistic (also copium for their low skilled wages), while coasting on generational wealth inherited from those before them.

Well if you're so non-materialistic, why aren't dropping the prices of your housing so other people can actually afford to buy something instead of hoping to profiteer from them like those "greedy" Americans?

As always, the people lecturing you on how money doesn't matter, are those who already have money.

Just like those Germans laughing at Trump when he warned them about Germany's dependence on Russian energy in 2018. [1] They can be so smug and full of themselves sometimes.

[1] https://www.youtube.com/watch?v=eKEycjREgPE

This is largely due to the use of groovy. When the Kotlin DSL is used instead, it can usually be introspected by (eg) IntelliJ. Otherwise, it’s pretty opaque.

    configure<SourceSetContainer> {
      named("main") {
        java.srcDir("src/core/java")
      }
    }

Also, groovy allows modification of private instance variables which leads to … un-fun situations. I converted tens of thousands of lines of groovy to Kotlin. A lot of those lines were automated. Too many were not automatable for myriad reasons.

As far as the magic in Kotlin, I can easily click through all keywords and jump to the implementation in IJ. Groovy (at the time and in the project I was in) was utterly hopeless in this regard.

For all of the “but I have nothing to hide” crowd, you need to modify your slogan to, “but I have nothing to hide, right now.”

Any else that I've missed?

Seriously, though, what would the HIPAA violation be for location data? Knowledge of someone going to a doctor's office doesn't sound like a HIPAA violation. AFAIK, violations only relate to what is communicated between doctors (and other healthcare professionals) and patients.

The web page below has quite some discussion on what this means for patient privacy and how to disable certain location services on your phone.

[1] https://www.hhs.gov/hipaa/for-professionals/privacy/guidance...)

I ask because we barely understand our own star, the Sun. We know it has solar minima/maxima and we still track sunspots as a primary means of qualifying how we think it will affect us. We are still sending probes to get closer looks at the surface which is extremely dynamic.

In terms of physical processes and energy production, the sun is immensely complex in its own right, but it doesn't exhibit the same kind of dynamic, adaptive behavior that we associate with life.

So while obviously we can't say for sure, I stand by my original statement when speaking in terms of orders of magnitudes. I think it's a sensible argument.

You can have stars without lead, but you can’t have lead without stars; Lead (the element) is produced by stars but is itself not more complex than a star.