Code Words

Interesting but for me reading the article left more questions than it answered. If you are curious about the internals, the referenced blogpost[1] has a detailed explanation of object file reperesentation(s) and I cannot recommend it enough. [1] https://codewords.recurse.com/issues/three/unpacking-git-packfiles

I have written a small python library to read info directly from the .git folder (without using the git executable): https://github.com/spapas/python-git-info/ Decoding the pack files was notoriously difficult, probably there are still cases that I don't handle properly. The packfile is a really complex/messy format and in the top of that it lacks any proper documentation! This article explains a lot of the concepts very good but doesn't go into implementation details (where the big snakes are). Another great resource for unpacking packfiles is this post: https://codewords.recurse.com/issues/three/unpacking-git-packfiles and of course reading the source code of other git clients. Unfortunately it seems that the official packfile format documentation is the git source code :|

The thing that made git click for me was to understand the data structures that make git work. There's beauty and elegance in the implementation details of git. You can do and undo with confidence once you can translate the changes you want to make to git object transformations. To get an overview of the concepts behind git I recommend this article by one of the GitHub founders: http://tom.preston-werner.com/2009/05/19/the-git-parable.html To understand the data structures I suggest: https://codewords.recurse.com/issues/two/git-from-the-inside-out

It's definitely fun: you can also take part of the challenge to be figuring out what parts of the full language are worth adding to make the overall job easier (so you're not taking the language subset as set in stone). When I did this for Python I started out in unrestricted Python, gradually both increasing what's implemented and reducing what's used. (Result at https://codewords.recurse.com/issues/seven/dragon-taming-with-tailbite…

I like the Recurse center codewords publication https://codewords.recurse.com/

Likewise, the followup post: https://codewords.recurse.com/issues/three/unpacking-git-packfiles/ And the corresponding HN discussion: https://news.ycombinator.com/item?id=9773714

First of all, I'm sure the author knows more about git than I do, so I don't wanna come across as trying to lecture an expert. But I do feel that his main point misses the mark. It seems to be centered around the idea that a lot of reasonable people are surprised by things git won't let them do (or, more accurately, strongly advices against doing). The problem is that most of these things are only "reasonable" from the point of view of someone who hasn't thoroughly thought through what a DVCS has to do. A lot of the "reasonable" questions are raised from the point of view of "this is a tool for sharing changes to code". But that is just a nice side-effect of what a DVCS aims to do – it is not the goal. I too have had to clean up git mistakes of collaborators for years, almost all of them rooted in a misunderstanding of what git does, or carelessness (amplified by git's arguably less-than-stellar naming conventions). But is there really any chance that any DVCS will be "easy" (or "not too hard") for someone who hasn't thought about and internalized what the goal of a DVCS is? It seems a bit like a person who only ever spreads butter complaining that knives are needlessly sharp. PS: My greatest success rate at converting people from "just hammer git commands until my code is on GitHub" to actually understanding what problem git tries to solve, and how to interact with it, has been from Mary Cook's wonderful Git from the inside out…

> but you now think the algorithms that might get you okay results on Kaggle competitions can be used to predict a child's future crimes Do you think anything can be used to predict crimes? Can you imagine any fair application of justice that doesn't boil down to an algorithm? Sentencing guidelines are an algorithm. It's literally a table on page 3[0]. Do you think sentencing guidelines, which were invented to address unfairness in the justice system like this guy's work was, are unfair? What alternative do you propose? Case-by-case judgements? Even if you could find me a model judge, be honest: the judge probably uses something that boils down to an algorithm to be just. > brilliant proxy for race Suppose we only used variables with a low correlation to race. Or we decorrelate them from race somehow. Suppose error on the validation set increased. Would this be sufficient to make this system more just to you? Would a reasonable person think it is more just? > Specific ML systems ("deep") can infer hidden variables such as race Considering how scientific you are trying to be about your understanding of ML, you're being dishonest about how much ML systems can "infer hidden variables." There's strictly anecdotal evidence of "deep"ness inferring something hidden. We think GoogLeNet is seeing higher-order features, but then we show it a picture of a cat and it thinks it's looking at a paper towel.[1] You're overstating the power of these systems to serve your point,…

git stores files as objects, which are stored as full copies, unless those objects are stored in packfiles and are deltified, in which case they're stored as deltas. https://codewords.recurse.com/issues/three/unpacking-git-packfiles

Since the cardinalities match the algebra, it's no surprise that identities translate, but seeing them still brings a smile to my face. The correspondence can be pushed much further - to differentiation! https://codewords.recurse.com/issues/three/algebra-and-calculus-of-alg…

Cf https://codewords.recurse.com/issues/seven/dragon-taming-with-tailbite… , a python->bytecode compiler that can compile itself.

And you can use this algebra to refactor data types! It's a surprisingly deep topic. I wrote a blog post about it: https://justinpombrio.net/2021/03/11/algebra-and-data-types.html And someone else wrote a related blog post: https://codewords.recurse.com/issues/three/algebra-and-calculus-of-alg…

Some related links (specifically that they perform "high school" algebra on types): - Seven trees in one [0], a paper showing a bijection between binary trees and seven-tuples of binary trees. - The algebra of algebraic data types [1] discusses Taylor expansions of data types. - Differentiation of higher-order types [2] is commenting on OP's paper. I used to be really interested in type theory, but haven't had as much time to explore it, but over the years I've saved these links (and the one posted). [0]: https://arxiv.org/pdf/math/9405205.pdf [1]: https://codewords.recurse.com/issues/three/algebra-and-calculus-of-alg… [2]: http://conal.net/blog/posts/differentiation-of-higher-order-types

This made it click for me: https://codewords.recurse.com/issues/two/git-from-the-inside-out

The news is not actually about git, it is about GitHub. Maybe they should make it more explicit in the title. Git still supports password authentication, as well as many other protocols. GitHub chose to restrict which protocols and authentication schemes are allowed on its platform. But obviously, learning about the tools you are using is always a good idea. My preferred "tutorial" is this one: https://codewords.recurse.com/issues/two/git-from-the-inside-out It is more advanced than the usual introductions but it demystifies most of the git concepts.

Immutability changes everything but does not Solves Everything. You are just changing to a different scenario that might help. "Tesler's Law" [1] :-) makes sure you are looking from a different perspective. Complexity is still present. "Immutability is not enough" https://codewords.recurse.com/issues/six/immutability-is-not-enough [1] - "Tesler's Law" https://en.wikipedia.org/wiki/Law_of_conservation_of_complexity

So in this case the connection to algebraic data types is that they provide static type checking for unions as well as structs in C along with type introspection which is novel. The linked article explaining the whys and wherefores of ADTs (https://codewords.recurse.com/issues/three/algebra-and-calculus-of-alg… has hit the front page of HN twice now!

funny how these same words came to many https://codewords.recurse.com/issues/two/git-from-the-inside-out

>Git from the Inside Out https://github.com/git/git https://www.aosabook.org/en/git.html https://codewords.recurse.com/issues/two/git-from-the-inside-out http://gitimmersion.com/

While I don't know the history of the term "algebraic data type", I do know that the algebraic structure of ADTs is much deeper than what this article presented. For instance this structure supports some limited notion of a derivative[1]! And purely algebraic manipulation of ADT "equations" can actually be used to generate some non-obvious results [2]. So I think it's probably wrong to say that ADTs were just "given a name that sounds mathematical". 1. https://codewords.recurse.com/issues/three/algebra-and-calculus-of-alg… 2. http://www.math.lsa.umich.edu/~ablass/7trees.pdf

I am also taking a guess: https://codewords.recurse.com/issues/two/git-from-the-inside-out

More on this, for the curious: https://codewords.recurse.com/issues/three/algebra-and-calculus-of-alg…

This would be more useful and more upvoteable if you had provided some text for context. TLDR: If you interpret sum types as + and product types (tuples/structs/objects) as *, type definitions can be read as polynomials. Recursive type definitions, like for linked lists, can be read as recurrence equations. If you do some calculus over these things and compute the derivative of these type formulas, you get back something meaningful: The formula corresponding to the type's Zipper (https://en.wikipedia.org/wiki/Zipper_(data_structure)), a data structure for efficiently traversing and modifying functional data structures. I like Chris Taylor's series of posts on this topic, as well as this shorter one: https://codewords.recurse.com/issues/three/algebra-and-calculus-of-alg…

There's also this take on differentiating datatypes: https://codewords.recurse.com/issues/three/algebra-and-calculus-of-alg… Reading this makes a lot of the operations in colah's article feel more intuitive. (To me, at least. I'm no expert here.)

See https://codewords.recurse.com/issues/one/type-systems-and-logic for a pretty elaborate response to this question. tl;dr: types are propositions and values are proofs of those propositions. Constructive logic is not concerned with (true xor false), but rather "I can prove A" or "I can prove not-A". There's also the middle ground of "I don't know how to prove anything about A".

Julia Evans: How to trick a neural network into thinking a panda is a vulture https://codewords.recurse.com/issues/five/why-do-neural-networks-think…

For a good deep-dive, I found this one very helpful: https://codewords.recurse.com/issues/two/git-from-the-inside-out Discussion: https://news.ycombinator.com/item?id=12802949

It may look surprisingly similar: https://codewords.recurse.com/issues/five/why-do-neural-networks-think…

One problem with training a neural network end-to-end this way is that the system is susceptible to unpredictable glitches: The same principle that lets people trick a NN into [thinking a panda is a vulture](https://codewords.recurse.com/issues/five/why-do-neural-networks-think… can happen randomly just by differing lighting/shadow conditions, sun glare, or who knows. One can always train the network with more and more scenarios, but how do you know when to stop? How good is good enough in this regard?

I feel this one is more well-written and complete: https://codewords.recurse.com/issues/two/git-from-the-inside-out