Hacker Newsnew | past | comments | ask | show | jobs | submit | aewens's commentslogin



I think Raymond Hettinger is called out specially here because he did a well known talk called [Modern Dictionaries](https://youtu.be/p33CVV29OG8) where around 32:00 to 35:00 in he makes the quip about how younger developers think they need new data structures to handle new problems, but eventually just end up recreating / rediscovering solutions from the 1960s.

“What has been is what will be, and what has been done is what will be done; there is nothing new under the sun.”


Since that time HAMT was invented and successfully used in Scala and Clojure, so this talk didn't age well.


Wikipedia (https://en.wikipedia.org/wiki/Hash_array_mapped_trie) links to the paper describing HAMT (https://infoscience.epfl.ch/server/api/core/bitstreams/f66a3...) and claims that is from 2000. That talk is from 2016.


Do you know of any implementation, that is well annotated/commented, so that it is easy to understand?


HAMT weren't immutable/persistent until Clojure though: https://en.wikipedia.org/wiki/Persistent_data_structure#Pers...

Still well before the talk.


I think he was always reluctant to add features, and his version of Python would be slimmer, beautiful, and maybe 'finished'. His voice is definitely not guiding the contemporary Python development, which is more expansionist in terms of features.


You may be thinking of the `frozenset()` built in or the third party Python module [frozendict](https://pypi.org/project/frozendict/)?

Personally, I’ve been using a wrapper around `collections.namedtuple` as an underlying data structure to create frozen dictionaries when I’ve needed something like that for a project.


When you are making str -> Any dictionaries it's quite likely you're better off with dataclasses or namedtuples anyway.


That works if you're dealing with a known set of keys (i.e. what most statically-typed languages would call a struct). It falls down if you need something where the keys are unknowable until runtime, like a lookup table.

I do like dataclasses, though. I find them sneaking into my code more and more as time goes on. Having a declared set of properties is really useful, and it doesn't hurt either that they're syntactically nicer to use.


The way Git computes diffs is by more or less storing all the source code in the .git directory as objects. At first glance it looks like a bunch of hashes, but tools can pull out source code from the objects tracked within the .git directory. Not least of which, the remote URL points to their username on GitHub and the author for commits can give you their email.


Not least of which, and even more so the URL had an auth secret in it. None of mine do, hence the question. I'm confused, because git has a credentials helper specifically designed to avoid storing secrets like that, or so I thought. So what tool is storing secrets in the git remote URL?

Yes, the git directory has all current and historical versions of the files packed into it, but that's not what the OP used to get information about the scammer.


I think you misread the question.


Sounds reminiscent of SCP-079: https://scp-wiki.wikidot.com/scp-079


Lossy compression vs lossless compression is the difference of whether you can get a 1:1 copy of the original data if you compress and then decompress it.

A simple example of this is if you have 4 bits of data and have a compression algorithm that turns it into 2 bits of data. If your dataset only contains 0000, 0011, 1100, and 1111; then this can technically be considered lossless compression because we can always reconstruct the exact original data (e.g. 0011 compresses to 01 and can decompress back to 0011, 1100 compresses to 10 and can decompress back to 1100, etc). However, if our dataset later included 1101 and got compressed to 10, this is now “lossy” because it would decompress to 1100, that last bit was “lost”.

An LLM is lossy compression because it lacks the capacity to 1:1 replicate all its input data 100% of the time. It can get quite close in some cases, sure, but it is not perfect every time. So it is considered “lossy”.


Probably since you can embed it in other languages quite trivially. For instance, in C after about a dozen lines of code you can now pass around data into Lua and back to C and thus give you access to a scripting language with little fuss. It’s also a fairly small and simple language, so adding it in won’t add much more to the overall footprint of the project.


Interesting, thanks!


To play the devil's advocate:

IANAL, but if I recall correctly part of having a trademark is having a legal obligation to enforce it, and if I'm reading the tweet correctly this is a name of a company and typically one cannot use a trademark in their company name.


(I am not a lawyer, I am speculating)

Oracle can grant others the use of their trademark legally, right? There's no reason Oracle couldn't say this?

> JavaScript is our trademark, you must either stop using it immediately OR <sign this online form here> to enter into an agreement with us that grants you the ability to use it, for as long as you please, no strings attached, no payment required.


> Oracle can grant others the use of their trademark legally, right? There's no reason Oracle couldn't say this?

Correct, with certain limitation[1]. This fact is why saying "but we have to do this or lose our trademark" is a bit disingenuous. You do have to actively defend your trademark or lose it (because a trademark is not intended to benefit the company holding it, it's intended as a consumer protection measure). But "defending your trademark" doesn't mean you have to engage in a lawsuit.

[1] The limitations are around the purpose of trademark as consumer protection measure. The idea is that consumers can rely on the trademark as a guarantee that a product or service is coming from who they think it's coming from. It's possible to be so liberal in licensing the use of your trademark out that it gets diluted enough to risk losing the registration.


An analogy may help, imagine the website as a door. A website using HTTP is a normal door and using HTTPS is a door with a lock, where the keyring in this analogy are the trusted CAs by your browser. A website using HTTPS with an expired certificate is a door that should have a lock, but the lock no longer latches; and a self-signed certificate is a locked door with a key left in the doorknob.

From a security perspective, a door without a lock has no expectation of protecting anything. But a door that should lock but doesn’t, or is supposed to be locked but has the key left in the latch is not providing the security expected, and should be given pause when anticipating security from the lock. This is what the browser is trying to translate with its UI.


That makes sense in theory, but you need to think about how the average user is going to perceive these UI choices: we're posting smaller warning for less-safe things. Put another way, the average user is going to be much more concerned about using a website with an expired certificate than a website that has no protection at all.

Put a third way: to the average user, a website behind an SSL-stripping MITM proxy is going to look more trustworthy than a website that forgot to renew their cert.


Skimming over the contents of the "About" page linked in the navigation at the top of the blog, it looks to answer most of your questions ;)

https://glorifiedgluer.com/about

The OP appears to be student and software engineer that is employed writing F# and Nix, and made the blog purely as an outlet to document the things they are interested in (and good on them that).


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: