Isla: a programming language for young children | Hacker News Reader

Isla: a programming language for young children

github.com

84 pointsllambda72 comments

Hi, Mary here. I wrote Isla.

Just FYI, the Clojure version of the language is deprecated. For the last year, I have just been working on the JavaScript version:

https://github.com/maryrosecook/isla

My latest work has been on a programming environment and programming demos:

http://islalanguage.org/

Very interesting language!

Why are numbers quoted? It seems that many of the quotes could be optional (except when needed for parser disambiguation). From your examples:

  age is 1
  name is Mary
  friend is isla

You could also use '.' as an optional command delimiter (in addition to newline) for more prose like, such as:

  age is 1. name is Mary. friend is isla.

I like the period idea. I will try it.

Quotes are required around number literals to maintain consistency with string literals.

I'm partial to the advice to designate strings by the vertical bar instead of quotes. eg, write |Hello | input_name |. Nice to meet you|. This avoids the complication of escape formats until much later.

First, I want to be clear that I attribute noble motives to the designer of the language, and second that I recognize the hard work and effort that goes into a project like this.

My unanswered questions:

() What are the pedagogical principles upon which Isla is founded?

() How is the language tied to models of developmental psychology and to what models?

() For what age is the language appropriate?

() What does it do better than other similarly targeted languages, e.g. LOGO or Alice?

Isla looks as if it could be a game changer. I want to know more.

Sure thing.

1. No principles at all. I know little about education. Since the time I started Isla, and since the time I joined Hacker School as a facilitator, I have been learning as much as I can.

2. It is not tied to any models.

3. I am aiming the language at children who are just learning to read and write. So, children between 5 and 8.

4. I don't know enough, yet, to know if Isla is better than LOGO or Alice.

As far as I can tell Isla is simpler and probably better for younger children than LOGO. In my opinion LOGO is actually harder to learn than Python or Ruby for children (at least in my experience from the couple of children I was trying to teach)

Really? I remember picking up LOGO in Kindergarten. Can't even imagine working with a real language back then. How old were these children and how did you go about teaching them?

They were 6 and 10, python seemed easier for them to pick up because they had more control AKA I think the turtle and what not confused them. It was much easier for them to name everything themselves and do what they wanted.

> I am aiming the language at children who are just learning to read and write. So, children between 5 and 8.

The effect of that could be interesting to study. Would it cause difficulties for learning "real" grammar, or would exposure to a non-natural language help linguistic development (and to a lesser extent social and intellectual development more generally) as some studies have shown growing up around several natural languages does?

I second brudgers re: noble motives and hard work. :)

Follow up question: Have you stuck it in front of kids to see how they take to it?

Without being based in theory, I'm curious how the language works out in practice.

Most of the stuff I have learnt from the experiences of young children using Isla comes from second hand reports from parents. I have also tested it on non-programmer adults.

There are some definite mistakes in the language.

It uses named nouns, yet in real world, we usually refer to things with adjectives and types. We say "pass me the red apple", not "that apple is called Jimmy, now pass me Jimmy".

People get confused about the difference between strings and variables.

To define a function, you make a list and add built in functions to it. This is awkward.

Have you looked at Inform? There's a paper on its Web site [1] discussing its approach to modeling the world.

[1] http://inform7.com/learn/papers/

I was reminded of Inform and also the world modeling languages for AI systems like Cyc.

> It uses named nouns, yet in real world, we usually refer to things with adjectives and types. We say "pass me the red apple", not "that apple is called Jimmy, now pass me Jimmy".

That's an interesting insight. The "pass me the red apple" version seems a bit like a declarative query language.

Regarding referring. There's indexicality[1], no? (Bit of a pretentious word but it's the right word I think.) We point. (We point with our index finger, even). And we say, 'this', and 'that'. and 'these', and 'those'[2].

[1] http://en.wikipedia.org/wiki/Indexicality

[2] https://en.wikipedia.org/wiki/Demonstrative_adjective

In a way (when you think about it) "pass me the red apple" is too succinct. Maybe, "there is a red apple", "pass me it" would be expressible is Isla.

And honest to God. I swear I had an Isla-like mini-epiphany about 6 years ago where I wondered if a homoiconic computer language could be fashioned using white space instead of the () of the Lisps and use regular words instead mathematical symbols. It's interesting that you don't have numbers yet. Numbers (written arabic numerals) are very special words. Also it'd be nice considering Isla is using natural language that it speaks the kid's language - so at the start of a block the kid says, "hablo español" or "i speak english" and then all the do-ing words are in the correct language. And Isla needs to grök áccènts on variables for most European languages bar English, seems like it doesn't? (Sorry for nitpicks! Maybe I can help with the coding.)

I applaud your creativity.

A really great book you should read is Seymor Paperts Mindstorms. That will def inspire you and perhaps give you answers to some of the questions I would I agine you are pondering on right now.

Great work, will see what my four year old thinks.

I read and loved Mindstorms. Thanks for the recommendation. Would love to hear what your child thinks of Isla.

Two thoughts:

1. The distinction between words that occur directly and words that are quoted seems tricky for a 5yo. - is it really necessary?

2. I played about with Scratch with my eldest daughter when she was four and had next to no reading skills. Having the program be made of blocks with differing shapes and sizes made it possible for her to distinguish between commands without recognising the words. It occurs to me that it might work well for Isla code to have such a visual block structure - there would be a number of ways to realise this.

My daughters are 6 and 9 now: I'll get them to take a look in the next couple of days.

My daughter is 5 and just learning to read. If I get her going with Isla while she's doing kindergarten, can she attend Hacker School this summer?

I have a 2-yr old daughter, who is a bit young for this. But she named one of her dolls Isla Baila, which I'm taking as a good sign (either that, or she is going to be into dancing). Either way, looking forward to introducing her to a language like this when she is old enough.

I'm not sure if the 5-8 metric is correct. Most of the kids in my school had completely learned reading and writing by 6, and from then on wrote papers and essays without any difficulty (obviously, their vocabulary was not fully developed).

Have you considered tying your project in with the Racket folks. Matthies Felleisen (The Little Schemer) and that community have a considerable history in designing teaching languages, and Racket has substantial tools for developing languages tailored for learning, e.g. friendly error messages. It also has done a lot of heavy lifting for graphics, webserving and html.

It looks like Isla might slot in to the front end of the spectrum before BSL (Beginning Student Language).

Their middle school resources are here: http://racket-lang.org/learning.html

The technical reports linked from the page might also provide some background in the design of teaching languages.

I'm not a fan of languages designed "for children". They tend to be toy languages with limited expressibility, and libraries tend to be limited or nonexistent, severely limiting what the user can actually do with the language.

When I was in middle school, I first learned to program using BASIC. While BASIC was designed to be easier to use, it was still a full language designed for people to be productive in.

There are a whole host of languages that can be taught to (or independently learned by) children that have a clean, simple syntax. Why do we need to create another one with all the drawbacks a small, obscure language brings to the table when Ruby, Python, Scheme, etc exist and are just as easy to get started in, but much more powerful when you dig into them?

This comment assumes that Ruby, Python, and Scheme are easy enough for children to get started with, and I disagree with that assumption.

This is clearly, in my mind, better than the languages out there and I've only seen 3 lines.

Why do you disagree with it? Children have started on and understood them easily enough before.

Age 5-7 I spent figuring out to get sprites and music to work on a Commodore 64 that had no commands for it - it was all "POKE"'s to various memory locations. I was by no means unique for my generation, or even my class.

There's a huge number of us that are evidence that non-custom languages that were massive pains to program are easy enough for children to get started with.

Does Ruby, Python and Scheme have dark corners that are harder to understand than BASIC? Sure. Just like my C64 had all kinds of secrets I couldn't figure out by myself by POKE'ing randomly around at that age.

But I'd hazard a guess that most children will be mature enough at some point between 5 and 10 to be able to pick up the basics of pretty much any reasonably "normal" language if they have the motivation to try (for me it was seeing my dad program a simple game and wanting to be able to do the same thing). I'd hate to dumb it down unnecessarily.

> Scheme

Out of interest, what are the dark corners of Scheme? I've been using Racket for a while now and I've not come across any unexpected behaviour.

I suppose using non-idiomatic language elements such as mutations is a little odd but so far I've found nothing in the language which has surprised me.

I meant as in "stuff that is difficult for most 5-10 year olds (or so) to pick up easily on their own".

Oleg Kiselyov has done some exploration into the darker corners of Scheme. See things like:

How to Write Seemingly Unhygienic and Referentially Opaque Macros with Syntax-rules http://okmij.org/ftp/Scheme/macros.html#dirty-macros

I agree this language is easier than say Ruby or Python, but I do remember in 4th and 5th grade (8 to 10 uears old) learning a bit of BASIC from a couple books my father gave me. By the end of 5th grade I had written a calculator, a stopwatch and a couple other items in BASIC(programming exercises from the book). Then in high school I decided to learn some Ruby and had a good time tinkering with that and the things I learned from BASiC made it relatively easy.

The point is, a kid can pick up on that stuff if they want to learn it and BASIC is defiantly simple enough to "start with" and I would guess so is Python and Ruby which don't have too much semantic complexity.

I think your'e right.

The rule of thumb when it comes to "designed for children" goes something like this - if it does not offer progression toward the "adult" version then it is a toy.

I think making toys for children is a good idea. There are lots of examples in the physical world that don't progress towards the adult version that are fun and educational.

My problem with this is I'm not sure kids would find it fun. Something like HacketyHack that has integrated music and graphics feels like the kind of thing that would make the programs kids want to make. I'd also try Processing.

>I'm not a fan of languages designed "for children".

This, I think if I was helping I child get into programming I would get them started with QB64 [1], [2]. Then once they mastered that move on to HTML/CSS/JS and C or Go.

Personally I started with GWBASIC (at age 7 or 8), then moved to QBASIC, then learned VB, and then C/C++. Then in college I learned Java and via work learned C#. Nowdays I program full time in Go. (I of course have learned many other languages and platforms along the way , but those were always what I wrote in when left to my own devices).

1: https://en.wikipedia.org/wiki/QB64 2: http://www.qb64.net/

There is a fundamential principle of programming that I think most failed programmers can't wrap their head around at that is GIGO. When you start typing words, most people will have trouble with the rigorous and literal interpretation of words that are normally far more expressive and nebuluous when shared with people instead of computers. And, if I may step way out on a limb, this is especially difficult for women and seems to be a major tripping point for women who are otherwise more than bright enough to be good programmers. I think that Isla seems to be usable for any minimally literate kids (like 6 years old) and can impart GIGO while being really simple and fun. It's not a replacement for BASIC, but it can be seen as a stepping stone to it.

Suggestion: An IDE for children which only allows valid sentences to be inserted. E.g. they could click "create variable" or "create function call" button which would be a form/wizard/dialog to create it. This could be combined with "switch to advanced mode" button which would allow normal typing.

I actually wrote one of these when I was about 11. It was a menu-driven program written in BASIC that constructed (more or less) syntactically correct BASIC programs. It had a user interface similar to Multiplan, or the Microsoft Word of the day.

I eventually abandoned it because even as a kid, for me it was faster to type stuff in than to mess around with a program like this; and typing gave me access to the whole language rather than just what I had implemented in the menus so far.

I agree, this is what I tell non-programmers who are interested in learning more. I phrase it as: "Most people are too smart to program."

The way we talk to each other involves a lot of abstraction and context. It is very hard to speak __simply__ to a computer, unlike normal conversation.

I feel that Ruby, Python and BASIC are too complicated for five year olds.

My aim with Isla was to make a language that avoids as much programming jargon as possible, and assumes no prior familiarity with programming. This is why I made it natural-language-like and omitted punctuation from the syntax as far as possible.

I think 5 year olds should begin with graphical 'programming' environments like Klik or The Games Factory (those are old now, but I'm sure there are modern replacements). They offer simple event based programming and the children don't need to bother with syntax errors etc. They also have a built-in graphical edition so it's a bit more fun than just playing with a terminal.

After a few years it's easy to continue with basic-like languages.

If you're in middle school, you aren't the target market for languages designed for children.

The first "programming language" that I learned to use was LEGO Mindstorms, when I was around 8 years old. I think that was an absolutely AWESOME way to teach the principles of computer programs to children. (And transferring the programs to the robot was WIRELESS! Serial -> Infrared, that is)

Each "instruction" was represented on a computer as a "LEGO block". For example, there was a conditional block. You'd place it under a block that would return an output (like a "sense" command), and then you'd place two blocks below it for the True/False conditions. So basically you ended up building a tree of the logical structure of the program.

I think this style is the BEST way for children to learn programming. In fact, I think a block-like/tree-like structure is often a great way to think about program structure (even for advanced programs; Simulink is really great!).

Now, once you get comfortable with the constructs, actually dragging-and-dropping blocks often gets too slow. But for children, and for building simple programs, I think it's great.

I'm afraid that text-based languages are just unnecessarily difficult for children - only a small fraction of what you can type actually represents a valid program. The blocks allow programming without having to deal with these syntactic barriers. After all, when I program in a language like Haskell, 90% of my programming errors cause the program to fail to compile. These sorts of errors (syntax errors or type errors) can be prevented as the program is built with the block interface.

And while I'm extolling Mindstorms, another great thing about creating these programs was that you weren't just flipping bits on a computer; it was pretty satisfying to see a robot "in the real word" follow your commands.

Ha! I still have my Mindstorms set and I plan to knock the dust off of it in a few years when my son is old enough.

And not only that, but if you're already interested in playing with legos (as I was as a child, although mindstorms was windows only back then much to my chagrin!), what a great way to learn basic programming concepts without even realizing you're learning! You're not even interested in programming, you're adding extra functionality to something you already enjoy in a fun way.

It's like asking some one to learn how to do the rainbow kick move over the head with a soccer ball when they don't play soccer at all compared to when they do if that is an okay analogy.

> Write [cherry is a circle] below

I don't know pedagogy, but I like that objects have names and properties, which is concrete and comes from the physical world (and our language). However, I find some things about the language, environment, and also tutorials rather confusing.

In the shapes tutorial, for example, we name an object that doesn't exist yet. We also name the object "cherry", which is also a word for an object in English. We write [melon color is 'yellow'] when the object named "melon" is actually red. I also wonder why there is no visual indication of which object is which (why not label the objects with their name?).

More fundamentally, in Isla each text block is a command. Why are there no actions words (at least in these initial commands)? Just like objects, names, and properties are first class syntactic citizens, so should actions. I think this would clear up some of the weirdness above.

  # make circle named bob
  # set bob color RED
  # print bob color
  ... RED
  # print bob
  ... circle
  # move bob RIGHT
  # make square named alice
  # trash bob
  # copy alice named chris
  # make circle named alice
  ... oops, alice already exists!
  # print dan
  ... oops, dan doesn't exist!

I like your idea for making the set and creation commands more aware of time. I will think about this. Thanks a lot.

There are two things that I immediately think while looking at this language:

    1. If languages were syntactically easier to read, then we wouldn't need one that's made just for young children.
    2. This confirms my suspicion that "=" and "==" are damn harmful stupid syntax for assignment and equality.

When I get around to writing a language = won't be a word (or maybe it will be just for initial assignment). Assignment (or at least mutation) will be := and equality comparison will be ==.

Specifically what problem(s) are you trying to solve?

I'm writing a language that uses = for assignment and == for equality comparison. However, expressions and statement are syntactically separate, so that using the wrong symbol is always a syntax error.

The if(x=1) problem, and the problem that declaration/assignment and mutation look the same when they're actually very different. I don't think an expression/statement distinction is the right solution to this problem, based on my experience in e.g. python (where not being able to include statements in expressions makes a lot of code more cumbersome).

Expression/statement distinction can make some things more cumbersome, but it can also decrease complexity and cognitive load, easing maintenance burden. It's very easy to be too clever with nested statements.

Even without distinction, making it a compiler warning is very easy.

Yes, please make me hit three keys instead of one just to make an assignment.

It's still better than Java's `if (string1.equals(string2))`.

It would be interesting to see whether assignments or equality operations are performed more often across the board in programming. I can't tell which way my initial lean would be.

:= certainly makes things syntacticly clearer but really after a point = and == are so common and so natural, is it a problem that even needs to be solved?

Mutation/reassignment should be a rare thing that takes conscious effort, since it makes the code much harder to understand and reason about.

Is it really such a great idea to make languages that look more like English? From my experience, newcomers to programming pick up a lot of misconceptions about general programming from English-like syntax.

Well, there's actual research on it. Most of our intuitions about teaching and learning are wrong.

Google computer science education or check out SIGCSE

A year or two ago I created a very similar language [1] in collaboration with my kids, then aged 8 and 10. They had a lot of fun writing their own stories and "telling computers what to do". The oldest has since moved on to writing her own HTML and CSS. Hoping to keep the fire alive.

A few more ideas that I never got around to, feel free to take or leave them:

* A simple tool to draw characters. My kids liked Google drawings more than Paint. They didn't mind (at first) that the drawings weren't animated.

* Sharing stories with family and friends

* Drawing backgrounds, moving between scenes, animation editor.

* They liked the idea of writing a story, but very quickly wanted to build a game. An animation editor could introduce looping. Collisions could introduce conditional actions, etc.

Good luck. It's a lot of fun.

[1]: http://kevinbeaty.net/projects/storyturtle/

Isla... Isla Nublar... Jurassic Park... "This is a UNIX system, I know this!" It all makes perfect sense now...

1. Kudos for the very interesting initiative!

2. I was looking for a "natural syntax programming language" on Google and this is what showed up as the first result http://bglang.org/

3. If I might add something, I think what something like this would need is flexibility i.e. a more "freestyle" way of writing expressions. It would not only be much easier to use by children, it would also be a nice technical challenge for the language designer.

Some examples:

* sum of all numbers from 1 to 10

* x is 3; y is 15; print their greatest common divisor

* if folder has file 'file.txt' then put x in file

* print 5th fibonacci number

* c is circle, diameter 10; C is square, side 9; print maximum area c, C

* show bigger number 2/3, 1/2

The danger with a natural language-like programming language is that it gives the impression . This is impossible.

I want the advantages of a natural language-like syntax (easy to read, not scary) without the disadvantages (the impression that the computer will understand whatever you type). To do this, I intentionally made the syntax only support one grammatical form of each type of statement.

Is "Isla" pronounced "ila" (as in the "s" is silent)?

I ask because I'm sure my otherwise-literate 8-year-old would have trouble spelling the name without some coaching…

(edit: typo)

I love this and I think it's beautiful. Removing a lot of the symbols will make it far less scary and "techy". I'd really like to see it develop.

Why do you think the symbols are "scary and techy" to children?

They're scary to adults. As a scala programmer I wish there was a similar language that used words rather than punctuation.

I teach 5th grade science, and we do a solar system unit that is sometimes remedial for kids already testing/learning at grade level. I'm going to try giving the Isla planets page to students who finish early, and see if they can figure out Isla and create a replica of our solar system (without instruction/help), as a quick brain teaser for them.

Thanks :)

This is great! Keep it up! Grown ups have tons of languages to choose from, so should kids.

Great stuff, when I have a little person ill look for something like this. One suggestion: better errors.

If I was a kid and I saw this:

  #hi
  Expected [ \t\r] or [a-zA-Z0-9_] 
  but "\n" found.

I'd think that I broke something.

Isla needs a read function for inuut.

We don't have mathematics for children. Or English for children. Sure, the stuff taught to children is simple, but it isn't simple coz it's being taught to kids, it's simple because the basic building blocks of any body of knowledge are typically simple. If you wanted to teach English to an adult Chinese man who only knows the Chinese alphabet,you'd have to start of with the same things you'd teach a child. When someone sets out to create a programming language "for children", my fear is that you might try to "dumb down" the art and/or science of programming. I could be wrong, off course. And I haven't looked at this particular language, so I wouldn't know if this is the case here. I'm just not very comfortable with the premise of a programming language aimed at children. What is it about it that makes it for kids? That which makes it for kids vis a vis other languages is what worries me in the context of what the kids will learn vis a vis what they should eventually learn, which is the "adult" stuff. Try and imagine a painting course for kids or adults. Same concepts, technique's, brushes, etc. In the same way you don't have canvases or brushes for kids, I don't think you should have a programming language for kids. But like I said, I could be wrong.

You must have had a very atypical childhood and never interact with kids because there are tons of art supplies, picture books and "count the apples" type arithmetic books that are only for kids.

"Dumbed down" programming is still programming, just like dumbed down mathematics (2+2=4) is still mathematics, or dumbed down painting (finger painting) is still painting.

In each case, children are simply being presented with a limited subset of the entire subject, to accomodate the real physical differences between children and adults (less complex mental models, less fine motor skills, etc).

We can argue about which specific subset we should start with, but the fact that it's a subset is not inherently wrong.

Reply on news.ycombinator.com