Apple launches Swift Playgrounds for iPad to teach kids to code
techcrunch.com
techcrunch.com
https://itunes.apple.com/us/app/scratchjr/id895485086?mt=8
For children who are older or more advanced:
Codea https://itunes.apple.com/us/app/codify/id439571171
For more of a game-like environment:
Lightbot
https://itunes.apple.com/us/app/lightbot-programming-puzzles...
It's a bit more visual programming rather than actual code, but programming concepts still apply.
We're being used by hundreds of schools around the world teaching kids to code :).
I don't doubt that kids are smart enough to wade through it all, but if you put enough obstacles in their path then they're going to wander off and do something more interesting. It also raises the question of whether you're teaching kids programming for the sake of programming (in which case you'd rather use any of the myriad languages that have been designed for young children), or if you're teaching kids programming for the sake of helping them solve some problem or achieve some task (in which case you'd probably pick a language with a more specific focus), or whether you're just teaching them programming just for the sake of adding to the ranks of the software industry ten years from now.
The fact is that those are surface details that are far less likely to tank your understanding of what's going on than basic problems understanding logic and execution flow. When I see beginners struggle, it's not because they've been given sigils they don't understand (it'd be almost impossible not to: even using words like 'or' and 'and' carry various secondary meanings unique to programming and/or formal logic), but because they're having trouble building a meaningful mental model of the execution of the program.
Live visualizations help a lot with that fundamental problem. From there you can learn the details. I think this way around is far more successful.
Fundamentally, this argument's been had over and over and over again, and in the end the languages people learn are the languages people use. BASIC is probably the most successful 'learning language' ever, but it became successful in environments where people were using it for productive work (as the boot rom environment on older computers and with visual basic). Likewise, Pascal only became popular when it became possible to use it for productive work (thanks to Borland Pascal and later Delphi).
Otherwise, allegedly 'easier to learn' languages lose every time to the ones people can move from success to success all the way from learning to productive work.
> basic problems understanding logic and execution flow
I know I reached this stage as a teenager when trying to learn C++ (because I wanted to make video games, you see, and everyone told me this was the only language to use), and trying to perform even the simplest operations was piled under layers and layers of seemingly-arbitrary nonsense. I gave up and didn't touch C++ again until after college.
In all, I think there's survivorship bias at work here. We say that these things aren't a problem, that they aren't barriers to understanding, but the only people here in this discussion are the ones who haven't already become discouraged. It's no wonder when things are seen as not-a-problem by people who didn't have a problem with them.
But my argument was based on my observations of other people trying to learn. My experience learning was quite different from most that I've observed, and my observation has actually been that the way I learned is the one that works for fewer people. This is an area of interest for me, so I take opportunities to see how people learn as much as I can. If anything, the better argument against what I'm saying is that it's just anecdata, which is true. I'd welcome research to prove this one way or another, though.
Tools like this are quite unlike what I had available to me, and I think they are a much bigger step to creating learning environments for real computing than trying to shoehorn natural language into a box it just doesn't fit. We have been down that road so many times and it never works out the way proponents suggest it should.
You seem to be asserting that an abundance of jargon, unfamiliar symbols, and unintuitive names are no obstacle to people learning to program, but sit a first-timer down with Befunge or Malebolge and we'll see how far they get. :) User interface matters, and it especially matters to people who have not yet internalized all the latent, lingering idiosyncrasies of programming in general.
Traditionally it's been Pascal and Basic, but I think those aren't used much anymore. I learned Commodore Basic first then Pascal in High School and CS1 in college.
As for the language itself, it seems to have decent type-inferencing. So, kids won't get bogged down on a compiler not liking "String" vs. "string".
To really capture kids' imaginations, Apple needs to visual and auditory libraries loaded and ready to go in the Playground. Kids will immediate want to build something graphical or auditory.
It's an interesting experiment.
A) Literally everything is new to a kid, and if they can figure out how to play pokemon and minecraft, they can figure out what '||' means.
B) Why teach them one way to do things and force them to relearn it a few years later?
> B) Why teach them one way to do things and force them
> to relearn it a few years later?
It's easy to forget that our first exposure to programming involves a lot of fundamental concepts that are wholly incidental to the semantics of whatever language we're using. Trivial stuff like case sensitivity of identifiers (quite surprising to an enormous number of first-time programmers) as well as highly non-trivial stuff like setting up your programming environment and teaching people how to invoke the compiler/interpreter. Making the language itself small and intuitive, even if limited, goes a long way towards giving students a stone to cling to in the rushing river of unfamiliar concepts that they're being exposed to.
The things you quote are typically not much of an issue. Once you tell students what a string is, or you show them how to type | or ^ or & or whatever weird symbol, they typically remember it (of course, you'll get some "oh yeah I need to use that weird squiggly thing here, how do I type that again?" - and as a fun tidbit, students in 2016 have no problem remembering and typing the # symbol (aka a "hashtag") ).
The bigger issues come from more macro level things, like understanding that the code gets executed on a line by line basis and can't "read the future" (i.e. you can't use a variable if it's only declared 10 lines later), what scoping is, how to combine conditions together to make a loop that does what you want it to do, and so on.
This seems like a perfect way to get some wide testing of the compiler, coding keyboard, etc. I wonder what IDE enhancements we can expect from a touch interface.
Yes, there are.
> ...that aren't excruciating to use?
Oh. No, not really. Pythonista is the closest I've seen to an non-excruciating IDE on the iPad, but that's Python only. Link: http://omz-software.com/pythonista/
Swift Playground: http://www.apple.com/swift/playgrounds/
Codea: https://codea.io
I was definitely aware of, and inspired by Bret Victor's presentations (and certainly took some of his ideas for Codea). But those particular features were first in Codea before being replicated elsewhere.
A 12 year old I know wrote an app as a birthday gift for his grandfather who lived overseas. The app was simple and displayed the grandfather's age with various different effects. Unfortunately, he wrote the app for iOS and so there was no easy way to deliver the app to grandfather (the family tried to submit it to the app store but it was rejected).
At least Swift Playgrounds allows kids to share with one another. Just don't try to leave the playground.
Also the new coding keyboard looks interesting. A nice surprise from Apple.
All this will do is push down wages.
We don't need more programmers, we need a higher percentage with a strong background in math, and with a thorough understanding of the infrastructure underpinning ever application (operating systems, hardware, networking).
But what we instead get is another post every week of somebody complaining that reversing a binary tree is too hard, and not relevant to our profession.
Reason? That's true for the general population, too. This IMO isn't even targeted at people who will go into software engineering or even science degrees. Instead, I think the target audience is anybody who might benefit from occasional scripting, 'down' to for those who will not program at all, but may benefit from knowing a bit more about what programming entails.
If successful, it will allow those people to, for example, write better spreadsheets, for some of them to write the occasional script, and for those ending up as managers to be a bit better at managing the software side of their projects.
Basically, I think this aims at the rest of the world, like logo and smalltalk do/did. Of course, the open question is whether it will succed at that.
There's enough beginner material - the stumbling block is the reality programmers are living in.
Cute demos aren't changing that.
I've lamented in the past (here even, maybe) that the first computing devices many people get are primarily designed around consumption. Some types of content creation (particularly visual and audio, more limited textual), are very well enabled by these tablet interfaces, but that's not been the primary focus.
But programming them has long been difficult and required an external device. Many of my peers' young children are first given an iPad or similar device, not access to a Tandy 1000, Apple II, Commodore or similar computer that had a BASIC interpreter baked in. To an extent the fault (on iOS) is squarely on Apple's shoulders, as for a long time they explicitly made interpreters and such verboten on iOS. This is a nice turnaround on their part, and a potentially good tool to get programming into the hands of kids.
As a first introduction to programming python might be a bit too complicated, but there do seem to be some BASIC interpreter on the app store it seems
I'm pretty sure calculus is more difficult than intro to python :)
That's how I got started, was having a TI calculator with a full TI-BASIC programming language in it. I was sitting in my classes and programming games while listening to the teacher at the same time.
I wish there was something equivalent in modern devices, but devices in general are too sandboxed, and pretty much all require programming from the computer, which interferes with kids being able to code from wherever they're at, because they have to go and do what their parents/teachers/etc tell them to do.
Back then I could access the graphing calculator, from code, and draw my own graphics directly to it, or create native menus (great for choose your own adventure games), check key input realtime, all sorts of fun things. I don't know an existing mobile device that allows native access to things from code on the device, and that sucks.
On Android (without rooting or any other "magic") there are plenty of fairly complete programming environments with comprehensive access to device features (including at least one dialect of BASIC with fairly comprehensive access to sensors, etc.), and there are even dev environments where you can build Android apps on device.
iOS may be "too sandboxed" to allow as much freedom (back when I was using iOS, I remember some similar things, but they were much more restricted than what was on Android at the time, don't know how that has changed since), but if so that's an iOS thing, not a "modern devices" thing.
And that being said, really there should (also) be something built into every device, so everyone has it and can be curious what it is and can look it up and tinker with it. Having to download apps requires them to be actively looking for it, and every IDE is competing with each other and fracturing the community and support behind it. (They should exist as alternatives, I just want something built in also).