but I think the question of “what programming” actually is, is quite interesting. I don’t know if we’ve quite figured it out b/c programming always lives in the assumptions and trappings of a pre-existing language of some kind!

Anyway, it seems like really good teaching is hard. I was really impressed with how vuemastery.com teaches Vue - at least the non-paywalled videos I saw have lots of great animations nicely timed to the instructor, but the animations sure look labor-intensive. scrimba.com probably has much better "bang for the buck" in terms of "teaching effectiveness per unit of time it takes to put a course together", since the viewer can play with the code at any time and the instructor need not put lots of work into fancy animations.

Anyway, since watching Bret Victor's "Inventing on Principle" I was sure I wanted to "Invent on Principle" as he suggested, but the tricky part is figuring out what my Big Principle is. One angle I've homed in on is the principle that "easy-sounding things should be easy". Programming is full of things that seem like they should be easy, but are unnecessarily hard in practice. Things like drawing graphics efficiently (you can start easily with Windows Forms but if you want efficient drawing you have to make this massive leap over to DirectX, in which case, good luck implementing your GUI widgets by hand) playing music and sounds (okay, playing a .wav file might be a simple static method call, but generating audio continuously or playing an mp3 or opus stream might be far more difficult), or keeping a user interface synchronized with the underlying data model (but see SwiftUI, Assisticant, MobX/KnockoutJS for reactive solutions in Swift, C# and JS respectively) In this view, then, the problem isn't so much education, the problem is that our tools are too hard to use. If the tools were easier, education would be easier too. Taking this a step further, I think there should be a toolset that allows a single universal education. We haven't figured out what the "ideal" programming language looks like yet, as there are so many ideas still being explored (consider Unison, Idris, JAI, Nim, Ceylon, as well as the languages made by people right here in FoC). However, there are a lot of ideas that are highly useful and fairly universal: interfaces, unit testing, sequences (including singly-linked lists, growable arrays and hashtables, semi-persistent data structures (ask me about them), functional programming, ranges and slices of collections, universal syntax trees, serialization, asynchronous functions, symbols like in Lisps/Ruby/JS, reactive state, geometry primitives like points, infinite lines, planes, affine matricies, garbage collection slash refcounting with weak refs, graphics, sound, sending UDP packets... I would like to be part of a group that develops a really good multi-language standard library and implements it in several languages. If such a library were widely available and if people bothered to learn it, it would bestow the ability to write code in many languages more easily. It would also be useful as the basis of tools for converting code between languages (the hardest part of converting code from one mainstream language to another is dealing with differences between standard libraries, since the actual semantics of popular languages are, at least on some level, fairly similar.)

I also think certain programming principles are much more important than others. Bad code typically results from violating one of the following principles that I follow: 1. Separate concerns!!! A program is like a house: just as walls give a house structure, separation of concerns gives a program structure. Most programming languages do not facilitate separation of concerns because they allow almost anything to touch almost anything else. Programmer discipline is required to create imaginary walls where no connections are allowed. For example, a language typically can't stop the GUI from directly running SQL update commands, so the wall between GUI and a specific data persistence library rests only in the minds of the developers. (I think some people "solve" this lack of compiler enforcement with "microservices architectures", but any solution that involves huge amounts of otherwise unnecessary plumbing code is not a good solution.) 2. The Generalized Don't Repeat Yourself principle: avoid not just repeating information or business logic in multiple places, but minimize repetition of any patterns whatsoever. Elegant code minimizes the number of tokens in the program. 3. Create functions and abstractions appropriately, but avoid excessive layering/wrapping (doing so is often motivated by prior failure to refactor, or failure to test, leading to brittle code you don't dare touch). There is an appropriate number of layers of abstraction; too many or too few is confusing (and many programs have both too many and too few, in different places). 4. Minimize the number of code entities by merging things that turn out to be very similar. For example, I realized that "logging" and "reporting warnings and errors" are essentially the same thing, so in the Loyc.Essentials way of doing things you would use the same interface

IMessageSink

for both (sometimes I wonder if no one else has noticed this). Similarly I often see interfaces like

ISomethingRetriever

whose job is to retrieve some kind of object given some kind of key. That's basically a dictionary! Just implement

IReadOnlyDictionary

, you fool, or whatever your language's equivalent is. Do not create a new and different interface every time you need to retrieve a new kind of object. More broadly, design both your interfaces and your components to be generic, reusable, and ignorant. 5. Pick good names and write documentation that describes things in a different way than the names do. I often write documentation for a class before its code, which leads to clear thinking and good separation of concerns. (However I have to correct the documentation later because I usually tweak something or change plans midstream.) Documentation of large-scale entities (classes, modules) and mutable state (e.g. invariants) is often more important than documentation of small-scale entities (small functions and code blocks). 6. Write good tests (or prove correctness) 7. Think long and hard about your decisions. Agonize over them. You'll never come up with an optimal design by doing the first thing that comes to mind. Even after you implement it, be on the lookout for a better approach (either so you can use it in the future, or ideally, improve the original code). 8. Be on the lookout for new and better general-purpose techniques, and then actually use those techniques. I am slightly irritated whenever I see professional developers using strings when they should be using Symbols. Why? Do you use strings in C# because it doesn't have Symbols? But you've seen Symbols in Ruby and ES6 - take the lesson you learned in the other language and apply it to C#. (When I wrote this I was thinking of the question "what events stand out as important learning points in your path to technical enlightenment?" but now I see that, rather than answer the question, I've simply explained what I think an enlightened programmer does. I don't remember how I learned this stuff, but I am quite convinced of its importance.)

If I were to summarize my goals right now it would be: Build a competitor to Udemy. A platform optimized to teach programming concepts. Base courses on open source code sets to create rich; real world scenarios. So; I’m trying to “learn” things I’m interested in; and at the same time, think about the process I use - to see if I can wrap it up into something that would be valuable to other people. On the implementation level; having a url that links into an arbitrarily sophisticated environment is a great enabler. I came across these guys (and have had a few discussions with them) https://www.gitpod.io/education/ - they are building a more open source version of vs-code. And then there is; as far as I can tell; a slightly more open source version of the gitpod “auto-environment” idea from Redhat https://developers.redhat.com/blog/2019/09/17/eclipse-che-kubernetes-native-ide-version-7-now-available/. So there are some quite powerful building blocks that could be leveraged. This tweet poped into my feed a few days back - and is getting quite a warm response - https://twitter.com/LostInTangent/status/1236672803123814400. I see it as being in a similar space of putting knowledge into code sets. A rough outline of the types of features I have in mind to explore: 1.) A focus on discoverability. StackOverflow has set the bar on being able to find extremely specific results; and the goal would be to bring a similar experience to course content. How to achieve this is the big open question. Currently I’m thinking along the lines of getting rid of Chapters and capturing the “structure” of the knowledge in the course - and perhaps from there; allowing users to explore in an autonomous way. 2.) A way to "layer on" complexity. I always find the early exercises overly simple; try to jump ahead; and then have to go back to try find where supporting info is addressed. This seems to come back to creating support for users to navigate the “structure” of the knowledge. 3.) A platform which allows linking through all related topics. Similar to following articles in wikipedia - being able to start in a course on https://github.com/zio/zio and end up learning the relevant Category theory. (At least I think that's where users would end up.) And again; this seem to be back to the same core idea of knowledge having a structure - everything is a graph!!! 4.) Being able to immerse in real world ASAP. The jump between "exercise tasks" and "real world" often is large; but with environment support, and leveraging open source, the context of the lesson can be enriched. I’m hoping this can embrace the principle of

Everything should be made as simple as possible, but no simpler.

Whilst things often get buried in accidental complexity; it is also easy to forget actual complexity. I think https://github.com/promises-aplus/promises-spec/issues/94 is a really interesting real world scenario. If the community could have that discussion again; could we have better ways of framing “known” information so that people with different backgrounds could get up to speed efficiently - towards the goal of having more progressive debates and reaching what in retrospect are agreed to be “correct” decisions.

--- There where lots of interesting points in this thread already - so hopefully once I start creating "content" I can loop back to them and dig into more detail. If anyone is interested in collaborating - please let me know

Dataquest.io does seem to be built on some very similar ideas. Are you aware of any platforms that take a similar approach for non-data science fields in technology?

@Brent oh yeah there’s a few. • Codecademy.com: Python, JS, other stuff (including data science) • Katacoda.com: for devops-y stuff, purchased by O’Reilley. • Codeschool was bought by Pluralsight but mostly hasn’t gone anywhere (PS has struggled to switch away from video based learning) • Datacamp.com: data science (Just throwing it in here) • There’s a few smaller niche sites that teach specific things, like https://www.sqlhabit.com/ and sqlbolt.com … both for SQL

@Brent building a Udemy / Datacamp / Codecademy competitor is interesting but ultimately I’ve come to appreciate the following: • Teaching consumers is effing hard. If you care about learning outcomes, the best thing is to add on a lot of things that students’ motivational investment. This is what coding bootcamps do .. they make you pay a lot of money (weeds out people who aren’t serious), they make you take a basic coding interview exam (weeds out people who aren’t serious), they’re often in person (shared struggle with other students), etc. They use the techniques universities use (old teaching methods with LOTS of carrots / sticks to “motivate” people). • If you instead care about being “innovative” in how you teach, the challenge here is that … customers don’t REALLY care about learning in some fancy new way, they just have a specific job to be done (https://hbr.org/2016/09/know-your-customers-jobs-to-be-done) that’s either “I want a pay raise / move up in seniority in my existing job” or “I want to switch into a new career”. There’s a small sliver that wants to “learn for fun / curiosity”, but that’s competitive as F (competing for the job of fun has an endless sea of competition, including Twitch, Youtube, and video games / tv shows). Soooo if you want to build some cool whizbang learning environment … you still have to answer the question of “what job is being served / solved better? and for whom?“. You want to teach with only interactive explanations? Cool! Which learners meet their goals better b/c of it? And btw creating interactive simulations is time consuming and expensive, which means your ‘learning rate’ from your customers is a lot slower which means your competitors that just make lots of videos … may end up solving the job in a good enough way for most students at a lower price. • Hopefully that didn’t come off too much like a rant 😛 I guess I spent 5 years here in this space and I felt like not enough rigor was applied to thinking about the customers’ actual desires, and instead more time was spent on feel-good things like “hands on learning” (which is still cool and interesting, but insufficient!)

@Brent anyway I can talk about this stuff for ages 😛 I’m still a big fan of creating rich, learning environments for learning to code (even if we’re just teaching people current stuff like Python and JS). But I actually am thinking now that I’d rather work on the infrastructure side of this. Basically make it easy for universities and companies to create their OWN courses that are highly tailored for their needs, but without being devops experts and needing a 10 person software eng team to stand this up! That seems like what Gitpod is doing a little? But Gitpod and Repl.it both are focused on developers instead I think? EDIT: looks like there’s at least one startup in this space: https://www.codesters.com/?lang=en EDIT2: https://www.codio.com/

if y’all wanna hop on a Google hangout / zoom to chat more, I’m always down 🙂