This is true, and one of the reasons we opted to look at the acquisition route rather than raising another round; with raising another round, a whole lot of expectations would be attached to that surrounding growth, while we were still operating heavily in a research capacity.
Languages like Rust and Go that have nice corporate incubators are a great model, but these languages tend to serve their corporate benefactors in some direct way. It's hard to pitch a greenfield project like Eve, because there's no real great way to quantify the benefits of a language before it's been fully realized.
Plenty of languages have been developed without major corporate backing (especially in the beginning). Off the top of my head, elm, elixir, Haskell, ML, ruby, python, coffeescript, purescript, Idris, Agda, pony and I’m sure many others were developed at least initially by hobbyists and/or academics.
I honestly don’t know a whole lot about Eve. Maybe it was too large in scope to be a side project or fully volunteer-driven. But, even if that’s the case, that’s one of the main things academia is for; perhaps Chris should go for a PhD instead of a startup. I’m sure there are plenty of schools which would give him ample time and resources to work on it for research.
Eve was very different from any language in widespread adoption, to the point where using it didn't even feel like programming at times. Therefore, it was difficult to quantify the benefits to others (especially companies) who have not experienced them first hand. With Eve, we didn't even know the full scope of supposed benefits until we started actually using the system we imagined in our heads.
Moving people in class forward before mastery. I guarantee you that 95% of the problems with math is students don't have one or two concepts mastered and then they are forever unsure.
My strategy is I use Khan Academies Math assessment with kids all the way through their parents. https://www.khanacademy.org/math
My two youngest have been doing for a few years. My 1st grader has almost completed 3rd grade right now. I know he has accomplished all the steps previously. My 6th grader she is in per-algerbra and every time she brings in homework I know she doesn't understand what she was taught. It can take 20 minutes for her to get her head around the concept but then she is fine. I have found that if I use Khan Academy after the drama level is lower and I have found her telling me she watched the Khan Academy videos and she is fine. I'll watch her do two problems and if she nailed it we move on. Math requires as much intervention in 4th to 6th grade as reading did from K-3rd grade form me.
In the UK they have started trials of Mathematics mastery. You can't move on till you have mastered the previous step. They did it one year and saw a slight increase in scores. This has to be started from Kindergarten till 5th grade to really see a difference. https://en.wikipedia.org/wiki/Mathematics_mastery
Simplifying the medium of something (in other words making it so somebody could genuinely learn a programming language, from nothing, in 5 minutes) does not necessarily make task implementation any easier. Consider writing. It's something that anybody of mean intelligence is more than capable of. And writing a novel requires nothing technically more than just writing, yet somehow there is this entirely different skill set there that is not really learned and one that many people for whatever reason seem incapable of developing.
Even if I could get 24/7 attention from Dostoyevsky, Stephen King, and George R.R. Martin for years on end - I'm not going to be a strong novelist. This could be genetic issues, but even if we want to discount that (which is not really a reasonable thing to do) - my potential would certainly be killed off my by my interest. I simply don't get pleasure from writing.
Programming is very much the same thing. Even if you make the 'human interface' to programming as trivial as possible, you've barely scratched the surface of actually creating desirable things. And unless you get pleasure from this creation and have this sort of 'feel' for doing as such, it's going to be a low involvement grind with a mediocre final product.
I think the thing we're fooled by is the confounding issue that programming languages are not easy. And so it's easy to think that if we just make the languages easy, that programming would thus be easy. But I see absolutely no reason to think that this is where the 'real' barrier to entry is. Making a tool easy, does not make the task that tool is used for easy.
Except when it does. Programming in an IDE with code completion, IntelliSense, on-line help and an attached debugger is easier than going all macho developer and programming exclusively in raw text with the pico editor, using println traces as debug.
Sometimes, merely reducing the cycles that the human brain wastes on interacting with the medium makes the whole task simpler. If you don't force the user to think about building a program, they are freed to think about solving a problem.
However, there may ''also'' exist tools that help in the fundamental task. In the example of writing a novel, professional writers use spreadsheets that help them keep track of the general picture, and follow the details of each character, scene and plotline. It doesn't help with the task of being creative and artistry, but hell if they don't help the writer keep track of every detail that's important to the final result.
What you can do, though, is cheat with the scope. Not all writing is novels, and not all programming is large distributed systems. Writing a semi-structured limerick, or a half-assed bash script, is much easier. Ultimately, I feel that the goal of programming literacy should be to let people use computation to solve their own specific problem. That is much simpler than general programming. For instance, plenty of people program in Excel. Or in Tasker (an Android automation app). There is lots of uncharted space in designing better interfaces and paradigms for such small-scale programming (unfortunately, this goes completely against modern UI/UX "wisdom", that is all about removing user's agency from the equation).
There, that's where most programmers miss the picture. I'm glad that you get it, and I couldn't agree more. There's the whole discipline of End-User Development dedicated to explore that area. General programming is like general nuclear physics; not everyone ''needs'' to know the details, but everyone may benefit of plugging a device to the wall and use the power, without a "priest of electricity" who creates a six-months agile project to do the wiring for them.
Thanks for the name, I didn't know there was a field for that.
> General programming is like general nuclear physics; not everyone ''needs'' to know the details, but everyone may benefit of plugging a device to the wall and use the power, without a "priest of electricity" who creates a six-months agile project to do the wiring for them.
Great analogy!
BTW, spreadsheets are considered the most successful End-User Development tool; it's not coincidence that modern web languages resemble more and more its reactive programming model.
We've been doing this for as long as computers have existed and have made virtually no progress (pun intended) since 3GL languages. No other industry has ever tried as hard as ours has to make itself redundant. Programming is about as simple now as it will be for the foreseeable future, any simplification sacrifices the versatility.
If you want to make programming more accessible then you need to work on peoples abstract reasoning skills.
A nice analogy is the difference between Ultron, Hawkeye, and Iron Man. Ultron represents the singularity where computers just program for us; it will come someday but it isn't very interesting to us. Hawkeye, the "super" archer, is analogous to the programmer with advanced abstracting reasoning skills, he is amazing, but there just aren't going to be too many of him. Humans aren't getting much smarter in general.
Then there is Iron Man, who makes himself awesome by using technology, from his power suit to his holographic design environment and interactive voice assistant. That is the sweet spot for us.
It's actually possible that we are: https://en.wikipedia.org/wiki/Flynn_effect ; summary: "The Flynn effect is the substantial and long-sustained increase in both fluid and crystallized intelligence test scores measured in many parts of the world from roughly 1930 to the present day." (But both the reality and the interpretation of this are matters of some dispute.)
Moreover, without any computer assistance until very recently, our ability to do mathematics has advanced marvelously over the past few thousand years. We shouldn't underestimate the power of education, culture, better notation, and accumulated wisdom to advance human capacities even at purely intellectual endeavours such as math (or, for another example, chess).
Of course, none of this says that computers themselves can't help us program, which is your primary point. I just think you're being a little pessimistic about "merely human" ways of improving ourselves.
Accessible tools and laptops don't make programming any easier than cheap hammers, nail and glue make carpentry easy.
After a while its just you. And that's the biggest thing.
Regardless, that programming is so unaugmented while other expert engineering fields are much better is shameful to the entire profession.
Omnipotent AI is not a theory. There’s no evidence it is possible. I have yet to even see a a falsifiable hypothesis about how it could come about. The most advanced hypotheses are something along the lines of “they’re getting smarter do eventually they’ll be infinity smart” which is not a strong claim.
Evidence suggests intelligence is niche specific. Humans are smart, but in the middle of the ocean a jellyfish is smarter. A better prediction about AI is they will surpass us in some ways and not others.
That's not what was suggested. Human-level intelligence is sufficient to cause a singularity (because then they can start improving their own programs).
> better prediction about AI is they will surpass us in some ways and not others.
That isn't a better prediction at all. Regardless, it is uninteresting to my original point, which is we want to live in the Iron Man, not Ultron, phase now anyways.
Your assumption is that human-level intelligence is bound by offline simulation capacity.
If humans are already optimally utilizing offline simulation (in the biological world we call that imagination) then the “human level” AI will have just the same limitations as a human.
That’s the counter-proposal you have to make falsifiable for your guess to become a hypothesis:
That any human-level AI, in order to become human level, will be bound to the same interactive constraints on learning that humans are.
Think about World War II for example: were strategies limited by offline simulation capacity, or were they limited by the fact that you can only try (and therefore sample consequences for) one at a time?
I’m not making a claim here either way: I’m just saying you wave this whole debate away by saying “human intelligence plus unlimited simulation equals superhuman intelligence”
I’m not saying your wrong, it’s an interesting thought experiment: I’m just saying not only is there zero evidence for that, there’s not even (to my knowledge) a robust model describing the mechanism by which that could expect to be true.
1. Making programming accessible probably means making software more accessible.
I remember a study of what mental capacity was most correlated with being able to learn foreign language. It was empathy. So a large part is wanting to communicate. If you want to communicate, you will find a way, and I think we see the same thing in programming. So called "non-programmers" learn the most absurd programming languages and systems if they are motivated. Also see Minecraft. And amazing/horrifying Excel spreadsheets.
One of the issues I see with "novice environments" is that they tend to be very separate from everything else on the machine. I would find that very demotivating.
What I would love to see is "open source as if we meant it", meaning programs that do something we want to do, that we would use, written in such a way (probably also: in such a language) that tinkering/adapting is a reasonable proposition. Yes, that means I don't think that currently is the case: except for the core-dev team, is it a reasonable proposition for people who want to adapt GNUmeric to download the source code and start tinkering? For novices?
2. I am not convinced by the low-end vs. high-end distinction
I think a lot of the same things that make programming awful for beginners also make it awful for advanced programmers. We have just gotten used to the pain and accept it, though I am not sure why.
3. I am not convinced by starting over from scratch
There are reasons why we have what we have, and not all of them are bad.
4. I am not convinced by not starting over from scratch
Of the reasons why we have what we have, a lot of them are bad. A lot needs to be reexamined and rethought.
Resolving that contradiction (thesis, antithesis?) is difficult, it requires looking at what we have in a lot of detail, including the history of how we got here, where we need apply tweaks and where we can interact properly with the rich computing tapestry we have.
Just extending what we have is probably not a solution, because one of the problems is too much cruft, but just starting over from scratch is likely to lead to cool but ultimately superficial projects.
I assume that means you think that programming is not accessible enough as it is? Why do you think that? As far as engineering disciplines are concerned I consider software engineering one of the most accessible to complete newcomers. All you need is a computer, something that's not very hard to procure these days (at least in wealthy countries). Then you have endless tutorials online, from learning to code websites to video games to raytracers to databases to physical simulations to neural networks.
As a self-taught programmer (who started coding in BASIC at around 15) I never found programming particularly hard to approach.
I know of many excellent programmers, yet they have problems solving problem space problems. They write great code, but the code is not solving a real world problem.
Many of the available programming languages (especially in the highly popular languages, like C, C++, Python, C#, etc) have too many "gotchas". Any language which has "undefined behaviour" or "implementation defined behaviour" makes itself a language for the "elites" and instead of being an adequate tool for solving problems, becomes instead a tool for elitism.
Programming languages should be a tool for specifying a solution to a problem that communicates to those who follow in the support roles (including the original author) as well as fully defining the behaviour that a senseless machine will follow.
The complexity of a solution should be predicated on the complexity of the problem and not on the "features" of the programming language involved. This is one of the reasons that I enjoy programming in Icon/Unicon, Failure is an option and allows simpler ways of saying things. The language is in no way perfect, but I find it so much better for solving the problem at hand than having to fight another language because of its "gotchas" that end up getting in the road of solving my actual problem.
Why? There's no shortage of programmers. People who want to do data mangling and don't want to use "real programming" use Excel or Matlab.
There's no general reason to think hard things can't get easier.
Similarly not simply building the same old bridge, because who the hell wants bridge 1.0 I want warp-bridge 20.0 now, requires I have a mastery of basic Bridges and additional pioneering topics currently of interest of which few individuals are experts.
And similarly the explosive growth of the products of these make-a-game kits renders the skill almost entirely worthless. What would have been a very viable publishable product 25 years ago, is now considered shovelware. I think the only way this would end is if we somehow reached a skill cap in development (you've officially made the best bridge that's at all possible!), but if such a thing may exist we're certainly nowhere even remotely close to getting there.
Specifying routines completely disambiguously will always be hard, but I do think techniques will come along to provide the equivalent of railings and safety nets while you do this; such as AI to query you about what you really want to happen, and to draw your attention to edge cases and unusual combinations of circumstances that you need to make a clear decision about.
Certainly true in many respects. However I don't think learning programming is much easier now than it was in the 80s.
Back then I had to bicycle to the library to borrow a book, and hope that the accompanying diskette with the compiler in it was still working.
Programming is still programming. Maybe becoming a professional software engineer is harder, though.
An abundance of choice can actually make things harder.
But overall it's so much easier these days. Even if you're spoiled for choice, you can get the tools and documentation for free. Back then it was either the BASIC interpreter that shipped with your computer (QBASIC for me) or the assembler (debug.com) or paying big bucks to buy a compiler. I was lucky that my dad could obtain a PASCAL and a C compiler through his work.
These days you might have too much choice but back then for a kid like me, the choice was what was available in the local library. So not much choice at all.
It was also what made demoscene competitions so interesting, there wasn't a web page explaining how to pull off those tricks.
It was curiosity and reading between the lines of those books that spiked out the curiosity to try out such tricks.
I wonder what else to call it. "Source code" is obvious and what everyone uses, but now I want something else to use.
I disagree. It's pretty easy to, say, find a suitable log, stand it up by the edge of a stream, and topple it over. It's more about the strength required than the thinking; and if it's a struggle, we have JCBs, chainsaws, etc. to help.
For something a little more robust, hire an AVLB. For more permanence, buy something like a Bailey or Medium Girder bridge.
Of course, I'm being facetious; but my point is that "programming" covers a vast spectrum. We don't teach kids to write under the expectation that they'll be modern day Shakespeares (or build Danyang–Kunshan Grand Bridges); we do it because writing is incredibly useful, even if it's as mundane as a shopping list on the back of one's hand (or a log over a stream).
"we need to add certificats and raise the bar, quality over quantity"
Im not sure why that comment was delete, hn is becoming very authoritarian
Killed comments are visible to anyone with 'showdead' set to 'yes' in their profile. We never delete comments outright except in the rare case where the author asks us to.
But the act of programming is not the only thing that a professional programmer needs to do. Understanding requirements, planning development, dealing with the complexity of large systems, communicating -- those are difficult. You don't need to do those things just to program. You can start your own project and build something that most professional people would call a "toy", but is still really satisfying for the average person. There is a limit to how complicated something can get if it is under a few thousand lines of code, and you are the only person working on it.
I find that most movements for simplifying programming are attacking the wrong part of the process. It's fair if you want to make programming more approachable, but it's already very simple. If your goal is to get more people able to do a good job as a professional programmer, then you should concentrate on being able to handle complexity in large systems, or being able to discover and reason about requirements in the system.
It's not.
I remember learning to program in Logo on a Commodore 64 when I was in the third grade. Even back then, I was decomposing my code into functions, playing around with recursion, etc. 30 years later, I was presenting to my son's 4th grade class, and was getting reasonable questions on CSS, github, etc.
The basic concepts behind programming just aren't that hard if they're accessible to elementary school students.
Where things do get tricky is when you start to scale upwards in terms of complexity, volume, and duration of service. But even then, it's all too common for engineering efforts to overestimate the need for those things. That then leads to architectural choices that not only make the system more difficult to work with, but also likely fails to meet the initial targets.
I agree, programming is easy, if the language allows you to formulate code that is logical and doesn't bite you because of "undefined behaviours" or "implementation defined behaviours".
Logo was and is useful in providing you with specific conceptual patterns for writing code, but does not give the necessary abilities to provide solutions to problems via code.
One can learn the features of Calculus and how to solve Calculus problems. but it is a different matter to learn how to use it as a tool to solve real world problems. This is a different subject altogether. In my undergraduate days, oh so many decades ago, a common refrain from us engineering undergraduates was how often we would be taught something with no reference to how to use that tool for real world problems.
As the years have passed by, I have been pleased to see that in some areas, this disconnect between learning a tool and using that tool for solving real world problems has strongly diminished. There is some excellent material now available that goes a long way to solving this problem. Kudos to those men and women who teach these courses.
You say that like it isn't a robust conversation that a significant segment of the community has not only been having but trying out solutions to for decades.
In 5th grade everyone talked about how Algebra was hard. When I got to Algebra, it was pretty easy. I was very surprised! Of course my dad had to explain it to me, because my teacher was incapable of explaining it.
10th grade, same thing with calculus. Thank god my dad knew calculus and was patient. Because my teacher did not.
And so on and so on.
One thing I’ve noticed is that nothing humans have invented or discovered is hard. Learning things requires curiosity, a lot of patience, and someone showing you how to get from A to B in small steps. Overwhelmingly, the inventors and discoverers are the people at the bleeding edge of those small steps who find a next step.
Programming is no different. We need to stop infantalizing people. Most humans are incredibly capable. We don’t need programming languages for children. A child can learn Python or JavaScript. You just have to show them that it’s cool. But instead most adults show kids that sports, video games and Netflix are cool. So, c’est la vie.
Today unfortunately we have a culture of “you can’t, it’s hard, it’s not for you, other people do that.” People always refer to “they” when they’re taking about people inventing something. This is good for the rich and easy for the poor. Who is “they”? What if instead of “they” it was “we”?
> because my teacher was incapable of explaining it
"A dad who knows ____ and can teach it" is, on the other hand, a practically-attainable real-world solution.
I can't be understanding this correctly. Please expand, I fear otherwise this is going to be at the back of my mind all day.
I'm "smart". I taught myself how to program, and now I'm an architect-level developer that's respected by everyone I've ever worked with. But I'm also a college dropout. I had a terrible education ("Christian" "school" with no qualified teachers) and my parents were no scholars themselves; and I gave up on college because I couldn't get a CS degree without making it through Calc 1, which I didn't even get to until my second year of college because my whole first year (and the summer prior!) was spent in remedial math.
I worked every night in the math lab with the smartest tutor I've ever met. I stayed up until 2a every night trying to get my Calc 1 homework done. But it wasn't enough. I didn't have a strong enough foundation to pull it off. It was too little, too late.
Years later, I think I'd do much better, as learning how to develop enterprise-grade data warehousing and ETL solutions has taught me /how/ to learn. But at the time, I had no good "tools" to use - I just knew how to memorize, memorize, memorize. And it just wasn't enough.
If my stupid, fucking, batshit insane religious-maniac parents had just let me go to a public high school - like I begged them to - all of this could have, and would have, been avoided.
Except for the final, I think he gave up trying to fight it and just gave me a 100 on that one, because I know I missed one of the CSS questions.
We never actually built a webapp in that class, either. Luckily for me, I'd been doing it for years already (older student, this time around), but I feel bad for the other students who were new to it.
Always full of drawings, or little stories, and along the process I got introduced to BASIC, Z80 Assembly and all the intricacies of Spectrum hardware.
I used to think those books were gone, but they seem to have come back regarding Arduino and Rasperry Pi programming. Just focusing on Python and Scratch now.
Giving them a board with such books and some electronic stuff is probably the best way to teach them. Regular computers have too many layers that just hinder learning and its hard to see things happening.
The C64, the Spectrum, the TRS-80, etc, were all "small" machines that were simple to learn.
The Arduino, Raspberry Pi and Scratch are also tricky, but not overwhelmingly so, and simple to learn.
The absolutely massive difference with the environments of the 80/early 90s and today is that
a) The environments learned are heavily sandboxed, caricaturized facsimiles of computing
and
b) Learning Scratch won't lay down a mental model you can immediately apply to Python, and learning Python won't lay down a mental model you can immediately apply to C++, Rust, etc.
Learning assembly language didn't quite leave you with an immediately-usable understanding of C, but what it did do is give you a working knowledge of what everything else was based on under the hood. I'd argue that's an even more valuable gift: the knowledge that you understand what the more complex environment is based on - good for confidence - and the knowledge that if you absolutely need to, you can pull everything to bits and unravel bits of it - which immensely helps with discovery.
Nowadays, it's like worst-case simulated annealing. "Climb Mt Everest, then climb all the way back down to climb Mt Everest²."
I don't think that's a good analogy, I think it's more like "Climb up to base camp, then climb halfway up, then climb ...".
I learnt Python before I learnt C and learning C I was constantly having these "Aha!" where I suddenly realised why Python is the way it is. I didn't have one mental model for Python and a different mental model for C, I had one mental model for computing which was enhanced by learning C.
And on top of that Python isn't a fundamentally different language to (for example) JavaScript, sure the details differ but somebody who knows Python won't have to spend months learning JS. Arguably a language like Haskell is a fundamentally different language to something like C, but there are plenty of things that you learn when learning C that can be applied to Haskell.
I don't think the issue is all these concepts are orthogonal, I think the issue is that there are just so many concepts. Back in the 80s learning assembly might have got you 30% of the way up Mt. Everest, whereas nowadays it might only get you 1% of the way up.
https://usborne.com/browse-books/features/computer-and-codin...
Just seeing those covers gave me a huge nostalgia-trip, from my own time programming the ZX Spectrum in the 80s. (First in BASIC, then in Z80 assembly via the fine manual.)
Have you also used the Input magazines?
I used to read a few of the Spectrum magazines back in the day, Your Sinclair, Sinclair User, etc. But over time they all dumbed down and started to be more about advertising and game-reviews, rather than having a mixture of programming-content and other stuff.
I did get some POKEs printed though, so it wasn't all bad!
That is true if you are discovering or inventing it. Trying to understand what other people discovered or invented is hard as you are skipping the journey and arriving straight at the results, without going through the dead-ends, u-turns, restarts and various other ups and downs in the journey making many side discoveries including many meta discoveries alone the way.
There is this anecdote from the life of Richard Feynman, that he sort of put his physics textbook aside and worked through all of that on his own and discovered all of it on his own. The reason being its impossible to truly understand things in a deep fundamental way unless you discovered it yourself.
You can learn anything you want. But you have to embark on the journey of rediscovering all of that on your own.
Surely the concept of outliers, survivorship bias, and statistical noise is easy too then!
>Of course my dad had to explain it to me, because my teacher was incapable of explaining it. 10th grade, same thing with calculus. Thank god my dad knew calculus and was patient. Because my teacher did not.
So, how do we produce millions of capable teachers (as opposed to the non-capable current bunch), with extra patience, and each dedicated to one or a tiny group of students?
Because this is not about how subject X is easy, but about how subject X can be made easy (or easier) under ideal conditions.
And even then, only if we assume you were a typical student, and not especially gifted or motivated.
>Programming is no different. We need to stop infantalizing people. Most humans are incredibly capable.
What if the problem is not how to teach motivated people under ideal conditions, but how to motivate or even how to teach unmotivated people, under all kinds of conditions (e.g. working class family, problematic household, poor school district, etc).
E.G: stop promoting growth so that we eventually get a system we can manage more easily.
Or change the way media communicate so that people focus their efforts in a different direction.
Or relocate budgets from war to education and research.
And so on.
"The brick walls are there for a reason. The brick walls are not there to keep us out. The brick walls are there to give us a chance to show how badly we want something. Because the brick walls are there to stop the people who don’t want it badly enough. They’re there to stop the other people."
Basically what I’m attempting to say is that the brick wall is a useful tool to make sure that the people who want to learn without putting any work or practice in are filtered out from the ones who want to learn and do put the practice in.
I recently said to someone that I believe that (almost; obviously disabilities and such exist) anyone can learn (almost) anything, all it takes is three things:
1. Motivation. You have to want to learn it. In the in text of learning to program, I do believe almost anyone can learn it, but many people have no interest in programming and they will struggle if they try to learn.
2. Practice. It takes time to get good at anything. If you don’t put the time in, you will struggle.
3. A good teacher. Sometimes even with motivation and practice, some things are still really hard. A good teacher can break things down or give you a different perspective. A good teacher makes a massive difference. You don’t always need a teacher (good or otherwise), but some people will. Sadly, not all teachers are good and not everyone has one.
but most of us that do are pretty frustrated at the how much time it takes, and how many artificial concepts we have to become accustomed to.
compared to the systems we use, the fundamentals of information processing seem really quite simple.
maybe, there is a way of describing simple programs that doesn't require months or years to master. I certainly wish personally that little ideas that occur daily didn't take weeks to realize....and I'm pretty sure given the simplicity of some o those notions that there isn't anything fundamental that requires that amount of brute force work.
and if there were a system, that cut a bit more quickly to the chase - maybe programming would become a useful tool for people that don't have the time or temperament to spend a couple months learning how.
This is one of the most absurd and arrogant statements I've ever read on HN.
If this is true, why don't you read some textbooks for a few years and start flawlessly performing surgery? Why don't you write a world-renowned novel?
> "A child can learn Python or JavaScript. You just have to show them that it’s cool. But instead most adults show kids that sports, video games and Netflix are cool."
Lots of kids know Python and JavaScript. They may think it's cool or not. They're right either way because nothing is objectively cool.
I'm a programmer and I myself see it as a means to an end (a fun one, sure). It's not meaningful to most people, not any more than plumbing or chess is meaningful to most people.
People don't only fail to learn hard programming languages because they're lazy or haven't unlocked the magic of programming. Many of them just don't care to learn them or enjoy them, and that's fine.
You missed the point because you weren’t open minded enough (admittedly OP left it ripe for you to jump to this conclusion). What I believe OP was trying to say was that the example you mentioned above isn’t some impossibly hard thing that only those with a special gift can do, but rather that with the right motivation, enough practice, and possibly the right teacher, you too can achieve it. OP also did not put time boxing on how long it would take (that’s on you there), but said it’s achievable if the above is met.
Then you go and start reading Actual Science: Minkowski spaces? Tensors? Paradoxes about long objects and barns? Gravitational lensing? Figuring out where to go with that initial idea is decidedly non-trivial.
In the extreme, there are papers at the bleeding edge of mathematics that can only be meaningfully reviewed by half a dozen people worldwide. Understanding these papers (or anything at the limits of species-wide knowledge) is a far cry from grasping algebra / calculus: eventually you hit a point of diminishing returns, where further advances in your understanding of the problem require months or even years of dedicated study...
...and yet (assuming we refrain from destroying ourselves) these same problems may eventually find their way into high school textbooks, where they will be succinctly (and approximately / incompletely) summarized so as to make them look easy and incremental. That's great! It means we've permanently moved the pedagogical starting point forward for future generations, so that they can go and struggle with truly hard problems that we don't even know to ask.
My point: yes, some things are hard, even if most are not. I'd say that the trick to advancing humanity lies less in convincing students that everything is easy given enough time / patience / curiosity, and more in getting them to stick with hard problems: to normalize failure, as it were. That said, I do agree that we should avoid presenting things that aren't truly hard as though they are :)
You could do division in roman numerals and perhaps people even then justified it with 'math is just hard, learn and deal with it' but things can get easier when you have better models, better representations and better mental tools. A big advantage of the computers is that they themselves are dynamic and interactive and so they can actually amplify the mental tools.
Squeak and Pharo are both pretty obviously prior art for Eve. For example, the bouncing balls demo someone linked to elsewhere in this thread looks very similar to Squeak + EToys, albeit with a dark theme.
Squeak and Pharo could both use more developers, BTW: