Children ages 3-7 are really just beginning to learn how to think abstractly, which is a pretty core competency for programming. So when you say you want to teach fundamentals of coding, you really aren't even at "coding" yet. You're really at the fundamentals of math, language, reasoning, and problem solving and curious mindsets.

So what are the fundamentals of coding that 3-7 year olds can actually do?

1) Math - I would scour the web for all the different ways you can do basic math with any type of physical object (pencils, fruit, whatever). You may think it's too simple, but if you take a cognitive approach to this, practice must be done at some point with mapping a number of any object to it's linguistic representation in one's mind. Practice counting up/down, sorting stuff into groups and sets, quantity, patterns (2x3, 3x2, are they the same? what's different?) etc, and doing simple arithmetic with actual objects. This is new to them and is fundamental to everything else.

2) Language - have adult conversations with your kids, and no not about adult topics, but with adult words and with adult grammar; no "baby-talk" in other words. And it's not about purposely choosing large and obscure words to obfuscate, but picking accurate words that probably leave little holes in understanding for the child to try and reason about. Hopefully they will ask if they don't know, or may even surmise correctly about word/phrase meaning. This might help with...

3) Reason/problem solving - Encourage experimentation in everything. If they see you constantly trying new things and failing gracefully and focusing more effort on finding solutions then hiding failures, you've taught them one of the most important lessons of all. Try, try, try many times, then go ask someone. You should be unquestionably the expert in some things, and a complete novice that asks questions and learns quickly in other things, and they should watch you in both situations. Seeing role models do both is an immensely powerful thing to observe to young children. It shows that adults can be both powerful professionals and learners. Where do you think they learn to laugh at, criticize, and fear failure? It's cultural. Make failure just another step to mastery.

4) Curious mindsets - in every category above, there are always opportunities to ask "why do you think this is?" or "how do you think this works?". You might get gibberish most of the time but it doesn't matter, they are going through the thought process and will get better with age. They need to be very comfortable with those questions at early ages and keep being willing to answer them. When they stop caring, THAT'S the problem.

So to try and answer your question more concretely, you can buy expensive toys made for programming but I don't see what it will accomplish. LEGOs are the gold standard, but really, every-day objects can do much of the above. Build a fort! Why are we building a fort? How do we do it? Tell me the steps for building a fort so we can do it again someday. How do we improve this fort? Tell me the steps for improving...

I truly think there is something there though, something from the open-source process that can make government more efficient and productive, but it's probably not in the way we are thinking. It probably looks less like software maintenance and more like science, dare I say political science. Crowd-source solutions and organize experiments across counties and states in a way that's data driven, not politics and need-for-reelection driven.

- nightly export to dropbox as plaintext and a backup as a type of json format with more metadata. If Workflowy goes away tomorrow, I have everything and can continue in an editor if I like. But until then, I use the pretty web interface.

- multiple device support. I am not going to mess with ssh on my mobile devices. I use Workflowy for everything from extended note-taking and long-form writing to quick pre-set searches on the go for reference; and that's on all my various interfaces (and sometimes other peoples too).

- Workflowy is easy enough for laypersons to view and/or collaborate in seconds. No setup necessary on their end.

I am a happy paying customer of theirs.

STEM training = literacy for the jobs we have now

Liberal arts training = big picture training for innovation that we have yet to do.

Remember this John Adams quote:

"I must study politics and war that my sons may have liberty to study mathematics and philosophy. My sons ought to study mathematics and philosophy, geography, natural history, naval architecture, navigation, commerce, and agriculture, in order to give their children a right to study painting, poetry, music, architecture, statuary, tapestry, and porcelain."

Education has moved in this direction, but our economy has not innovated alongside it to make work for them.

Or suddenly went proprietary.

It might even happen.

https://mako.cc/copyrighteous/google-has-most-of-my-email-be... https://sfconservancy.org/blog/2015/sep/15/email/

https://common-lisp.net/project/iterate/

Even the ITA/Google style guide says to avoid loop if possible:

https://google.github.io/styleguide/lispguide.xml#Iteration

Almost every macro in Lisp provides syntax.

It's one of the strengths of Lisp imo; that you don't need to think much about how the parser is going to interpret your code (ie. missing semi-colons, whitespace, use curly brace here, square bracket there, etc.), just stick to (func arg1 arg2) and all you're left with is your own logic errors.

    (func arg1 arg2 (func arg3))

But Lisp has a few special forms and zillions of macros. Most of them are syntax.

Lisp has IF. What is the syntax of IF?

    IF form then-form else-form+

    cond {clause}*
    clause::= (test-form form*) 
 

    defun function-name lambda-list [[declaration* | documentation]] form*

    lambda-list::= (var* 
                    [&optional {var | (var [init-form [supplied-p-parameter]])}*] 
                    [&rest var] 
                    [&key {var | ({var | (keyword-name var)} [init-form [supplied-p-parameter]])}* [&allow-other-keys]] 
                    [&aux {var | (var [init-form])}*]) 

> It's one of the strengths of Lisp imo; that you don't need to think much about how the parser is going to interpret your code (ie. missing semi-colons, whitespace, use curly brace here, square bracket there, etc.), just stick to (func arg1 arg2) and all you're left with is your own logic errors.

What you describe is just the data syntax for s-expressions. Not the syntax of the programming language Lisp.

Exactly. The data syntax if what most people worry about. The names of the verbs (funcs/methods/etc.) may change from language to language, but the data syntax is what trips people up. I think Lisp has one of the simplest and clearest. There are very few cases of "oh you can't write that there, only nouns are allowed in that position".

I agree with your point, but I think we're arguing slightly different points here ;)

    (lambda x (+ x x))
    (cond (> x 2) (+ x x))
    (if (> x 2)
        (do-this when-true)
        (also-do-this when-true))

That is to say, a problem with s-expressions is that they are so regular that everything looks the same, and when everything looks the same, it can become an obstacle to learning. Mainstream languages are not very regular, but they are more mnemonic. I think Lisp works best for a very particular kind of mind, but that for most programmers its strengths are basically weaknesses.

    (if (> x 2)
        (do-this when-true)
      (also-do-this when-true))

    x > 2 ? doThis(whenTrue) : alsoDoThisWhenTrue();

    x > 2 ? doThis(whenTrue) ; alsoDoThisWhenTrue();

If not, how is the macro different other than implicitly changing the evaluation?

for a more simple example, why is the idiom CALL-WITH-FOO (implemented as a function) not syntax while WITH-FOO (implemented as a macro) is? What precisely is syntax is somewhat nebulous (if I use a regex library in C, have I added syntax to the language? Regexes certainly are syntax, despite being wrapped in a C string).