gugagore

To say nothing of "Swift for TensorFlow" when Julialang was an option.

To each their own!

I follow your connection, though I think your unit analogy is a strawman.

Do you want to give two different types to complex numbers, depending on whether a given complex number represents a point versus a transformation (an amplitwist)?

https://math.ucr.edu/home/baez/torsors.html

The distinction is whether zero is meaningful independent of a choice of origin. Zero displacement is meaningful. Zero position is arbitrary.

Are you thinking of displacement as an operation? Because it is just as well a vector. I don't see the connection to section I highlighted from the article.

The part in this that I most question / deviate from is what I've quoted below about having distinctions (syntactically?) between objects and operations. Conceptually, it's a good distinction. But is it so clearly wise to bake in that distinction into the formal framework when doing calculations or proof?

Most of the time we think of complex numbers as vectors in R2 or as rotation+scaling operators, but rarely do we actually we want them in both roles at the same time. So it is not very natural to equate the two objects, as opposed to finding a correspondence between them.

So GA ends up being very stuck because it equates “vectorial objects” and “operators that act on vectorial objects”. It would be better to express all the geometric objects you care about in their most natural forms, and then find isomorphisms between them when it’s necessary to do so. Otherwise all the meanings get blurred together and it’s very confusing. So that’s another problem with geometric algebra: eliding the distinction between vectors and operators is undesirable, confusing, and disingenuous.

People are jumping on it being an important file to review. You don't want to ignore the diff.

Even if that's true, you definitely do not want to attempt merge two lock files, and using the .gitattributes file to set the merge strategy is a good idea!

https://en.wikipedia.org/wiki/Floptical

A related technology with a name that already answers your question.

If there is a stack of size n and you make a modification at the first change, closest to the trunk, is there a single git command you can run to rebase the other n-1 branches and ensure they remote branches are updated?

https://en.wikipedia.org/wiki/Mead%E2%80%93Conway_VLSI_chip_...

I'm guessing is what they're really talking about. Which is not about NAND gates.

They are referring to the comment ("You're pointing out a real conceptual issue ..."), not the article.

Have you heard the thought that LLM hallucinations when coding within an API / framework are feature requests against the same?

I have a suspicion that Julia, owing to multiple dispatch, has a sort of regularity that makes that you said plausible.

Though there is just so much more Python to train on, any I bet they even do RL with validated rewards on Python, and probably not Julia.

Woodworking is, like, the quintessential craft. I think it is very useful to bring it in when discussion "craft"!

I am not myself a woodworker, however I have understood that part of what makes it "crafty" is that the woodworker reads grain, adjusts cuts, and accepts that each board is different.

We can try to contrast that to whatever Ikea does with wood and mass production of furniture. I would bet that variation in materials is "noise" that the mass production process is made to "reject" (be insensitive to / be robust to).

But could we imagine an automated woodworking system that takes into account material variation, like wood grain, not in an aggregate sense (like I'm painting Ikea to do), but in an individual sense? That system would be making judgements that are woodworker-like.

The craft lives on. The system is informed by the judgement of the woodworker, and the craftperson enters an apprenticeship role for the automation... perhaps...

Until you can do RL on the outcome of the furniture. But you still need craft in designing the reward function.

Perhaps.

"sound bites pop radio" of 1999 has made a comeback, But worse.

https://en.wikipedia.org/wiki/Subsumption_architecture

For some more depth into the "bloat" of bazel, I like this reference: https://fzakaria.com/2024/02/27/hermetic-but-at-what-cost

Intel's first 32-bit microprocessor was the iAPX 432, which was introduced in 1981, but was not a commercial success. It had an advanced capability-based object-oriented architecture, but poor performance compared to contemporary architectures such as Intel's own 80286 (introduced 1982), which was almost four times as fast on typical benchmark tests.

I know that there was OO hype, but 1981 seems kind of early. I also know that OO means many, many things. What does it mean here, if anything?

Are the 50 for loops truly necessary in the manual C code example of a Kalman filter? At least introduce a few functions (that could be inlined and loop-fused) for some matrix operations?

Another way to make the same point is to observe that every single society has language.

But only some groups have the ability to systematically encode language as writing.

Writing is a technological marvel.

Does anyone have a reference to the original thread or issue about sleep(1)?

The bug being "perturbation confusion"?

This is the first time I see "SGD" to mean "standard gradient descent" and not "stochastic gradient descent".

Please share your understanding!

We're not using "type theory" the same way, I think. I'm thinking in terms of

    - simply typed lambda calculus
    - System F
    - dependent type theory (MLTT)
    - linear types
    - row types
    - and so on

people who like type systems tend to dislike Julia's type system.

This is true. As far as I understand it, there is not a type theory basis for Julia's design (type theory seems to have little to say about subtyping type lattices). Relatedly, another comment mentioned that Julia needs sum types.

I think of context parameters as a replacement for dynamic scoping.

I think it can be all of these things, which in my opinion partially undermines the GP's point.

Recommended related musings: https://wiki.c2.com/?ClosuresAndObjectsAreEquivalent

Also, statefullness. Baudot has two codes used for switching into one of two modes: figures and letters.

Typewriters have some statefullness, too, like "shift lock". Baudot needed to encode the actions of a type writer to control it, not the output.

"A language that doesn't affect the way you think about programming is not worth knowing." ― Alan J. Perlis

A search for "LLM Harry Potter" would suggest that LLMs are widely understood to be proficient at rote memorization.

(I find the example of the computational geometry algorithm being a clear case of direct memorization not very compelling, in any case.)

You don't have to precisely represent the float in decimal. You just have to have each float have a unique decimal representation, which you can guarantee if you include enough digits: 9 for 32-bit floats, and 17 for 64-bit floats.

https://randomascii.wordpress.com/2012/02/11/they-sure-look-...

I think search is a fairly simple control loop. Beam search is an example of TTC in this modern era.

It is a very wide term, IME, that means anything besides "one-shot through the network".

I think the thing about the search formulation, which is amenable to domains like chess and go, but not other domains is critical. If LLMs are coming up with effective search formulation for "open-ended" problems, that would be a big deal. Maybe this is what you're alluding to.

What you're describing — search + NN — is presently under the term "test-time compute".

The rules / dynamics / objectives of chess ( and Go ) are trivial to encode in a search formulation. I personally don't really get what that tells us about AGI.