The COVID outbreak has disrupted our world in lots of different ways.

For CodeGrades, it meant our face-to-face work with young coders, in London, had to stop.

We had been meeting since the Autumn of 2019 to prepare both young coders and their ever enthusiastic parents for our initial syllabus of Python grades. Improvised venues included the Barbican, co-working spaces, the Tate Modern and the Royal Society of Arts. It was engaging, friendly and the candidates (no matter their age or level of experience) were a credit to themselves.

They had been building all sorts: from games, to websites to mobile apps. It's such a shame we couldn't complete the courses of study and have folks actually present their projects for grading.

We learned a huge amount from this remarkable group of young people and their parents. Because of their feedback, the syllabus was subsequently refined, various tools were updated (the Mu editor, and PyperCard) and we all naively looked forward to the soon-to-be-imminent easing of lock-down here in the UK.

Yet that didn't happen, and two year's later, the world has changed.

Instead CodeGrades has taken a different direction, and reviving this blog is evidence of this journey.

To cut a long story short,

• Lock-down afforded us the opportunity to connect with many folks in the wider Python community, all over the world, who were interested in our crazy experiment in coding education.
• They called our bluff about making the work we'd been doing accessible. So we put our code where our mouth is, and have a completely new web based version of CodeGrades.
• The assessment process has changed, but we believe it is actually better as a result of this adjustment.
• The new website is completely redesigned, rewritten and feature complete. It is currently undergoing technical alpha testing with trusted invited friends of the project, and we expect an open beta to be released later this summer.

It was always our intention for CodeGrades to be accessible to anyone, anywhere there's an internet connection, and lock-down forced our hand. Every cloud has a silver lining.

Finally, this is just the tip of a very large iceberg.

For instance, here's a sneak-peek of the rough-cut of our "elevator pitch" video (still in development):

Now that various pieces in a very complicated jigsaw puzzle are starting to fit together, expect much more regular updates via this blog, and our Twitter account.

See you soon. :-)

CodeGrades was recently on the Podcast.__init__ show where we had lots of fun exploring the links between music and coding education as a way to explain the concepts behind CodeGrades.

The host, Tobias, asked plenty of interesting questions, giving us a chance to explain and unpack the high-level aspects of the project, tell the story so far and describe the various upcoming milestones. We were also able to touch upon related projects such as the Mu beginner's code editor and PyperCard GUI framework, also aimed at beginner developers.

We were very pleased with Tobias's positive reaction to CodeGrades.

CodeGrades (initially) targets Python as a language for learning programming. This post explains why.

The most obvious answer is that the folks involved in CodeGrades are professional Python programmers. But there are more fundamental reasons why Python makes a great choice when first learning to write software, especially when compared to other programming languages.

A primary strength of Python is its readability. Python uses indentation to structure code, so how it looks and is presented tells us something about how the code works. Python also has remarkably few confusing special syntactic symbols to organise code.

Why is this important?

If, like me, you have taught learners with English as an additional language or who have a special educational need such as dyslexia, then you will know that Python's intuitive indentation is something people, the world over, all understand (no matter their human language background or potential barriers to educational engagement). A lack of confusing symbols, such as {, } and ; scattered around the code makes Python very easy to read compared to other languages. Furthermore, the indentation rules guide learners to present and write their code (no need to remember what all those confusing symbols mean).

Since you don't have to concentrate that much on how to read and write Python code, you can put more effort into actually understanding it. Anything that lowers the effort required to engage with programming in an educational context is a good thing. In terms of code accessibility for learners, Python is an excellent choice.

Another strength is that Python is a mostly obvious and simple language.

The names of things built into the language make sense (for example, "list" rather than "array" and "dictionary" rather than "hashtable"), the things built into the language are useful (the so-called batteries included approach) and often such features are implemented in a simple and intuitive way. This puts Python in a rather unique sweet spot: the language has enough features that it's useful, Python usually names these things in an obvious way (making them easy to discover) and using such features is often easy. Of course, there are aspects of Python for which such generalisations are false. However, when dealing with beginner developers, Python's combined strengths of usefulness, clarity and simplicity are an extraordinary advantage compared to pretty much all other text based programming languages.

Python also endeavours to do the "expected" thing. For instance, if I try to add a dictionary and a list Python will complain:

>>> {} + []
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'dict' and 'list'

Python is saying you can't use the + operand to sum together a dictionary and a list. This, I would argue, is the "expected" thing to do. When I ask myself, "what should be the answer to adding a dictionary and a list?" I can't think of a sensible answer. Summing really only makes when used with numeric values or as a short-hand way to "add" two strings of characters together (for example, "hel" + "lo" makes "hello").

Contrast this behaviour with JavaScript. Look what happens when I try the equivalent operation:

> {} + []
0

Of course the answer is obviously zero..!?!?!? I mean, what were you expecting it to be?

Here's some more fun. What happens when we switch around the summed terms?

> [] + {}
"[object Object]"

If you were expecting the same result and got a surprise when things were different, then you're demonstrating the importance of consistency (especially in an educational context -- this is an important aspect of building up internal mental models of how programming languages work).

Learning, by its very nature, involves making mistakes and realizing that mistakes have been made. Only then can behaviour be adjusted, mental models updated and progress made. If you're learning to code with a programming language that would rather make what appears to be a best guess at what you mean (like JavaScript), rather than complain about an obvious error, then all sorts of problems will pass unnoticed. Instead, you'll either continue with your mistaken or incomplete view of the programming world or you'll have to learn stuff like the rather tortuous rules used by JavaScript that cause {} + [] to equal 0 and [] + {} to equal [object Object] (whatever that may mean).

Python, on the other hand, will just (helpfully) complain about your mistakes. Please don't misconstrue my examples as an attack on JavaScript. The point is simple: different programming languages have different strengths and weaknesses (and often what appears as a strength in one context, is a weakness in another), and Python's preference to complain is (because it helps avoid misunderstandings) a good thing.

Such a focus also encourages both learners and professionals alike to create understandable and coherent code. Such code is easier to maintain and less likely to contain bugs (because many bugs are caused by misunderstanding what the code is actually doing compared to what you mistakenly think it ought to be doing). Python is powerful because it allows folks to simply state their ideas in coherent code. This, once again, is an extraordinary advantage in an educational context since learners can focus on the problem in hand rather than having to create, configure and build "boilerplate" code needed before anything useful can be accomplished (a rather demoralizing activity).

Python is also a real programming language. By this I mean it is not just some sort of educational tool such as Scratch and other block based projects. The skills and knowledge gained by learning Python are economically valuable and useful in many vocations. Put simply, learning Python has professional value in many disciplines. The reach of Python is also an advantage. You'll find Python running on all sorts of different platforms (from desktop operating systems to server farms "in the cloud") and devices (from your laptop to an embedded device no bigger than your finger nail) to fulfil all sorts of tasks (from helping to render state-of-the-art computer generated special effects in films, or processing data captured from space telescopes and scripting computer games to, running some of the busiest websites in the world).

It turns out that learning Python gives you a useful and widely applicable skill!

Finally, there is the Python community. It has been my happy experience that many folk in the Python community are welcoming, friendly and work in a spirit of open, supportive and respectful collaboration. My hope is that CodeGrades can go some way to help continue such a spirit in new programmers by engaging with those who share a constructive passion for programming education in the wider Python community. While not a unique feature, the focus on and openness to beginner programmers and new community members is certainly a great strength of the wider Python community.

However, like all communities, the Python community also contains thoughtless, ignorant and (alas) nasty folk. Sometimes things go wrong, causing pain for some or all involved. CodeGrades acknowledges such experiences and views them as sadly inevitable. We believe it important to foster in CodeGrades participants a constructive, respectful and honest outlook and promote expectations of open, safe and friendly collaboration. Such expectations for the behaviour of code mentors and candidates alike, while preparing for and taking part in the grading process, reflect our belief that CodeGrades isn't just about learning technical skills. CodeGrades is a way to cultivate and foster the social skills and maturity needed to deal with the inevitable problems that may arise. CodeGrades isn't just about learning to code, it's also about learning to flourish in a technical community.

So, why Python? In conclusion: we know it already, it's a powerful language, it's a valuable skill and it has an amazing community which is fertile for promoting the flourishing of beginner programmers.

Finally, all of the Python positives described above demonstrate the thoughtful efforts and formidable technical skill of a huge number of folk within the Python community. CodeGrades would like to publicly thank all involved. It is our sincere hope that if our CodeGrades experiment is a success, we can give back to this wonderful community.

This is a blog about CodeGrades, an experiment to help folks learn about programming (initially in Python). We'll use it to celebrate the successes, learn from the failures and reflect upon the feedback of participants. We'll also share project news here too.

So, what are CodeGrades?

At a time when technology is finding its way into every aspect of our lives many folks want to be more than just passive consumers of technology. They feel a desire to become creators of technology. They want to take control of their digital world. They want the skills to make their technology reflect their own needs.

This is where CodeGrades come in...

CodeGrades are a programming version of time-proven techniques like music grades or belts in martial arts. Learners level up by applying the knowledge and skills needed for each grade to their own fun, interesting and challenging coding projects. Learners present their projects to professional software developers who assess the projects against the criteria for the grade being taken and provide a set of marks and written feedback so the learner can see where they're doing well, what needs to improve and what their next steps may be.

CodeGrades are eight cumulative steps for learning how to write code. The first grade is easy enough for most people to take as a first step into programming. The eighth grade is of equivalent standard to the skills and knowledge needed to be an effective junior professional software developer. The middle grades bridge the way so the skill gaps between each of the grades is achievable. They're like stepping stones into coding, or perhaps a modern day Gradus ad Parnassum.

The syllabus for CodeGrades is written by professional software developers. The grades reflect current best practice found in the software industry. They offer a framework for sustained and structured long term learning to write code. All the resources associated with CodeGrades are free, learners only pay to take the grading. Grades will be competitively priced and will certainly not cost the many thousands needed to attend a code bootcamp.

Passing a grade is undeniable evidence that an expert programmer believes the learner has attained the level of competence, knowledge and skill for the grade taken. Nobody can take that achievement away. It's something to be celebrated and gives learners the confidence and momentum to continue on their path to programming mastery.

The professional developers who assess the candidates in a grading (we call them code mentors because that sounds more friendly than examiners) are paid for their time at a level comensurate to that of a senior software engineer. We like to think this may be an alternative source of income for FLOSS developers who want to concentrate on their software projects rather than work in an office.

That's it in a nutshell.

It's early days but we have already successfully graduated a first cohort of learners through "grade 1 Python" (with better than expected outcomes). We have just started a second cohort of learners to test the new syllabus (more on that soon) and hope to engage with further test cohorts over the summer. Eventually we will open up our website so learners will be able to book and pay for grading. We expect this to happen by the end of 2019 at the latest.

There is still much to do! If you think you could support our work, or perhaps you have feedback or maybe want to get more involved, please don't hesitate to get in touch via the email address at the bottom of this page.

Onwards and upwards.