1,206 karma · joined June 6, 2019
I also found this reading list [1] a great reference.
[0] http://highscalability.com
[1] https://www.the-paper-trail.org/post/2014-08-09-distributed-...
Ah no, he is simply hosting the review. From the top of the page:
> These are archived from the now defunct su3su2u1 tumblr. Since there was some controversy over su3su2u1's identity, I'll note that I am not su3su2u1 and that hosting this material is neither an endorsement nor a sign of agreement.
I'm not aware of any drama beyond this. The review has some good points though.
And an interesting sequel: https://www.fanfiction.net/s/11174940/1/Significant-Digits
> I wonder if part of this has to do with the fact that Rust seems to appeal to a certain type of programmer who is attracted to esoteric topics and arcane knowledge
I find this an unfair take, especially having been a witness to the design process in Rust, where a lot of emphasis and effort is put into coming up with designs that have the right complexity-usefulness balance.
A better way to put it is that Rust matches the values that I care about in a programming language [0][1]. What I love about Rust is that I can rely on it to point out a wider class of mistakes that I'd often make in other languages. Forgetting to deallocate a pointer (C/C++) or using multiple objects when trying to run a synchronized code (Java) often need non-trivial time to debug that ultimately don't teach me anything other than to be more careful. In Rust, I can offload that cognitive load to the compiler. And I find that delightful and satisfying. If it compiled, it is highly likely to be correct, moreso after a refactoring session spanning the entire project. And all this makes the effort in learning whatever complexity Rust has worth it. And I say this with the knowledge that the Rust team is doing their best to address the complexity concerns seriously.
> what a programming language would look like which has an ownership system like Rust, algebraic types, and a trait system, but puts a ruthless emphasis on productivity and eschewing complexity.
Do give this a try. It is likely that you'll have to make different tradeoffs. Or you'll discover novel ideas. Either ways, it'll be a learning experience.
[0] https://www.slideshare.net/bcantrill/platform-values-rust-an... [1] https://www.infoq.com/presentations/rust-tradeoffs/
I don't think this will work well in practice. For example, would you want to declare a new variable every time an array is reallocated at a new memory location?
Reusing variables has both ergonomic (don't have to think about and manage new names) and conceptual (x may represent the same "thing", e.g., a reallocated array) values.
And in this particular case, the compiler will very helpfully tell you what went wrong, so it's not like a programmer will have to hunt down the bug for hours trying to understand what happened. The programmer has to learn this once. Can we then call this a complexity issue then?
Great line of thinking. But I think the idea of earning income from a creative work throughout one's life also has value.
A compromise is to retain the existing copyright periods (after which works go to the public domain),but after 5-10 years of creation, works would become free for non commercial distribution. So Netflix would still have to pay for movies in their catalog. But me torrenting it from people freely sharing it and playing it on VLC would be legal.
I just finished watching Manolis Kellis explain [0] how computational biology is transforming our understanding of the human genome and changing how we treat diseases. Who will argue that this is not a gripping story of how humanity has risen in it's ability to understand how the world works and consequently to control it. This exciting adventure has both passion in the seekers and beauty in what they have found. And of course there are endless songs (e.g., [1][2]) already written about this noble pursuit.
[0] "Decoding a Genomic Revolution: Manolis Kellis at TEDxCambridge" https://www.youtube.com/watch?v=zlVZ0ORtpPM [1] "The Molecular Shape of You (Ed Sheeran Parody)" https://www.youtube.com/watch?v=f8FAJXPBdOg [2] "A Capella Science - Rolling in the Higgs (Adele Parody)" https://www.youtube.com/watch?v=VtItBX1l1VY
Confirmation bias also explains a lot. I remember seeing many anecdotes about Trump before the 2016 election that felt quite possibly true but turned out to be false on further investigation. As if the true things were not exciting enough.
Moreover, I suspect that much of our perceptions, esp. on topics that we don't directly seek out, are based on just glancing at the continuous stream of clickbaity article titles that cross our feeds everyday without even clicking them. In isolation, they'd be harmless, but if the same articles appears across HN, FB, and Twitter, they make a mental impact. And these half-digested impressions then color our opinions when those topics come up in debate or discussions.
However, "that's true of any type system" just feels dismissive of the current state of the world. The comment you were replying to was pointing out that at present, enabling strict type checking in Python, that has been bolted on as an add-on only recently, will not be able to provide benefits to the same level as the ones in Java and Rust where types are front and center. That might become true tomorrow when all Python libraries have adopted types. Hypothetically, tomorrow the Rust community could also decide to adopt Any as the central type everyone uses. But today, the state of the world is very different. Python is still known as a dynamically typed language where devs can essentially forget explicit types, and Rust is a strongly statically typed language where devs will rarely have to worry about missing types.
My take is that there is value in putting in deliberate effort to remember the key takeaways from our readings or talks we've listened to (among other things), as the original comment pointed out. The blog post is then on how to go about doing it.
I think the key difference between the annotations in Python and types in Java, or even more strongly in languages like Rust and Haskell, is how they are used in the language ecosystem. In Java and Rust, the types are cental to how programmers think in those languages. A large part of the dev cycle goes into ensuring the types are consistent. In python, these type annotations are a relatively recent addition that the community has not completely adopted yet. A lot of real-world python code will have no types, thus the (3rd party) python type checkers will fail to ensure the benefits of having strong consistent types.
And how can we then justify "types" like Object in Java or Any in Rust? Well, sometimes we do want to write code where we want to tell the compiler to stop checking types. However, these are more of an escape hatch rather than a central part of the language ecosystem. As someone else already pointed out, the Java or Rust community does not go about writing code with only Object or Any, even though they can in principle. But in python, that's what the community has been doing till now.
It goes the other way too. If the python community starts taking the type annotations seriously, it will start approaching the same usefulness as in these other static languages with good type systems. Then we can start expecting that the 3rd party library type annotations being accurate, which started this discussion in the first place.
Basically, automatically giving options to the users based on access to data they should already have. Detecting the car is not even needed, just scan the driver license at a terminal and get going.
DMV does not need to have direct access to your bank account, but can simply hand off the total to your banking app (say), which in turn can then offer the easy payment plan. Some credit cards already offer this option today.
In general, life can be made quite simple with technology without also having to give up choices or privacy. The hard part is convincing the tech companies/govt IT bureaucracy to go this way :)
`var list = new ArrayList<String>();` [1]
The compiler figures out the type of `list` without "annotations". Same with C++'s `auto` and Rust's `let`.
I think this is super important on any social website that has reached certain level of popularity (Twitter, Quora, FB). Without curation, there is just too much content to wade through between reaching the interesting ones.
Personally, I use Twitter to follow people from CS and tech, and it benefits me a lot. Many times, I get news on Twitter faster than my feed reader, for instance.