Why coding is the vanguard for modern learning

Time to read: 20 minutes

Note: Sorry this post is so long, I do have to start writing shorter posts… also I’m publishing this as is and plan to edit and improve the post over time, largely to clarify ideas that may be difficult for non-coder to understand. Please excuse the typos and other errors.


Screen Shot 2015-12-31 at 8.23.02 AM

Coding is coming to all of our schools with a lot of hype, inevitably there is push back from many different quarters for a variety of reasons… In my view these push backs are uninformed.  The code I know is the vanguard for modern learning, and for this reason, in my view, anyone interested in learning should take notice, and seek to understand, what is happening.


The Importance of the Learning Environment

We get so attune to curriculum and assessment as it is done in schools, we can begin to think that all learning, no matter how it occurs, produces the same results and the same outcomes. Nothing could be further from the truth.

It is fairly obvious that you can’t learn to play golf out in the ocean, and that you can’t learn to surf on the golf driving range. It is less obvious however that the learning environment in which, say math is learned, has the same effect on the developmental possibilities, not just the pedagogical effectiveness. Too often when we think about pedagogy, we think about it as if the outcomes of learning are fixed regardless of the pedagogical approach that is used. Our curriculum is so entrenched in school that we take it on face value that its progression points are natural and irrefutable. We cannot fathom, for example, that memorising time tables might not be required for every approach to learning maths, that there might be learning approaches and learning environments where students can develop deep understanding and the ability to use complex mathematical concepts and yet not be able to recall their times table facts in a fraction of a second.

It would be remiss of me to write about the learning environment without beginning with Vygotsky, who writing in The Problem of Development says that “the environment is the source of development.” The environment doesn’t just dictate the quality of development it dictates the actual development. In looking at the development of children, Vygotsky uses the development of speech to explain how the environment is crucial, and the source of development.

Seymour Papert’s vision for LOGO was as an immersive learning environment to experience and learn mathematics, and similarly to Vygotsky, Papert also spoke of learning [mathematics] in terms of learning a language. Papert worked towards creating a learning environment where students could learn not only as naturally as children learn french in France but also as completely as they learn french.

Papert argued that “school french” was very different, not only in form but also in content, from french spoken in France. In a french class in an english speaking country students are exposed to a small number of french speakers, and the differences between these speakers are minimal, in France learners are exposed to many different french speakers. In french class the vocabulary is static, in France not so. In France slang, idioms and vagaries of language (dependent on the speakers age and geography) are frequently used, in french class not so. Learning french in France isn’t just better because it is immersive, it is better because it is the real thing, french in french class is not the same learning environment and has vastly different, and poorer, qualitative learning outcomes.

LOGO wasn’t designed to teach students the school maths curriculum, LOGO was designed to produce vastly different and qualitatively better mathematical learning outcomes. LOGO enables students to pose mathematical based hypotheses, school maths doesn’t. School maths requires students to memorise time tables and algorithms to be successful, LOGO doesn’t. LOGO enables students to test their hypotheses themselves, school maths has the answers in the back of the textbook. LOGO isn’t a better way to learn school maths, it is better way to learn real maths. The result of learning maths in the LOGO environment to learning maths from a maths textbook produces qualitative different results, they aren’t two roads to the same end, they are two roads to different ends.

LOGO isn’t the only mathematical learning environment that enables qualitatively different results to the usual school math. Many schools, for example, use play based learning, such as playing shop, to enable children to explore mathematical concepts through buying, selling and the exchange of goods. Yet it would be to misunderstand the play-based learning environment to view it only through the curriculum progression points of patterns, sequences and the usual associated strategies. Instead you’ll most likely find, that these children are understanding and using traditionally more complex mathematical concepts such as supply and demand in order for them to play the game of shop. The mathematical play based environment enables completely different learning outcomes for these children that are not possible when children learn mathematics in traditional maths classrooms. Just because children can learn these different, historical more complex mathematical concepts, in LOGO and play-based learning environments does not mean it is possible that it is possible for all environments to produce these outcomes, just like the golf course and the ocean, different environments produce completely different learning outcomes.

Papert though it must be noted didn’t see the computer as a device for learning math, he saw the computer as an instrument whose music is ideas!

Of course, our understanding (or rather our lack of understanding) of mathematics makes it difficult to fully understand the magnitude of the what is possible in play-based, or LOGO based mathematical learning environments as opposed to traditional mathematics classroom approaches. When we reduce maths to the content outlined in the curriculum, and not the development of students who can expertly use maths to solve problems and make good decisions, we no longer need to care about how maths is best learned. Even worse, as we’re seeing with the current debate about coding, when we focus on the content and its merits, we engage in silly debates about which content has more value than other content, as opposed to what are the characteristics and motivations of the students we’re graduating and what problems will they want to, and what will they be able to solve.

Consider how fairy tales are used in classrooms to enable children to experience heightened emotional experiences, such as fear, sadness, elation, empathy, and so on, in a contrived, completely artificial situation. Without the contrived environment that fairy tales make possible, children wouldn’t have opportunities to learn to understand and express how they feel, and instead parents and teachers would need to wait until heightened emotions are present due to real life concerns. As such fairy tales offer developmental possibilities that are unique, and not possible in other learning environments. Not to mention much more appropriate and effective, and not to mention prepare children to emotionally cope with real life crises.


Given that when we change the learning environment, we change the possible learning outcomes, it would be reasonable to suggest that searching for new learning environments that offer qualitatively improved developmental possibilities would be a major focus for educators. Rather than trying to improve the effectiveness of existing learning environments, such as our traditional maths approaches, we should rather be taking a leaf from Papert’s book and pursuing new, qualitatively better, learning environments.

The web, by an order of magnitude, is a qualitatively better learning environment that what most learners currently have. Sure we can try to understand it in terms of traditional learning environments, but to do so is to completely underestimate the developmental possibilities. Possibilities that were previously unimaginable and impossible.

Coding, programming, software development (whatever we are calling it today) have always driven this new learning environment, as they sought to create the web we now have. Driven by their own learning and work needs these modern learners really are the vanguard for modern learning, and to learn how they learn is, in my opinion, currently the best way to understand the modern learning environment that is the web. I’m calling this learning, modern learning (borrowed from my friend Bruce Dixon), and not life long learning, or even just learning. I’m doing this to make it perfectly clear, that the learning outcomes from learning how to learn in the coding environment and with the current software development tools is qualitatively different to learning how to learn without the environment of coding. Modern learning is not possible without modern tools and modern learning environments.


Not that all coding is a magic bullet, and educators (usually with good intentions) can design learning environments that include coding but omit what actually makes it powerful learning. Just as educators might play maths games to help students memorise number facts, or use LOGO to teach recursion, or use edu-games for drill and practice.


The Importance of Tools in Development
If the learning environment is crucial, the tools we use are just as crucial. Tell a blind person that their walking cane is just a tool, a deaf person that their hearing aide is just a tool, or person who wears a prosthetic limb that it is just a tool. Tools enables us achieve what would otherwise be developmentally impossible. Tools enable the blind to see, the deaf to hear, and the incapacitated to walk.

Of course, it isn’t just using a tool that is developmentally important, it is using the tool to achieve success in activities that were previously impossible that makes tools developmentally important. Communication and sharing via the Internet has remarkably changed coding, but equally apparent are the tools that have developed and are now what makes software development as we now know it possible.

From open source to design patterns to devops to test driven development to MWWV frameworks to continuous integration to whatever is next on the horizon, new tools are produced that in turn produce new ways of working which in turn produce new beliefs and practices about software development. How coders now work and code is far removed from how they worked only a few years ago, and what is certain is that this trend will continue.


In an attempt to make sense of how developers are learning to develop, I am proposing loose learning environment types, as a way of understanding how learning to code isn’t acquiring skills but rather how coding enables development that is not possible without coding. As I do, I highlight the important developmental role tools play in each environment. Hopefully, this process will enable other educators to understand why many of us are excited about coding.

Note: I’m not going to switch from referring to code and coders to (software) development and (software) developers, which is a more accurate description of what coders do. However this does also pose a problem as I’m more interested in exploring the development of the developer (as a learner), as opposed to the development (of products) by the developer!


1. Feedback-Rich Learning
At its most basic, learning to code is learning to write scripts to solve computational problems.  To understand what a variable is, to learn to use if else statements and create logic loops, understand what functions are and what functions are commonly available, and how to write our own functions. This might be a simple line of code that splits first names and surnames in an excel column into two seperate columns, it might allow us to make a game in Scratch, build a redstone powered machine in Minecraft, or invent and create Facebook.

Code enables us to experiment. To imagine solutions or creations, and then see if we can in fact make them. Code enables us to solve problems that would otherwise be beyond our capacity because they would take far too long, or be difficult not to introduce mistakes. The computer language provides precision and consistency to a level beyond what we can usually do by hand.

The feedback that a coder receives as they code is immediate. Almost from the first single line of code, a developer can run their code and see the results. They receive feedback on what is working as expected and what isn’t. Papert’s LOGO and then later the very similar MicroWorlds, and now with Scratch, began with turtle drawing, drawings that we created by following the path of the path of the LOGO turtle. Scratch has since replaced the turtle with a much more Internet acceptable cat!

Screen Shot 2015-12-23 at 10.19.09 AM

The screenshot above shows the Scratch editor and interface. Coder select commands from the middle pane, drag them into the right pane to create the program, and then observe the results of the program in the left pane. Modify the code blocks on the right, click the green flag at the top of the left pane and immediately see the results of the code.

In this way coding bring mathematics to life. No longer is the truth sealed in the pages at the back of the text book, now the truth can be exposed click of the run or refresh button. For educators who understand the importance of feedback, the way students can test their mathematical ideas and immediately get feedback on these ideas should be compelling. Programming languages designed for kids like Scratch (shown above), Kodu Game Lab, and even Minecraft redstone don’t require typed code and therefore don’t need to provide additional methods beyond visual and audible checks.

Browsers, for example, via their developer tools enable coders to check whether their code is running as expected using a number of different tools. Looking at a browser’s developer tools is like lifting the bonnet on the car to see how the engine running. All modern browsers have developer modes which let you inspect the DOM by right clicking on the area of the screen that you’re interested in, shown below in the left pane. This shows the structure of the underlying html, and also allows designers to see the CSS markup that dictates the design elements, shown below in the smaller right pane. Some browsers also allow you to manually change the html and css markup in order to view the changes immediately without needing to refresh the browser window.

Screen Shot 2015-12-26 at 8.26.54 AM

Browsers also show the files that they use to build the page, this can be useful on a simple level to discover if all of the expected files are being successfully retrieved, because the filename or location isn’t correct, or some other server error.

Screen Shot 2015-12-26 at 8.35.20 AM


If schools wish to develop learners who can use new ways of experimentation and feedback they need to encourage learning environments in which students can use code to solve real problems. Of course, feedback on code also comes in more traditional avenues. The cost of obtaining feedback, in both time and money, is now extremely low and many organisations now use experimentation and feedback in place of detailed pre-planning. Eric Ries a leading thinker in entrepreneurship says learning is the only useful unit of progress for startups. Harold Jarche a leading thinker in personal knowledge management explains that “learning is the work, and the work is learning.” It must be noted that teaching is also headed down the feedback path with many education experts suggesting teachers can improve their practice by obtaining feedback on their effectiveness from their students.

Of course there are many other learning environments where feedback is also rich. Blogging is celebrated for the way it facilitates the exchange of ideas and provides feedback. YouTube, Twitter and other social media allows offers rich forms of feedback. Wearable technologies being used are being used in some universities to provide a rich source of feedback. Yet, none of these environments even come close to the feedback-rich environment that is coding


Unfortunately, when you start to understand how feedback-rich the environment is in which coders code, you begin to understand why educators don’t understand its power. As educators we’re obsessed with students mastering the single best strategies (assuming we actually believe there is more than one appropriate strategy.) Mottos such as “fail = first attempt in learning” sound as if teachers understand modern learning, yet failing isn’t necessarily feedback, you can fail and not learn anything. It also suggests feedback only happens at the conclusion of the learning activity, as opposed to throughout it.

Similarly, feedback from teachers, particularly when given as explicit instruction isn’t informative it is authoritative. Feedback-rich learning informs why something works or doesn’t work, or at least allows the learner to discover more on why an activity didn’t work as expected, as opposed to textbook learning which is only concerned with right and wrong.


2. Reuse-Rich Learning
Free and open source software and its derivatives (such as Creative Commons) have made the web that we now have possible. Without open source we wouldn’t have the web that we have today. Software development, as it is commonly now done, particularly creating apps and developing for the web, builds on the work of others. Unless the work is simple and trivial, a developers unique code is often only a small percentage of the code base. Open source licensing and its culture of reuse, makes this possible.

A typical website today will most likely build upon numerous open source code. A typical website might run on, or on variants of, the LAMP stack, and use backend and front-end frameworks, javascript libraries, css frameworks, icon libraries, as well as other code sourced from blogs, github and question and answer sites. All these pieces used by the developer to make a well functioning website, that would not be possible to create, due to complexity and time, without them.

WordPress, one of the greatest examples of building a business based on open source, is a wonderful model of how software architecture can promote reuse. Like 25% of the Internet, this site is a WordPress site, I haven’t written any of it’s code but if I wanted to change the functionality of the site it is easy to do. Which is why WordPress is so popular, developers use it to create all sorts of websites that were not part of the original WordPress blogging vision.

How does WordPress do this?

WordPress provides two main ways to modify it’s functionality, themes and plugins. It is crucial that WordPress provides these methods otherwise changes to the existing WordPress code would be lost every time an upgrade for WordPress is released. WordPress separates the presentation code, as themes, from the core code that provides the base functionality. This allows theme designers to easily customise the look on feel of the WordPress website by only replacing certain functionality.  If you’re happy with how are part of WordPress looks or works then leave it, if you’re not happy with how it looks or works write code to change it. And as a result tens of thousands of plugins and themes have been created and shared for other WordPress users to use.

The major way plugins and themes build on or change WordPress’ functionality is through its system of hooks and filters. WordPress theme files uses standard WordPress template tags to fetch and display the appropriate content to the browser. To display the title of the blog post the theme developer uses <?php the_title() ?>, to display the blog post’s content (text and pictures) the developers uses <?php the_content() ?>.

Say for example, I wanted to put a message at the bottom of each and every blog post on this blog.  I could edit every blog post or I could write a simple plugin that changes the post’s text before it is displayed. The code might look something like this:

add_filter( ‘the_content’, ‘thanks_for_reading’ );

function thanks_for_reading( $content ) {
$content = $content.”<p>Thanks for reading! If you liked the post, I’d love to hear from you by way of a comment.</p>”;
return $content;

I’m not going to step the reader through the code, for this is not the point of the article. The point is to demonstrate how WordPress is designed to be easily modified. The WordPress developers expect other developers will want to and need to modify the functionality of WordPress, and they have designed WordPress to make this really easy to do. WordPress has thousands of filters and hooks through which its functionality can be modified in order to meet the needs of the developer. It also has a replaceable theme and modifiable short code system that developers can also modify, but that is beyond the scope of this post…

Of course it should also noted that WordPress, like all web code, uses a lot of code created by other developers. They don’t just expect others to use their code, they also use the code of others.

jQuery is a javascript library that provides developers with a range of powerful functions for manipulating (showing, hiding, animating, searching) webpages and responding to user actions, such as clicking and dragging. It is used by a large proportion of all websites. If you visit BootStrap or Font Awesome you probably recognise what you see there. Interface components (buttons, menus, alerts, drop downs) and icons to create beautiful and functional websites, that work on both computers and mobile devices.

It would be wrong to assume that the code that reused by programmers is limited to large projects packaged for others and produced by organised teams. GitHub contains a staggering 2 million active repositories, which coders have used to share their code. GitHub makes it easy for anyone to grab a copy of someone else’s code (this is known as a fork) and make changes to it, enabling them to modify the code to suit their specific needs.

The reuse that happens in software development isn’t just limited to code. In 1994, the Gang of Four famously release the influential book Design Patterns: Elements of Reusable Object-Oriented Software, which presented 23 design patterns. A design pattern is a tried and tested reusable solution to a common software development problem. Typically a design pattern would also describe the rationale including pros and cons of the solution as well as the solution itself. As such, design patterns enable developers to focus on design decisions unique to their needs as opposed to designing solutions for common problems, such as connecting to a database.

The usefulness of design patterns outside of programming have been explored by others in a variety of other domains: a wiki of game design patternsbusiness model patterns, and even pedagogical patterns, tough note I’m not vouching for the quality of the pedagogical patterns! GitHub shows even more promise, examples such as GitHub for government, for writing a novel, and creating documentation that describes the standards that run the web.  Open source software licensing has inspired Creative Commons licensing where over 1 billion licensed works such as photos, writing, and other digital products have been licensed by their creators that allow others to remix and reuse, just as open source code is remixed and reused.


It would be easy to view reuse-rich learning, as simply saving time and effort, this is to completely misunderstand what is happening. Lawrence Lessig describes a remix and reuse culture as an ecology of creativity. For developers remixable and reusable code and design patterns offer opportunities to solve problems and create solutions that are outside their current developmental scope. When coders use jQuery they can create sites beyond their level of skill, when developers use BootStrap’s components they can create functional and visually beautiful sites that they wouldn’t be able to otherwise create, and when developers draw on solutions of known design patterns they can have confidence in a design solution without needing to exhaustively test its suitability.

Reuse-rich learning environments therefore allow learners to engage in successful activity beyond their current developmental possibilities. Which might not seem to be a big deal, except for the fact that is how our students need to learn outside of school. If we want to develop our students as learners who will be able to successfully operate in fields where as Howard Jarche says learning is THE work, we need to prepare them.


Screen Shot 2016-01-25 at 10.30.40 PM

The image above shows a Scratch sprite that can be saved (and then shared and imported) individually.

Of the programming languages designed for kids and education, Scratch is the only one I know of that is designed to encourage reuse and remixing. Most educationally designed programming languages let you share the whole file, however Scratch allows you to share and reuse the individual sprites containing images and code. Strangely, and disappointingly, though Scratch doesn’t allow you to share the stages in the same way. There are a lot of YouTube videos showing redstone programming creations, which is a poor form of reuse, hopefully down the track MineCraft will find ways to encourage reuse and remixing. You can see how I used reusable when I was a teacher Scratch sprites here, you can see how I used games design patterns to structure a course on designing games with Kodu Game Lab here.

Screen Shot 2016-01-25 at 10.36.17 PM

The image above shows a description of a Big Boss game design pattern found in Kodu Game Lab course.

Screen Shot 2016-01-25 at 10.37.29 PM

The image above shows a screenshot of the website the students used to share and remix Scratch sprites as they created maze games.

When you start to understand how reuse-rich the environment is that developers are developing software in, it is easy to understand why it educators might not want to understand them. Schools and educators are obsessed with individual knowledge and individual learning. Sure we might use collaborative activities but only so individual can learning how to collaborate…. individually.


3. Opinionated Learning
In the same way that code is shared for the reuse and betterment of all, so are tools and processes. Most tools and processes that are highly opinionated, that require (or even force) the developer to work in a certain way. Where workflows once dictated how developers choose tools to increase their productivity, increasingly developers are choosing tools based on ideological beliefs about the best way to solve complex problems.

Tools are still evaluated on how well they work, but now they are also evaluated on how well they fit and promote a developers philosophy of development. This has been most apparent in the uptake of GItHub and the move towards agile and continuous delivery as opposed to a linear or waterfall approach. Similarly, web-development in the last few years has seen a huge ideological shift in the rise and rise of single-page frameworks and the node.js server.

AngularJS (created at Google), BackBone and Ember appeared on the web development scene at roughly the same time, and all positioned themselves in contrast to jQuery. These frameworks appeared as a response to the need to create websites that acted more like apps. Rather than clicking links and fetching a whole new webpage from the server, these frameworks enabled the creation of single page webapps. They were all preceded by jQuery mobile, yet jQuery mobile, over time was largely scorned, because it doesn’t enforce a architectural structure. Angularjs et al do force a structure, specifically the Model-View-Controller structure. The Model View Controller is an architectural pattern (similar to the design patterns mentioned earlier) that segments the code base into three distinct areas, the model (the underlying data), the controller (the logic), and the view (the display.)

Screen Shot 2016-01-25 at 9.52.47 PM

The image above shows the MVC architectural pattern (taken from wikipedia)

Proponents of MVC frameworks, eschewed jQuery and its lack of clear design architecture, believing their code was not only quicker to create but also less likely to have bugs, easier to understand and maintain due to its superior underlying architecture. The supremacy of these MVC frameworks didn’t last that long, largely due to the concern over the speed of MVC frameworks particularly when displaying large amounts of content on mobile devices. Facebook famously stated that web apps would never be able to compete with native (downloaded from the app store) apps, that was until they created their own framework, which they called React.

Interestingly, though not surprisingly, the creators of React didn’t just create a framework they also created and released a new architectural pattern, which they named Flux. The team behind React knew they couldn’t just expect developers to use React because it is faster (and it is apparently a lot faster), they also knew they needed to communicate why they believe it is architecturally and philosophically superior.

Screen Shot 2016-01-25 at 9.53.14 PM

The image above shows Flux’s architectural pattern (taken from the Flux documentation.)

Over the last five years in web programming we’ve witnessed a shift in the web development community from jQuery to AngularJS (and its variants) to React. This has been a shift in the use of tools, but more importantly a philosophical shift. Not that everyone agrees with these shifts and philosophies, but I think it is fair to say that most do. Architecturally opinionated frameworks are the only opinionated tools that coders use, increasingly developers are using a range of opinionated tools to test, manage external libraries, and even tools to manage these tools.


Obviously, all tools are opinionated, for example design thinking is philosophically based on user’s point of view, and lean startup entrepreneurship is based on the philosophy of reducing waste while searching for a viable business model. Yet, what is unique about coding is the speed in which current philosophies are being questioned and new philosophies are emerging.


The image above shows Lean Startup’s Build Measure Lean loop.


Unfortunately, when you start to understand how opinionated the learning environment of developers is, you begin to understand why educators don’t get it. In the classrooms of our schools, the teacher is the point of truth, the expert. Students aren’t able to use the tools and architectures they use, in fact schools usually don’t want to let them know there are philosophical and design choices they can make. They are taught that there is a single right way to write a narrative or a persuasive text, or to solve a mathematical problem.


4. Continuously Evolving Learning
There are two reasons why the philosophies of web development are evolving. Firstly of course, is the continual advancements in the underlying technologies, but equally important is that developers are making their own tools to solve philosophical problems. It should be no surprise to learn that AngularJS was initially created a single developer to meet his own need, or that React was created by Facebook because web apps couldn’t compete with native apps. React needed AngularJS, in same way that AngularJS needed jQuery, neither of them were created from a theoretical or philosophical vacuum, new philosophies are created in the response of the shortcomings of the previous philosophies.

Don’t be fooled though into thinking though it is only the big companies and rock star programmers creating these tools, this is certainly not true.

It is because programmers can create the tools to challenge old philosophies and develop new philosophies. If you can believe that software is eating the world, and a quick look in any of the app stores or conference exhibition halls would suggest this is true, then it stands to reason that many domains will continue to be redefined (and philosophies shifted) by software-based tools.

From consumers to creators to (opinionated) tool makers.

In my view, increasingly we will witness a differentiation from those who can create new tools and those who can’t. Tools enable learners to succeed where they cannot succeed without the tools. Tool use also enables development (Vygotsky proved this a long time before the Internet), the development that results from the use of tools, in turn enables the possibility of future higher forms of development.

Coding therefore not only provides our students with opportunities to use and develop opinionated tools within the activity of coding, and to develop as such as modern learners. It also provides them with skills and experience in creating opinionated, philosophical based tools that can be used to transform other areas of learning. What sort tools? I can’t wait to see!


Unfortunately, when you start to understand how continuously evolving the learning environment of developers is, you begin to understand why educators don’t get it. Continuous evolution doesn’t fit, nor is it even slightly desirable in our curriculum model. What’s on the test is what matters, and what’s on the test doesn’t need to change.

The sad fact is that most teachers aren’t pedagogues, they’re soothsayers. They’re able to predict the future, not because they can, but because they don’t really believe what really matters in learning changes. They don’t really believe that our students might need new tools, or that creating new tools is even possible.

If teachers saw themselves as pedagogues rather than soothsayers, they’d stop making predictions of the future, such as “everyone doesn’t need to code,” but instead start to understand how technologies create new pedagogies and change exisiting ones. They’d read Papert’s Mindstorms, and seek to understand constructionism, the learning theory he developed and promoted. They’d also investigate Siemens’ Connectivism, a second learning theory that is inspired by technology… they might even start creating their own (opinionated) tools!