TLDR: Focus on getting them to have fun & enjoy learning about 'code'. Don't care so much on how well they learn it.

Every kid is unique & will respond to different things.

Social & mentors are awesome. It's usually more fun to build with others if possible. Also they will want to easily share & show off their creations with others.

Show them how to "hack" Google with the browser's dev inspector tools. Wins them over every time.

Give them simple partially completed programs that they can modify. I've had a lot of success with a simple trivia game that lets them start by modifying the questions/answers & the replies it gives. A great first lesson in how to use strings & gets them looking at the code. They can then share what they created with others (social aspect) & have them play their game.

Do NOT lecture to them or try to do long demos. They often listen to teachers lecture all day long. They want to have fun & explore. They also don't care about types or any other computer science terms until they've created a lot of things & are trying to figure out why they don't work.

I've had decent results with Scratch. For pure beginners though, still start them off with a semi-completed program.

Another suggestion that works for the same reason is to give kids code to play with. I've wasted 20 minutes of class time having kids write a three line "Hello World!" javascript program from scratch. All this did was irritate and bore the kids out of their minds as they struggled with syntax and hunt-and-peck typing.

Instead, when I give kids a great big block of javascript code that does something fun and animated, those kids will go wild with it. This is because changes to different variables can have big effects. They quickly learn to read the code and identify what different parts do. They break the code, and you show them how that's a good thing and how easy it is to revert it back so that it's working again. Code should be a playground. Give the kids a rich playground to run around in.

I remember being a kid and typing in Mandelbrot code from a BASIC computer magazine. Even though I didn't understand the code, I had endless amounts of fun with stuff like that for exactly this reason.

It's what sparked my imagination and interest in programming.

Got some script for modifying a game or an excel function or some code that doesn't quite do what we want it to. Bash it with random changes until you suddenly fix/change/etc. it.

Get a bit addicted, rinse, repeat, suddenly a month later you can understand most of the code.

It's too bad elementary and secondary education in general aren't more like this.

The plan was to teach kids about how websites works/HTTP basics, basic HTML/JS etc. I had all the material and code ready. When I reached the school I found out their internet had been disconnected!

Google's "browser is offline" T-Rex game popped up and I ended up spending the entire week with them teaching them how that game worked. It was a big hit! By the end of the week they were busy modifying the t-rex sprites with each others faces and stuff :)

Basically have a back up plan for no/limited internet!

YES. I wish I could upvote this more. Curiosity is a powerful drive for learning, and when kids are allowed to pursue their own line of questioning and tinkering, the questions asked are more "personal" and the information learned IMO is more likely to be retained.

The "zero-entry pool" that Scratch provides is also important (how many kids want to spend a lot of time setting up their development environment?), but I think the tinkering is key. Kids who are simply content to tinker with what is provided will stay at that level; the ones who are truly interested in going beyond that stage will begin asking questions and driving beyond what has been provided.

We had a lesson plan booklet to work from, but I found it far more effective to completely ignore it and let the child explore, and then guide the result of that exploration into a result. Seeing the sheer delight on a kid's face when you point out that with a few minor modifications, what he or she has made is in fact a playable computer game is spectacular. (and then beatboxing with them to record "background music" and sound effects is also fun ;) )

I have learned not to bore them with business apps or too much of the logistics to start. I start by getting them to code basic HTML/CSS. They get super excited by learning how to change colors and font sizes. Then we go into programming some simple JavaScript games. Later in the course, I bring in a Raspberry Pi and introduce them to that and a little Python.

You don't want to scare them away or overwhelm them at first. Keep it exciting and fun. At this age, let them hack.

Teaching kids to code is similar to teaching just about anything else: get them to have fun and find how it applies to them, followed by how to figure out what they don't know, then how to keep going when things are frustrating and they want to give up.

More practically, the kids who are into games have probably already figured out how to write Minecraft mods or something, so introing them to something like Code Combat is a fairly natural next step. For kids into music, try http://sonic-pi.net. Sports? Maybe wade into statistics/data analysis and show em some moneyball or fantasy football. Lego Mindstorms-style stuff is awesome for just about everyone because of the tactile aspect, and moving from that to playing with simple electronics can be done with gentle happy path introductions.

Also be aware of where the falloffs will be. Lots of kids can change the color on a prebuilt object on Khan Academy, but going from changing a field to starting from scratch on a new idea is an incredible. Teaching debugging and figuring out how to solve something you haven't seen before is more important than anything else.

The beginning of my own path to being a programmer, long ago, was playing with games made in RPG Maker 95. If I didn't understand how to pass an obstacle, I would "cheat" by opening the game's world-database file up in the game editor, finding the "object" with the logic that was inhibiting my progress, and then modifying it to allow me to bypass it.

After that, I progressed to just opening games in the editor to "figure out what the author actually wanted me to do here" so I could go back to the game and do it; and then, finally, just observing how people had constructed their games.

All in all, it felt very natural to transition from there, to making my own games in the editor.

I think it was a (probably unintentional) brilliance on the part of the company who produced the software, that the games produced only by using the "hardcoded" features of the game-editor were so simplistic and limited--while also allowing a complete, Turing-complete scripting capability. It meant that, very quickly after starting down a path saying "I want to make a game", I was forcing myself to learn programming concepts in order to extend the engine with the features I wanted in a game.

After a while of doing that, I had absorbed enough about programming to understand that the game-editor tool itself wasn't "magical", and that the whole of its hardcoded game engine could be represented with a not-overwhelmingly-large piece of the same scripting-language logic I had already been writing.

After that moment, it just felt "natural" to move on to reading some Javascript tutorials online, and to pick up a book on C.

The realization that there was no magic in the software I interacted with, but instead merely sequences of small, logical steps I could identify and replicate myself, using a library of atomic mechanisms (branches, loops, etc.) specified to a computer in a formal language: I think that is the one thing that needs to be captured by anything that claims to "teach programming."

And, personally, if I were going to teach programming, I'd try to do it just as I did above: give them completed game, but an overly-difficult one, one which they aren't just modifying for the sake of modifying, but modifying because that's what will let them win.

And, at first, I don't think "programming" even needs to be introduced. Just introduce the framework, the idea of modifying an existing interactive thing (don't call it a program), even if it's just by opening a visual editor and erasing a rock that's in your way.

Then, in later exercises, you can make the "thing that's in your way" much less simple--a sprite whose state is wrong, an event that won't trigger until a flag is set from somewhere else, a person who expects some variable to hold an impossible value where you have to construct the trigger to set that variable yourself; etc.

Eventually (but probably within one semester of an after-school-club setup!), this "adversarial modification framework" could work up to the point of something like Core Wars, where the student is writing writing complex agentive processes controlling shield drones to protect the player-character from enemy fire as they move toward a goal.

From there, you've got a decent jumping-off-point to the "wanting to mod the engine to get it to do the cool things other people have made it do" phase, and from there to the "why not just write it all myself?" phase.

One thing that we always did towards the beginning of a class was an exercise where we tell them to write down the steps to make a peanut butter and jelly sandwich. Then we'd literally get bread, peanut butter, and jelly, and follow their instructions to the letter. No one ever adequately describes the process: "put peanut butter on bread" - With what? the jar is closed, I can't! etc.

You might argue this introduces too imperative a thought process - but it gets the "computers do exactly what you tell them to" idea across very well.

We needed to describe how to draw some sheet music on the chalkboard, but you couldn't gesture (we could only communicate through an imaginary phone line), and he would take whatever you said as literally as possible and opposite of your original intention as he could.

"Ok, draw 5 lines" (Draws 5 squiggles) "No! 5 straight lines" (draws 5 lines in various locations and directions) "Nooo! 5 straight lines, above each other, horizontal!" (Draws the 5 lines of a musical staff, but 2 inches long and 3 feet vertical spacing between each line). "Nooooo! 5 straight lines, above each other, horizontal, they should be very long and close together" (Takes out a piece of paper from his desk, draws the staff on it) "NOOOO! On the chalkboard!" etc

Sounds like the perfect introduction to abstraction and wishful-thinking guided programming! (Maybe not using big words like abstraction for kids)

* Don't teach unnecessary details. For example, students get hung up on the <title> tag because titles are usually at the top of the page. Just skip or defer teaching it - it's not important to their end goal of understanding code.

* Reinforce that the computer is dumb. I tell my kids outright that the computer is stupid. What this gets across to kids is that when they talk to this box, they need to be very precise with their language. Syntax errors---a constant demoralizer---then become not a shortcoming of the student but of the machine.

* When you craft / select exercises for practice, make sure they always fit two criteria: instant gratification and fun. By the former, I mean the students are producing code and instantly seeing a visual reward for it. With the latter---adults always forget that kids are kids. They couldn't care less about "Hello world". But an "About me" page is fun because they get to express themselves. When you talk arrays, don't push and pop fruits. Push and pop Justin Bieber and Ariana Grande.

I might expand on this in a blog post. Happy to talk more offline.

[0] - https://scripted.org/

PS - if you're in the bay area OR NYC and want to teach underserved high schoolers how to code, reach out!

http://www.bootstrapworld.org/

Bootstrap 1 is computing tied to algebra concepts, targeted at the middle school age group (US grade 6-8). Students learn things like order of operations and what a function is while building up their own game. The curriculum has lots of activities that show students how to use code to generate images early on, which gives something immediately interesting and tangible to work with.

It runs in a stock browser (lots of students do Bootstrap on inexpensive Chromebook models), has a great support mailing list, and is used in schools across the US already. It also explicitly helps with math skills, which can be doubly useful in preparing for other STEM topics in the future.

For younger kids maybe a block-programming interface would be good: https://developers.google.com/blockly/ || https://snap.berkeley.edu/ || https://scratch.mit.edu/

For a less high-tech approach, you should look at http://csunplugged.org/ , e.g., http://csunplugged.org/binary-numbers/

In all cases I think the instruction/teaching is going to be key—through the physical presence and support. It will be comparatively more difficult to bootstrap and get them to learn by themselves. Peer tutoring is very promising though: See: https://www.youtube.com/watch?v=dk60sYrU2RU and https://www.youtube.com/watch?v=y3jYVe1RGaU

It would be great if you write a blog post about this and what worked so people can follow in your footsteps. Good luck!

At first, I thought it was silly to teach "drag & drop" programming and would have preferred a high-level scripting language. But, after teaching 2 semesters of Snap and observing classes in Java, I'm a huge fan.

2 main reasons:

1. Time-to-cool-result is really low. The first project was a Mario-like game. Less than 10 hours from "never programmed" to "built Mario game" is a really powerful first experience. (Demo: http://snap.berkeley.edu/snapsource/snap.html#present:Userna...)

2. Syntax and compiler errors are really confusing. When I walked around the Java class, most kids were asking questions about how to fix their syntax errors. In my class, most of the questions were conceptual.

It's easier to go back and learn a "real" language after you understand the high-level concepts and have seen how cool programming is.

If you want the resources I used, feel free to ping me (adamaflynn@gmail.com).

I taught this curriculum to 120 or so kids aged 6-13 from underprivileged backgrounds in the Boston area. The experience changed my life - kids are so amazingly smart and learn so fast - and they ALL got really into making websites! I have no doubt that for at least a couple of my pupils the early exposure led to success in tech careers, helping to break them out of generational poverty.

The Web is an incredible platform for learning, self-expression, creativity, and empowerment. Unfortunately in the age of iPads etc. I think it's more difficult now to get kids into web development than it was 10 years ago.

My contact info is in my profile if you read the curriculum and want to ask any questions.

One kid wrote a basic brick breaker and another pong. They all seemed to enjoy the process since it's pretty straight forward drag/drop logic.

https://scratch.mit.edu/

After getting a jumpstart, they started building games using Scratch and sending them to each other to play (test). That's the hands-off part. The prep was simple instruction in reaching a goal with code, including the importance of accepting feedback from others. The school had already taught them to be respectful, so I didn't have to deal with a lot of egos. The boys all knew that some of the girls would be better programmers, and didn't fight it.

I've been using the CS-First curriculum from Google. It uses Scratch as the programming environment (a visual environment from MIT).

Overall, I like the CS-First curriculum a lot–though some of the themes are better than others (some lean towards animation/storytelling and are light on actual programming topics). In my workshops I almost always inject some of my own lectures and exercises with the kids.

Biggest issue I've run into is with Scratch being Flash-based. I'm starting to see browser issues more often (especially in a tightly controlled university lab). This could be a big issue for you if you're teaching kids remotely.

One new thing I'm looking forward to trying with a class soon is Hopscotch. It's a scratch-like visual programming environment for iOS. I've tested it on my own kids and they love it. Plus they put out a ton of useful videos and tutorials.

Good luck

https://www.cs-first.com/en/home

https://scratch.mit.edu/

https://www.gethopscotch.com/

Bootstrap World (http://www.bootstrapworld.org/) is a curriculum for teaching CS and Algebra while making a simple graphical video game using Racket (similar to Scheme). You can do the exercises using Dr. Racket IDE or by using a web-based IDE (http://www.wescheme.org/).

You also might take a look at Picturing Programs (http://picturingprograms.com/) and How to Design Programs (http://www.htdp.org/). Both of those may be more advanced than what you would want to start with, but they are both focused on teaching computer science concepts more than the particular language and both are aimed at beginners without any background with code.

It was one of the more meaningful things that I've ever done and was nothing short of hard.

Here are the things I've learned teaching my siblings full stack development in a few months.

You have to be patient, programming is complex and takes time. Sometimes you have to re-introduce the basics multiple times and hold their hand along the way as they try to connect the dots.

Offer them free food, support their interest, help them with their school work, reduce their stress levels, and take a keen interest in their hobbies

Build something right away, and introduce theory immediately after the project is finished. When introducing new concept explain it in an ELI5 fashion.

Give them multiple resources. Sometimes one source of knowledge is not good enough and giving them other resources not only helps with repetition, but it gives them other places that will explain the same topic in a different manner.

It was easy for the students to get started because it was connected to math that they already knew. Just different notation.

We use a web-based interface based on glot.io that was popular on HN a while back. The code is run server-side in docker containers.

Source code and screenshots: https://github.com/umutisik/mathvas

Web site: https://www.mathvas.com login details if you don't want to sign up: email: misik@uci.edu password: guestguest

1) Force them to learn how to navigate filesystems, the basics of file-based config, how to find and download files, and basic networking to make their video games work.

2) Give them little money, but a decent Internet connection, and make 3rd party private discussion forum solutions expensive, so they have to learn Linux and DNS and how to configure a webserver and a database and one or more scripting languages to stand up a discussion forum for their friends.

3) Make doing similar things for others pay way better than anything else they can do, even if they don't really like doing it 40 hours a week. Make this be true year after year.

I can vouch that this will work.

Because those steps would totaly turn me off.

I doubt I'm even close to the only developer who ended up here because it was easy to end up in a computer-related learning loop just trying to get video games (or Encarta, or that Win98 upgrade, or your fancy new dial-up connection, or whatever) to work, there were fewer easy distractions at the time, and that skillset originally picked up while trying to play video games provided surprisingly easy entry into a career path that was both (much) easier and (way) better-paying than the things we might actually want to do with our lives. Hard to get off that track when you're in high school and already falling into (relatively, compared to your peers) high-paying jobs.

Point is, don't make the goal (for the kid) "learn to program". Make the goal "do thing that's fun (but you'll have to learn to do computer-stuff/programming to get there)" The ones for whom "learn to program so... you can program" is an effective motivator probably don't need much help other than a finger pointing the right direction.

I have no experience in teaching kids how to code, but I have quite big experience in working with kids in scouting, and what I can advise is to do with your students things that really work, and are not considered "boring" - like controlling LED lights, "hacking" websites with dev tools, making computers in Minecraft, etc. Your mission should be to open their minds and spark a passion to coding, then they'll learn a lot on their own and will have own ideas for projects.

Here are the main things I have figured out (3.5 years, ~6,000 kids in 8 states): - It has to be fun. Lots of people have said this already, but I have tried and failed starting with academic rigor. Hello world was a psychological payoff in the past, but for this generation it's more like a multiplayer video game (easy on scratch) or fake hacking a news website (people have said this above) - It has to be social. Anyone can get online and teach themselves, but most people won't. We hold weekly meetings at public libraries where the librarians facilitate (they don't know how to code) and the kids teach themselves. Someone mentioned Sugata Mitra +1. - It has to be inspiring. I try to help the kids feel part of a movement, like for example getting the governor to talk at a hackathon, and hand out expensive prizes. But not all kids care about that stuff, and the goal is to figure out what they care about and show them how coding can help. Art, business, sports, etc.

To the original post - I know a lot of inner city, rural and tribal libraries that would LOVE to have a shot at those donated laptops.

Another project was using arduinos -- and I even got them writing C, which more or less worked. You didn't need too much code to blink a light and they loved that. The mix of coding and the hands-on wiring up their breadboards kept it engaging. We did a little project where the light blinked with a frequency related to a temperature sensor, so when you put your finger on it, it would blink faster. One kid had the grand idea of having it blink faster when cooler and slower when warmer, and watching him figure out the math was great.

Perhaps something to explore as a platform as well as it's not too expensive and comes with what you need to hack around.

It comes with Minecraft Py installed and has a few tasks to customize a level, character, etc. Python dev tools comes installed as well as Scratch and other exercises.

The idea of gamifying tasks across the platform is interesting especially if you think of a class of folks and a leaderboard or something - maybe not something to stress but some folks like competition more than others to drive them to learn.

https://kano.me/store/us/products/kano-complete

Lately I've reset the learning process focusing more on basics (networking, files, processes, utilities, etc) rather than programming.

You can also get things up and running really quickly with LOVE2d and Lua. love2d.org

There is a more advanced class that teaches javascript.

It is an extremely rick environment..

Some other thing could be Scratch/Kara, but I'm not sure if it exists in english and personally I don't like it.

In that case Python is a good choice. It's the #1 language in education world wide. I used it to teach programming to my son. It is free, low threshold, and I've earned a living with it for many years.

Some experimentation can be done on-line without installing anything.

https://trinket.io/

http://www.transcrypt.org/live/turtle_site/turtle_site.html

But of course in remote places there may be no fast internet connection.

When I teach programming to a group, installation of software always costs lots of time. So it's important to preinstall what the children need, in a more or less protected way, e.g. administrator privilege. Otherwise they'll probably cripple their system accidentally in no time.

The book I wrote is designed for self-study and seems to work pretty well for some kids.

More details on my blog here: http://grahammitchell.com/writings/how-i-teach-beginners.htm...

In his words (paraphrasing, since this was from a phone call): "I was a professional Java programmer for eight years and now I can't stand Java. There's no way I could deal with it long enough to write a Java textbook."

Easy to use code editor with live preview, fun starter projects to remix, easy to follow tutorials.

https://www.codeclub.org.uk

I've been working indirectly with school districts doing this for a couple years now, and have seen great results from curriculum very similar to this -- https://code.org/educate/curriculum/elementary-school#overvi...

There are other courses for different ages, too. Not sure what age groups you are looking at...

Once they know computational thought, THEN teach them how to code for an app.

I had a lot of success with 'unplugged' computer science activities. Basically, any activity without computers. Let's learn what an algorithm is. Let's play with binary and make a 'secret code'. These activities are engaging and teach something worthwhile. It's very easy to get bogged down with tools, syntax and minutia when actually programming. For younger age ranges definitely try some computerless lessons.

http://csunplugged.org/

It's available as an ebook as well as in paper. Short pitch: don't just learn to code by typing out existing code, learn how to think algorithmically and write your own code instead. Learn Scratch and Python side by side, seeing the same Computer Science concept in one and then the other. As well as the reviews, I've heard great anecdotal feedback.

Full disclosure: I wrote it. If I could get you a discount, I would, but I don't have that kind of sway with the publisher.

After some of that, you can move on to JS where they'll actually understand programming logic. I built a site to teach people to code the web. Maybe it'll help you a bit: https://enlight.ml

This is a little more advanced, obviously, so it's not a great activity for total beginners. However, once a kid learns that they can make exploding blocks just by writing about 5 lines of code, they're totally hooked.

It also gives them an initial idea as to what real software looks like. Once that is demystified, their confidence as coders increases substantially.

I've been planning on using Mozilla's Learning program (https://learning.mozilla.org/en-US/) a shot.

It's 2 separate sessions (1 for each age group) and 2 weeks in total. I have already outlined my plan based on it that I'm happy to share.

Does anyone have experience using their platform - share some thoughts?

I also used AppInventor, an online platform by MIT, let's you code visually in the browser, might be worth checking out.

Finally, show them this video: http://www.gamasutra.com/view/news/178938/Video_Is_your_game...

* Robot Turtles

* Robo Rally

* Colt Express

* River Dragons

* Walk the Plank!

* Mechs vs Minions

Get them playing the games, and then after they're enjoying themselves and having fun, explain how it relates to programming, and replace the actions in the games with functions ("actions") you can do in apps.

It was my first time doing anything like that and found that CodeClub were really supportive and had a heap of resources for us to use.

Worth a look: https://www.codeclubworld.org

Code club is a volunteer lead international coding club, maybe see if you have any local clubs that you can support or if you can find some people that would be happy volunteering a couple of hours every week to run one at a local library (or similar).

All of the resources use web technologies, so they can learn python through a browser at a library computer without needing their own resources.

Another thing I have been part of is OMG Tech![1] which holds events every two months with the aim of exposing children to tech that they wouldn't have experienced otherwise. So imagine taking a bunch of kids from low decile schools and having fun with 3d printing, robotics, coding, science experiments and more. The theory being that a lot of kids don't go into tech because they just don't know about it, have never experienced or think it is just too hard. So just showing them that they can do this really cool stuff goes a long way.

[0] - http://projects.codeclubworld.org/ [1] - https://omgtech.co.nz/what-we-do-omgtech/

https://medium.com/@eric2.71828/your-journey-is-important-sh...

https://code.org/learn

I build tools for teaching adults to code, but recently started volunteering for a non-profit that provides a couple hours a week for kids to come in and learn HTML, CSS, javascript. It's 75% them trying to play minecraft and roblox, but seeing a kid whip open the chrome inspector is pretty inspiring.

Doing it on paper by hand first is more important then it sounds, so they can really understand a)what they are coding, b)how fricking awesome computers really are.

https://www.youtube.com/watch?v=leBEFaVHllE&t=89s

was a pretty smart way to start out. Its possibly the opposite of what you want as it is completely unrelated to tools/manuals/etc.

Specially, in remote areas where there is low/no connectivity, as Web Maker works offline!

And yes inspect element is gold.

Machines will code for us. I think we should push the vision further. We always try to apply the present for the future. The real future for these kids is not coding!

Starts at the very beginning, with a lot of variety in paths and lessons. Self-paced and gamified.

Not sure about the cost.

https://www.ted.com/talks/sugata_mitra_shows_how_kids_teach_...

We run an after school classes program in Barcelona, Spain. Where we teach kids from age 4-15 "programming" or computational thinking.

Depending on age group there are different tools, and starting with the really young ones, we use tools like Hopscotch and other simpler coding apps, when we use technology. And even more fun is to learn about coding not even using any tech. So then we revert to using pen/paper/strings and ourselves, programming each other is a fun thing to do, and you can debug the code in group, and learn to understand how computer operates, and how to give orders.

Once the kids get slightly older, we use to go straight to scratch, (this is the first stop we tend to go to regardless of age if anyone is new, just to grasp concepts) This will not take to long if the kids are older than 10.

But even from 6 years of age we've seen enormous potential in using scratch, kids love it, it's visual in the output, super versatile in what you can do (we get blown away by the kids all the time). And you can indeed build very complex things with scratch, as well as you can produce a pong game in matter of minutes.

Main take away, if you want the kids engaged, get them super comfortable in Scratch, and get them to understand problem solving using computational thinking, rather than go straight to the browser and manipulate the DOM, that's not learning kids how to code, thats like peeking and changing values, not really getting to the core of programming.

Once the kids are comfortable in understanding that one thing can be solved in more than 10 ways, and that no real way is the right way (except if it is). Than make an introduction to text based programming, either looking inside scratch code, or by looking at something in the visual spectrum, like processing, this is a great first step and good jump from scratch. And it's easy to build on top of this and move into javascript.

When I'm mentioning age groups it's only if they have zero prior knowledge about coding, we have 6 years old that program as good as 12 years old but the 6 year old kids have been doing it for a year or more and the 12 year olds are just a couple of weeks into classes.

So it's also about checking the temperature on knowledge. Once you start moving up the ladder on text based programming, it's important to understand how to keep the vast majority interested, and not just the .consoleLog(); persons interested. Keep in mind that programming comes in many shades, and not everyone is hard core math nerd loving, but still can be terrific problem solvers, if given the right tools to do so.

I would say the biggest take-away for us since starting KidsHackClub.com is that make sure it's fun, do not indulge in long demos, or make complex things, and show of big projects, it wont get the kids into coding, it will scare them away. So start small, and build up as time goes, and make things that are visual, no-one enjoys staring at lines of intigers counting in the console, sorry peps, it's kids from the touch generation, they have played with phones and tablets since they where born.

Would love to chat more, just hit me up on twitter @LinusEkenstam or @KidsHackClub and we can also do email, but ping me on Twitter and we can hook up.

It's "classroom-ready", gives instant feedback and would be quite fun.

Easy as HTML, with option of adding more complexity via javascript. Very rewarding from the start, children get into VR from the very beginning.

resources: http://kata.coderdojo.com/wiki/Home_Page

Teach them what data is: numbers, strings of characters, true or false statements. Let them play in the interpreter. Let them see the computer work for them. Teach them that a variable is just the name of a box and the value is the contents.

Then introduce tables. Just like a set of boxes with labels.

Then simple control flow. Now you can introduce them to Love2d and start them off making simple graphics programs.

Eight hours or so later, they can code small games using Love and will understand each line. Then you can leave them to their own devices and point them at further resources.

Stand back and see the fun :)

https://en.wikipedia.org/wiki/Logo_(programming_language)

My favorite for older kids is to find an open-source video game with easily modifiable parameters, like lives, enemy count, sizes, etc., Start by asking them to change various things - class nearly runs on auto-pilot before too long.