GregBuchholz

What about the next 3,900 words after the first sentence? (yes, it is that V.I. Arnold https://en.wikipedia.org/wiki/Vladimir_Arnold )

Is there any context where it makes sense to have fractional pixels? Like millipixels, micropixels, nanopixels, etc.? There is of course sub-pixel text rendering; does anyone refer to numerical fractional pixels in that field (333.33 mpx)?

Things That Turbo Pascal is Smaller Than:

https://prog21.dadgum.com/116.html

Looks like fweimer is correct for scheme. I admit to being very surprised. Here is the verbiage from various rXrs:

r3rs, r4rs & r5rs (section 4.2.6):

https://standards.scheme.org/official/r3rs.pdf

https://standards.scheme.org/official/r4rs.pdf

https://conservatory.scheme.org/schemers/Documents/Standards...

"If a comma appears followed immediately by an at- sign (@), then the following expression must evaluate to a list;"

r6rs (section 11.17):

https://standards.scheme.org/official/r6rs.pdf

"If an (unquote-splicing 〈expression〉 . . . ) form appears inside a〈qq template〉, then the〈expression〉s must evaluate to lists;"

r7rs (4.2.8):

https://standards.scheme.org/official/r7rs.pdf

"If a comma appears followed without intervening whitespace by a commercial at-sign (@), then it is an error if the following expression does not evaluate to a list;"

How do you get that to work?

  #lang racket
  (read-syntax-accept-graph #t)
  (let ((a '#0=(0 . #0#)))
    (display (car a)))

...which of course doesn't work, because `(read-syntax-accept-graph)` is a run-time thing, and the circular-list structure is a `read`-time thing.

I couldn't figure it out with this either:

https://stackoverflow.com/questions/51942188/read-syntax-for...

...just to make sure I wasn't going crazy, this:

  (let ((a '#0=(0 . #0#)))
    (display (car a)))

...does work as expected with this online scheme interpreter:

https://www.jdoodle.com/execute-scheme-online

Is Prolog bicameral? Because it has a `read` predicate? Is bicameral then just a matter of implementing a `read` function which returns a tree of tokens, which you could implement for C or Python? Which makes bicamerality a property of a library rather than a property of the language?

I tried:

  #lang racket/base
  (let ((a '#0=(0 . #0#)))
    (display (car a)))

...over at

https://onecompiler.com/racket

...and it didn't compile, complaining:

  read-syntax: `#...=` forms not  enabled for `read-syntax` mode

...maybe there is a switch needed to enable it?

It looks like Racket nerfed the shared-structure / "Datum Labels" for circular lists and the like (I see it is still in section 2.4 of r7rs):

  '#0=(0 . #0#)

...and I should have included `#|block comments|#`, datum `#;comments`, and probably `|symbols with spaces|`.

  (let ((|1 + 2| (+ 1 2)))
    (display |1 + 2|))

Also, CRUNCH from Chicken Scheme:

https://wiki.call-cc.org/eggref/6/crunch

Windows has allowed forward slashes for directory separators for a long time. Seems like maybe it started with DOS 2.0.

https://en.wikipedia.org/wiki/Backslash#Filenames

> no special syntax for anything.

    (list '(1. . #\#)
          -5/6+7.s-8i
          `(1 ,@2)
          1@1           ;hmmm, no unquote splicing comma ;-)
          10#           ;surprised?
          (list #i+1 +1i 1+i) ;complicated or complex?
          #e-1e10i     ;Old MacDonald?
          "(* 9 10)" #())

Looks like DDG gets it right (very first link).

https://duckduckgo.com/?q=realsense+"failed+to+recconect"

Here are some of the things I use to increase the range of programs for which I can use vi keybindings:

* vscodevim extension for Vscode

* "set -o vi" in Bash

* Vim Vixen plugin for Firefox

* you can use ctrl-alt-j in gdb. And that might (should?) work in other programs which use GNU Readline to get vi keybindings. The only thing I miss with the vi bindings in bash/readline is "ge/gE" from vim (move backwards to the end of the word).

The pedantic point of the article is that an error in this situation isn't correct. The average is 8e307 and 8e307 is 8e307.

>I have hand placed 01005 parts

Any more details you'd care to share? I was thinking of a project to use some 0402 LEDs in a pattern, and I've been balking at it.

>compared to the modern form of the equations

Are the Geometric Algebra...

    ∇F = μ₀cJ

..and Differential Form...

    dF = 0
    d⋆F = J

...equivalents post-modern?

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

Does anyone have a link to a video of the oil drop tunneling experiment?

https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.10...

(like https://www.youtube.com/watch?v=nmC0ygr08tE)

Chapter 4 of "The Art of Prolog" ("The Computation Model of Logic Programs") is about that very topic. It doesn't go into gory details on how to optimize an interpreter for fast execution, but it does go into enough detail that I was able to create a Prologish interpreter in ~30 lines of Haskell many years ago. Apparently "The Art of Prolog" is a free download now (there is a PDF link on the left side of the page).

A good book to read to get aquainted with these notions is "Meta Math" by Gregory Chaitin. The impatient can jump to chapter 5.

https://arxiv.org/abs/math/0404335

...since you have been interested in the matrix form of sqrt(-1), I thought you might also be interested in the book I recently came across as well, "The Naked Spinor: A Rewrite of Clifford Algebra".

https://www.amazon.com/Naked-Spinor-Rewrite-Clifford-Algebra...

...I can't recommend it, since I haven't read it yet. But from the introduction it sounds pretty interesting:

"Some ten years ago, your author stubled upon a change in the notation we use to write complex numbers. Instead of writing a complex number as a+ib, your author began to write a complex number as a 2x2 matrix. From nothing more than this change of notation, your author discovered the higher dimensional complex numbers. The higher dimensional complex numbers include the whole of Cliffor algebra and, with that, the whole of spinor theory. The change of notation simplifies and generalizes Clifford algebra and spinor theory."

Sorry for derailing your GitHub thread with an off-topic comment.

What is so special about transistors? There are many non-linear active devices that are relatively unexplored due to the local maximum of transistors. How about homemade flame triodes or magnetic amplifiers or memristor.. I think you are going to love these guys:

http://www.sparkbangbuzz.com/

http://ludens.cl/Electron/Electron.html

Yes, that looks to be exactly the type of thing I'm thinking of. Thanks.

That sounds like the traditional method of learning math. I was wondering if we could leverage technology and our experiences with teaching/learning the formal systems of programming languages to make more math more accessable. For instance, I'm thinking this little instance of geometric algebra:

http://www.shapeoperator.com/2016/12/12/sunset-geometry/

...might be easier for me to understand if I could use Haskell to implement the wedge and geometric product operators on an algebraic data type describing the scalar/vector/bi-vector thingy. There is probably an applied vs. pure thing here as well. My motivations for investigating geometric algebra is to see if geometric algebra makes synthesizing mechanical linkages easier, whereas maybe most expositions on geometric algebra are focused on teaching geometric algebra to advance the state of geometric algebra. That's probably a long winded way of saying that mathematicans are writing for mathematicians (whether by design or accident). I suppose I should re-read Mindstorms again, but this time in the context of adult learning.

I also what a running commentary would do for authors. Would they get ideas for improving their next paper, by looking at what had people confused? Surprised by who is reading their papers (especially those outside of their field)? Would they merely be horrified by YouTube style commenters?

>learning math is just really, really hard.

I'll accept the premise, but I still wonder if there are things that can be done to make it easier for someone. In my case, I've been trying to learn some more mathematics recently, and one of the most annoying things is coming across notation that isn't defined in a paper, presumably because "everyone" who can read the paper is familiar with the context and knows what the "skinny long arrow" means (good luck with that internet search). I wonder if there could be a wiki-like / forum / stackoverflowish site, which people could use to discuss and provide running commentary on a paper/book. Especially useful would be the ability for people to be able to annotate the paper by translating the formulas in to a formal language where you could track down the definition of the various operators, and try to figure out why the author used both of → and ↦ in the paper, when they both appear to be for functions/maps. (Just to preempt the easy objections, I'm not trying to suggest that each paper be formalized and proven in something like Isabelle/Coq).

In the ideal form, this website would allow you to see the paper or book page in question, and then see all the people who commented or had questions on each particular sentence (in the margin?). There could be filtering and voting so that experts could bypass the newbie commentary, etc..

I suppose part of my problem would be solved by getting a book like:

https://www.amazon.com/Mathematical-Notation-Guide-Engineers...

...(which I just came across when composing this message).

Maybe someone has a other suggestions for something like this? Maybe a site similar to this already exists?

And on a slightly related note to making things easier to learn, I think learning programming is much easier than math, because even though both are abstract, at least with programming you get a tangible, concrete thing (the program) that you can run and modify and extend, and the computer will tell you when you went wrong (e.g. won't compile, output result is unexpected, etc.).

You can run a Stirling engine on much lower temperature differentials:

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

https://www.amazon.com/Three-Stirling-Engines-Without-Machin...

Seconded. I've only just started it, but it really resonates with me so far. It is about how to better use time / avoid distraction.

>I suggest teaching vectors before trig. You can get the cosine and sine from the dot and cross products.

What about geometric algebra instead?

http://www.shapeoperator.com/2016/12/12/sunset-geometry/

Your mention of deliberate practice prompted me reinvestigate the guy who was doing the 10,000 hours of deliberate practice to become a golf pro. Unfortunately, from what I can tell, he did get to 10,000 hours, but it doesn't seem like it panned out. Anyone have further sources of information?

http://thedanplan.com/

https://en.wikipedia.org/wiki/Dan_McLaughlin_(golfer)

Anyone have a comparison to the "Code the Matrix" book and lectures?

http://codingthematrix.com/

https://cs.brown.edu/video/channels/coding-matrix-fall-2014/