Fluency vs proficiency when teaching/learning programming (and ready-made assignments for your classroom)

There is a project called Language Hunters that provides a framework for learning human languages. The goal of the project is to help keep dying languages alive. They make a very interesting distinction between fluency in a language and proficiency in a language.

Fluency is what you can say without thinking about how to say it. Or perhaps, what you can say when you’re woken up in the middle of the night with a flashlight in your face.

You can be fluent at a low level of proficiency. This was a bit of an epiphany to me.

The language hunters operate with four levels of proficiency in a language. They call it Travels with Charlie (video).

The first level is where you can use simple phrases–single concrete ideas. “Burger”. “Soda”. “Good food”.

The second level is where you can communicate in full, simple sentences. “Where is the library?” “Walk straight ahead until you get to the tree. Then turn left.”

At the third level, you can tell simple stories. “Last night I went to see a movie. It was about two friends who hacked into computers to transfer money from rich people to poor people. Then one guy went out for pizza and the other guy got caught.”

At the forth level you can discuss complex ideas, including social, political, and economic topics.

These levels don’t map exactly to proficiency in a programming language, but the idea is useful. I gave a presentation at GopherCon this year, where I explore this topic in relation to the existing resources that teach the Go programming language.

One of the reasons I’ve spent so much time thinking about this is that for the past three years I’ve been working on a project, Exercism, that I think of as working towards fluency in a programming language at level 2 proficiency.

The project has lots and lots of small exercises. The exercises are tiny, self-contained, and they’re typically on a quite trivial topic. For example: count the occurrences of each word in a given sentence. Or figure out of two queens in a given configuration on an otherwise empty chess board could attack one another.

The project is popular with professional programmers who need to ramp up quickly in a new language for work, and it’s also popular with people who are in the early phases of learning how to program.

The goal is to give people enough little exercises that they could solve this type of problem if someone woke them up in the middle of the night with a flashlight in their face.

It doesn’t teach large overarching design principles, or complex algorithms, or how to do large-scale projects, but it does take away a level of friction in learning the language so that when you start tackling bigger, more meaty topics, the student has more cognitive resources available. You’re not fighting against basics like “how to write a loop”, or “how to access the value for a given key in a dict/map/hash”.

Each exercise consists of a README and an automated test suite, which does a couple of things:

  1. It teaches students how to use the test driven development workflow.
  2. It gives the student a clear indication of when they’ve solved the problem (clear definition of “done”).

The project also encourages people to submit the solution and get feedback, and the feedback tends to center on idioms in the language, greater simplicity and readability, and better use of the core libraries for your language.

The project supports 33 languages at this time. Some languages have a lot of exercises (F# has 100), others have fewer (Java has 39).

For teachers, Exercism isn’t necessarily ideal, because it has its own janky command-line client, website, community, etc. It would be far better if the interface were simply git and GitHub.

Since the exercises themselves are all using the MIT license, I’ve started repackaging the exercises as stand-alone repositories that you can import via GitHub Classroom.

There are two formats. In one I’m sticking all the exercises in a single repository:

In the other format each individual exercise is it’s own repository:

I’m working on getting Ruby, Java, JavaScript, Go, Python, Swift, C#, Rust, and MIPS Assembly set up like this. Eventually we should get all the languages set up, but I don’t think a lot of people need languages like D and Nim and OCaml, so I’m trying to focus on the most common teaching languages first.

The exercises themselves have been solved by thousands of people on Exercism, but the idea of using them as assignments in the classroom is still new and unproven. I would love to work out the kinks to make them more generally useful to teachers and students.

If you are teaching basic programming, and you’re using GitHub Classroom, and you think these exercises would make good assignments for your students then I would love to hear from you. My email address is kytrinyx@github.com.

If you’re teaching a different language than the ones I listed, let me know. As long as we have that language on Exercism it should be a very simple manner to create the repositories that can be used with GitHub Classroom.


The distinction between fluency and proficiency is something I am also very interested in as a teacher of software engineering.

Several years ago, I started developing a pedagogy called “Athletic Software Engineering” whose goal was to help students develop fluency (as opposed to “googling their way to the solution”). I’ve used this approach in four or five courses so far with very good results, and it has been adopted by some of my colleagues as well. An introductory description of Athletic Software Engineering from its early days is here:


We just published a paper in the 29th IEEE conference on software engineering education and training, which you can read here:


1 Like

Hi Katrina Owen

I love the idea of exercism.io. When I started to create a bootcamp for our students who had not yet picked up Java sufficiently well (our university’s core teaching language) my idea was to use the exercises there as key way to learn.

In trying to work out what order the students should attempt the exercises I tried to map which concepts were required to complete each exercise. This was my attempt - https://docs.google.com/spreadsheets/d/1-jHZex1oMRk2eJxCkHfWK1MXaIFkVWQt2hUhDUih198/pubhtml?gid=0&single=true

What I found was

  1. There are relatively few exercises that are accessible for an absolute beginner. A fairly high proportion of them require string manipulation or use of Maps, which in the teaching material we use, aren’t introduced until later.

  2. A lot of the exercises are similar, e.g. processing a string to calculate some properties of the text within it.

What I did to combat this was to create exercises that a student can complete to introduce the more basic concepts (loops, conditions) and build up to their first exercism exercise. I also curated and ordered the exercism exercises so that they could avoid doing multiple similar exercises. The results is this - https://github.com/rcraggs/learn-some-java/

A similar idea is Koans https://github.com/ahmdrefat/awesome-koans although this lacks the social aspect that exercism.io does so well.


@rcraggs That’s fantastic!

We’re in the process of adding some more metadata to the config.json file so that we have information about topics and difficulty to help us in ordering the problems (see https://github.com/exercism/xjava/issues/125 for details).

Would you mind reposting this over in https://github.com/exercism/xjava/issues? I would love to improve the Exercism Java track in order to make it more accessible to beginners, as well as more interesting. The duplication is sometimes useful as a practice drill, but sometimes if things are too similar it’s just not worth it.

I forgot to say: I love koans. I was first introduced to them via the http://rubykoans.com back in the day.

thanks @kytrinyx I’ve posted it as an issue

@philipmjohnson Thanks for the link to Athletic Software Engineering—this is really interesting!