Could you elaborate please? For those of us not familiar with Wittgenstein's work, could you link to sources depicting before and after his views changed, preferably with summaries.
Not at all. In fact, she’s already asked us by the tender age of 6.
I think life is an amazing thing. A miracle. And it’s very special. For all the angst and fear that comes with life, there is so so much beauty. I wanted to share that with a person, a new person who would have the ability to see the world like I do (since we share genes, my hope is some of that comes along with it).
I believe GP is "grandparent", referring to the post that the post you're replying to replied to. As if the reply is a descendent, and you're a descendent of the reply.
Slightly OT, but when you edit code in the REPL this way using conditions/restarts, how do you avoid getting your code out of sync with the REPL's state? It seems with a long-running REPL, you eventually run into:
- Out of order execution means we don't know what order our code should be run in to achieve the current state
- If we run some code in the REPL and never save it in a file, then our state is also out of sync
- Finally, if we redefine some code, there's no way the state can be in sync with the code if started from the beginning
How do Common Lispers typically deal with these issues for a REPL that's been running for days or weeks, short of just saving the image and never turning it off?
As the cousin comment stated, we use sources. Even with this condition/restarts/debugger: fix the error in the source and recompile it, not in the REPL.
And we have the right to restart the image. For example, I run the tests from the terminal, hence from scratch, from time to time, typically before pushing my commits. I have a CI that tests and builds the program. I deploy a static build. We don't use images coming from development here. However, I can connect to a running image in prod and tweak settings if I want, or just look around[]. I could very easily change the code, but I'll do that in my sources and do a clean deploy. Or not. I too heard about people who mold a running image for years, their sources totally out of sync O_o
[]: there's a trading startup that posts screenshots of their Sly REPL from prod, that's where they ask their system for data. They didn't have to setup another complex layer just to see data from prod.
This is true of any image based development, as well. You can get the same thing in Java with hotswapping code, even.
That is to say, this is a bit of a concern, but isn't typically as large of one as you'd think. There are plenty of ways to make it so that you can't reason about a program. In general, you avoid doing those things.
Specifically to your question, I think, the biggest trick is that you rarely use the REPL as where you type your code. For that, you typically still use files and eval the file into the environment controlled by a repl. Even in emacs, you rarely just execute elisp from the scratch buffer. Unless you know it is something you don't care to keep, of course. Instead, you are working with files and evaluate the file on a regular basis.
Worth noting is that stochastic computing devices would make reproducible experiments more difficult. For R&D, that's not a trivial thing to throw away. Indeed, one of JAX's motivations is finer control of pseudo-randomness for reproducibility of experiments.
What are the advantages of GA over regular linear algebra in practice? Can you create better neural nets or faster graph search algorithms? What is the draw, computationally?
The most commonly cited example is cross product -- instead of esoteric rules about "this special type of vector that doesn't really work like a vector", you just make them their own irreducible thing.
This means that "multiplying" apples and oranges is possible by having appapple components, ororange components, and apporange components, and they're just described the same way as you do with distributing multiplication in brackets, so just sum of incomparable objects.
So ultimately, in terms of calculations they fundamentally use the same number of operations. The main advantage is a cohesive framework of Types, rather than arbitrary exceptions defining different product rules. You just have *one* vector product, whose output have all of those as components.
Do you think there's a practical benefit, or is it just more elegant conceptually?
From my limited understanding the idea is that instead of having vectors, quaternions, planes and so forth, these are all represented pretty much the same way. But as a working programmer is there a benefit to that? At the type level I'd definitely like those concepts to be separate.
The concepts may or may not be useful for your aims. One pragmatic benefit could be e.g. you can automatically generate optimally-performant code for different algebraic operations, all just from the spec.
>What are the advantages of GA over regular linear algebra in practice?
It is a unified description of certain kinds of spaces. The greatest conceptual advantage over "regular linear algebra" (the quotes are there because you are still doing regular linear algebra, but with a different spaces and operations than R^n) is that it allows a very nice description of Euclidean space. Where e.g. points and rotations are the same type of object.
I think the best example are complex numbers. Complex numbers are just 2D vectors where multiplication is rotation. (Defining i as the square root of -1 is probably the worst way to think about complex numbers).
The way they are doing it (the right way IMO) is actually as a 2^1 dimensional Vectorspace, with one multiplication (fully described by the product of all basis vectprs with one another) which describes the geometric properties of 2D euclidean space.
The privacy policy / terms is clear that while they don't share data with third parties, they help themselves to the data for their own models. Misleading of them to leave that off in their FAQ. And it's opt-out, not opt-in.
He's swapping billets and claiming the swapped billet is what Simon originally wrote. Simon is amazed because he was just told he would find himself confused, and he is, since the fake billet is written in his handwriting (forged). Which is the simpler explanation, sleight of hand and handwriting forgery, or hypnotic memory implantation spanning several days?
Swapping billets doesn't add up. Derren talked to Simon on the phone with instructions to sign it and make sure no-one steals or switches it, and Simon opens it on camera straight from his wallet. So to switch it someone must have met Simon, and either figured out or pushed the exact same envelope/pen/signature location that Simon used, then went and had someone forge some new note the exact same, and then met Simon _again_ and somehow switched it while somehow Simon is convinced that no one has had access. This also must have happened well before the show since they already had to setup the room with BMX bike.
I mean or he could have just paid Simon, the actor, to act surprised.
