Techie presents for the coder in your life!

You can read last year’s techie present guide here. Most of those ideas are still available and still great, but if you’re looking for something fresh we’ve rounded up some of the best techie gifts available below.

We’ve include links below to the best prices we can find at the time of writing, but we’re educators not consumer journalists, and we’d always encourage shopping around where possible. If you’re lucky enough to live near an electronics/maker shop we’d also encourage you to check out what they have on offer. Even if it costs a little more, there’s nothing quite like having an expert on hand to advise on your own specific needs!

Doodling Robot (Amazon; approx €17)

A simple and relatively cheap stocking filler, this kit is a great way for kids to learn about circuits and a great intro to the idea of robotics.

Recommended for ages 8+, the assembly should keep them busy all the way through Christmas morning.

Just make sure you’ve get plenty of paper - and that the robot isn’t let loose near any expensive carpets or rugs!

Raspberry Pi for Kids (Amazon; approx €16)

Coding books can be a mixed bag, but this one from Richard Wentk has been extremely well received (currently 4.3 stars on Amazon UK). Filled with approachable projects and suitable for ages 7-11, this is a great intro to some of the most popular programming languages in education today.

This is a great present for someone who may already have received a Raspberry Pi, but not be quite sure what to do with it. Also great for someone who’s getting one this year!

Raspberry Pi CanaKit (Amazon; approx €100)

There are tons of great Raspberry Pi kits available (for example this starter kit), but the CanaKit provides a great one box solution. Not only does it include the Raspberry Pi itself, it also comes with most of the kit required to build a huge range of projects and is a great introductory platform for both programming and electronics.

Note that although it’s technically possible to do plenty of fun things with a Raspberry Pi without a keyboard, mouse and monitor, we wouldn’t really suggest it, especially for beginners. Any old USB keyboard and mouse is fine, and any screen (including TV) with a HDMI port is fair game!

Star Wars Droid Inventor Kit (Amazon; approx €110)

Parents of a certain age will be just as excited as their kids at this one! A fully programmable R2D2 robot, standing 40cm high and controlled through a phone app.

This, one suspects, is the way we all wish we had learned to code!

Not included in the list above: an Academy of Code Gift Voucher, on foot of being almost too obvious to mention. The printable gift cert is particularly perfect if you’ve left your gift buying to the very last minute - you can even by on Christmas Day. We’re sure they won’t mind ;)

New Curriculum Highlights - Autumn 2018

Autumn courses now open for registration at Evening and weekend courses begin the week of September 10th, after-school tech clubs and other classes vary by venue.

Like redecorating a house or embarking on a new fitness regimen, curriculum development is a process which never really ends. There's always room for an improved exercise here, a different project over there - and perhaps some fresh flowers in the kitchen?

This summer we've been at the "knocking down walls and adding a basement extension" end of the spectrum, and as the new term approaches we're really happy with how things are shaping up. It's not finished (nor will it ever be, really), but there's tons there for students to look forward to in the new year. Here's a few of the highlights:

  • An all-new nine grade curriculum structure gives students and parents a clear roadmap of where they are today, and where we're aiming to get to in the future. Each grade takes one year to complete. Existing students will be slotted in at the appropriate stage of the new curriculum.
    • Grade 1: a "pre-coding" module. Currently scheduled for launch in January 2019, this is aimed at younger students (1st-2nd class) and brings together keyboard and mouse skills, internet safety, computational thinking and an introduction to coding through Scratch.
    • Grades 2-3: these are our "early coding" grades, aimed at those up to 4th class. These grades combine the foundational skills which are the focus of grade 1 with a variety of coding and electronics projects which include tasters of Python, HTML, Micro:bit and more.
    • Grades 4-6: our core coding curriculum. This is a refined version of our Processing curriculum from previous terms, and takes students from total beginners through to advanced coding concepts.
    • Grades 7-9: our advanced curriculum. These grades combine masterclasses in a variety of subjects (computer vision, Internet of Things, advanced OOP concepts and more) with student driven projects, culminating in a Masterpiece at the end of grade 9. We also have lots of other exciting plans for students at this level, and look forward to rolling them out as students reach these grades over the coming years.


  • Academy of Code Discovery Sessions: most lessons now integrate mini lessons on computer history, computers in society, how networks work (and how hackers use them), surveillance technology and more besides. This will give students a broader appreciation of technology generally - and it will integrate into every student's favourite part of class, the end of class kahoot quiz!
  • Community of Coders: our new curriculum integrates events and fun competitions which bring together coders from all of our venues, either virtually, with touch typing and mouse skills leaderboards and real-time multi-class quizzes, and with in-person coding events and exhibitions. 
  • 21st Century Teaching & Learning: the new curriculum integrates best practice from the latest education research, with a focus on collaboration, communication and presentation skills.
  • Industry Tips: we have integrated a range of "insider tips" from professional software developers on how to be a better programmer. These give students an insight into the real world of coding, and help us encourage students to follow "best practice" coding approaches by showing them how they help the coders produce great software.

We can't wait to hit the ground with the new curriculum in a few weeks time, and to hear what you all think about the changes!

Taste of Computer Science 2018

Our Taste of Computer Science (ToCS) course has a very simple goal. We want to give secondary school students, and in particular those already in senior cycle (4th-6th year) a taste of what a third level course in computer science will be like.

This is crucially different from other courses run at the Academy of Code and elsewhere. For younger students in particular, the goal is more so to get them interested in technology than anything else.


The proliferation of Scratch is a perfect example of this other approach. Scratch is a fantastic tool, and useful both from the perspective of makers and teachers, but no matter how hard you look you are unlikely to find any Scratch developer jobs on your friendly neighbourhood jobs board, and to our knowledge there is no third level computer science department which builds its degree course around Scratch.

Our ToCS curriculum is anchored by a Processing block, which is given two thirds of the total teaching time for the week. Processing is a Java-based language, which uses the industry-standard Java syntax and structure, as well as being widely used in introductory computer science courses at third level.

The Processing framework, built on Java, provides a fantastic environment for students to get to grips with coding for the first time, or a fantastic onwards step for those with experience in Scratch or similar languages.

The Processing framework, built on Java, provides a fantastic environment for students to get to grips with coding for the first time, or a fantastic onwards step for those with experience in Scratch or similar languages.

For this week-long ToCS course we’ve reshuffled our normal beginners material into eight lessons. The first seven are an hour each, and give students a whistlestop tour of the major building blocks of a coding language including variables, conditionals, loops, functions, etc. The final section of the course is a short project where students will build a simple game which they can then personalise and extend using the toolkit they have assembled throughout the week.

(Warning: some technical material ahead!)

The breakdown of lessons and learning outcomes is as follows (lessons 1-7 are each a single hour of instruction):

1) Introduction to coding - students make use of functions to draw shapes on screen. They will manipulate the size and position of the shapes by adjusting parameters. They will also colour the circles using RGB codes, and develop a basic understanding of program flow in the process. This lesson includes a revision of coordinate systems.


2) User input - students will be introduced to the idea of variables and loops here, and make use of them to have simple and composite shapes follow the mouse on-screen. They will also deepen their understanding of parameters by experimenting with sample code to produce simple abstract artwork.

3) Variables and animation - following the introduction to variables in the previous lesson, students will develop a greater understanding here of what variables are, how to use them, why to use them and what to call them. They will learn about different variable types, and make use of floats. They will manipulate those variables to produce very simple “animations” - moving shapes across the screen and in various predetermined patterns.

4) Logic and more user input - an introduction to if statements, one of the cornerstones of all programming languages. Students will produce simple movements and colour changes dependent on keyboard and mouse input from the user.


5) Keyboard movement - building on the previous lesson students will check for keyboard input using simple if statements, and move shapes in all directions on screen according to those keypresses.

6) End conditions - building on the previous two lessons students will create basic visual loops on screen, such as can be seen in many simple computer games (eg Snake).

7) Collision detection - students will use their knowledge of conditional logic and simple mathematics to detect collisions between two circles on screen. They will study how this can be used to build 2D games.

8) Final project - combining everything they have learned up to this point in the course students will produce a functioning game of their own design! Building on a roughly sketched plan students will make the game their own, both graphically and by adding their own unique gameplay features.


Other curriculum elements

Alongside the Processing material there are several other taster sessions throughout the week (HTML, computer hardware, electronics, Micro:bit programming), as well as a short careers talk and Q&A, where students can take the opportunity to find out more about what college and work might be like for someone pursuing computer science at third level.

What students get out of the course

By the end of the course students who have no previous coding experience will have an understanding of what it’s like to write and debug code, and what they can expect if they choose to pursue coding at third level. It will be hugely advantageous both to those who find that they really take to coding, and perhaps even more so to those who thought it would be for them and discover it isn’t. Better to discover that before starting into a multi-year commitment to a degree program!

Whichever direction they go, students will have gained a valuable insight into the world of computer science, which will stand to them regardless of the path they choose in life.

What about returning students

Returning students are at the core of our mission at the Academy of Code. We want every student who finishes one of our courses to be immediately chomping at the bit for the start of the next term!

For those in that boat we have written a whole new set of intermediate and advanced lessons and projects. ToCS will be a perfect environment for perfecting all sorts of finer details of coding, and using them to work on more advanced and interesting lessons and projects.

The Making of a Curriculum - Building a Curriculum the Academy of Code Way


In 2014, we set out to build the first version of what would ultimately become the Processing curriculum which still forms the backbone of our coding courses for students aged 10+. (You can see a good portion of that curriculum in various forms at

In doing so, we were looking to achieve a couple of key things. Most importantly, we wanted a curriculum which would give our students a really rigorous understanding of the building blocks of code. This meant that we didn’t shy away from material which was “too hard”. Rather we went and found ways of introducing it which made it more approachable for younger students, and (hopefully) made them want to understand it.

Secondly we wanted students to enjoy the lessons. It’s easy as a software developer (which all of the founding tutors were) to forget how coding isn’t just a “challenging” or “satisfying” activity. When presented in the right way, making a computer do what you want is really fun! Coding through Processing in particular is great for this, as it strikes such a great balance between letting you really control what’s happening - it is proper Java code we’re playing with, not some artificially easy teaching sandbox - but also not getting in your way where it doesn’t have to.

Finally we wanted to give students a real sense of progression. This last one has proved trickiest in many ways, and those of you who have been with us for a few years will remember various iterations of this, both in naming (“Stages”, “Grades” and more) and in recognition (wristbands, certificates, letters…). A large part of what has proved so tricky here is our determination that we will cater for as wide a range of students as possible, and that we will give plenty of freedom to students who want to power ahead to do just that.


In many respects the existing curriculum has served us extremely well, and indeed much of it will be rolled into the new curriculum, but there were several areas where we felt it was time for change. Not only that, the past four years have seen new curricula launched for computer science at both junior and senior cycle secondary school level, and the insights incorporated there also seemed worth bringing into our own curriculum as well.

What’s changing

The new curriculum will be organised around 9 grades, each of which will be made up of 5-10 (or more) individual learning units. Some of these learning units will build on previous grades, or other learning units in the same grade, while many others will be standalone or part of shorter series of learning units (such as website development, 3D printing, computer hardware, music tech, etc). Most modules will be completed on an individual basis, but some will involve working in pairs or small groups.

There is a lot more structural detail around this than the previous system, which was more focused on a linear progression through the core curriculum with the occasional unscheduled side-trip into web development, music tech, or something else!

To complete a grade, students will need to complete all the core learning units in that grade, as well as a certain number of the additional units. A given grade may have 5 core learning units and five optional units, and a student might have to complete all 5 core units, plus 3 of the 5 optional units, to progress. While coding remains the core of the curriculum, the overall curriculum will be more holistic than before, including “softer” elements such as web safety and computers in society, as well as technical but non-coding skills like image editing, 3d design and music technology.


Each module/grade will take approximately a year to get through, but some students may move faster or slower, and this will be catered to. Also catered for will be the completists, who want to collect the full set of grade 1 badges before progressing to grade 2.

Class groups will form around particular learning units, so for example you might have some students who have just started grade 3 working on a web tech unit with others who are almost finished module 3. This will keep things fresh for the students, while allowing us to deliver a varied curriculum with enough changes of pace to keep everyone engaged throughout the year. The flexibility in the curriculum will make it practical for us to provide this wider variety of material to different groups across multiple venues and times.

In terms of progressing through the grades, earlier grades will likely involve a simple teacher sign-off for progression. Later grades will include more formal assessments including capstone projects and formal testing. While the course will remain fun and engaging throughout, the later grades will require significant application on the part of students to progress, and we would envisage that in time an Academy of Code Grade 9 certificate could become a real asset to our students’ CVs!

What’s staying the same

The focus on coding first hasn’t changed - that’s the most important part! While we are introducing more “broad curriculum” topics, and hopefully allowing our students to experience a range of techie-but-not-coding material, our focus has and will always remain coding.

Java Processing will also remain our key language, at least for now, although in the medium term we will be looking at doing more Python and JavaScript with our students, to tie in with the Leaving Certificate programme.


Many of the lessons and projects which we have developed over the past four years will stay as well, albeit re-packaged into the relevant new learning units.

Most importantly we’re working hard, both in the context of this new curriculum and just in the context of growth more broadly, to keep the in-class atmosphere which makes the Academy of Code so unique. Rigorous without being rigid, intense without being harsh, fun without being frivolous - the atmosphere which our tutors create in class is core to what we’ve been doing since day one, and remains at the heart of our approach.

Who is building the new curriculum?

The new curriculum is being crafted “in-house” in the first instance, by our rapidly expanding team of full time tutors, ably assisted by ongoing feedback from our team of part time staff. We are also taking significant inspiration from the fantastic work which has been done with the new junior cycle Coding and senior cycle Computer Science courses, and will be engaging with a number of partners in both industry and academia as we get closer to a full rollout.

When is it rolling out

Summer2014Photos (6).jpg

Specific learning modules are being trialled in class currently, and will be again during the summer camps in June, July and August. We expected most of our students to be working under an early version of the programme in Autumn 2018.

While we don’t see this as a curriculum which will ever be “complete” - we will always be looking for ways of improving learning units, or of adding new modules to keep up with technological developments - we expect to be broadly finished implementing it the first draft in approximately 12 months time.

Watch out for updates over that time period, including draft curriculum specifications and all sorts of content around the material we're pulling together!

How can I get my child involved

Send them along to a course! This curriculum is designed to bring kids from total beginners to expert level over the course of 8 years or more, so there’s no time like the present to get started. Go to our homepage at to see details of all courses currently available, or to register for our newsletter to hear about upcoming courses and events.


UCD Coding Competition

Learning a new skill like coding can be incredibly rewarding, especially in the early phases. As time goes on it can require more external motivation to maintain that momentum, and a team-based competition can sometimes be exactly what’s needed.


Enter Professor Nick Holden of UCD’s School Of Biosystems & Food Engineering, who presented a group of senior Academy of Code students with just such an opportunity as he invited them to showcase their skills in a coding competition run as part of the first annual ‘Internet of Things 4 Food’ (IOT4F) conference in UCD, March 21st-23rd, 2018. This event brought together those in the forefront of the space, both in industry and academia, for three days of talks, presentations, workshops and networking - and Academy of Code students would be along for the ride!

9 teams made up of 32 students from the Academy of Code took part in the coding challenge at the event, made possible by sponsorship from both the Academy of Code and Origin Enterprises. Each team was tasked with creating a project around the topic of food waste, food management, or any other food-related topic, and presenting it as part of the conference.

After 12 weeks of hard work and preparation, the student’s designs were judged over several sessions in the week leading up to the conference. The judging panel consisted of Mr. Tom Maher (Academy Of Code), Mr. Pat Bolger (Origin Enterprises), Ms. Spain Hughes (Ripcoder), and Dr. Pat Grace (UCD).


The projects were assessed under five headings: execution, presentation, originality, planning/teamwork and, of course, code structure.

Following the judging, each team’s work was put on display at the UCD event on Thursday the 22nd of March, where the delegates at the conference had the opportunity to view each design and discuss the work with the students. After the project presentations, the students were given a tour of the O’Brien Science Building, where they got a first-hand look at the work which takes place behind the scenes in the University’s science labs.

Following an extremely enjoyable day on the Thursday of the conference, Friday the 23rd of March was the day the winners of the challenge would be announced. An exciting and nerve-racking time for everyone involved in the projects!

After much deliberation, the judges came to a decision and following a talk to the conference’s closing session from the Academy of Code’s Managing Director, Diarmuid Ó Muirgheasa, the winners of the challenge were announced. In first place, Bastian, Jesus, Sofia and Beatriz stole the show with their smart greenhouse design, in which they had automated lighting, heating and watering in a model greenhouse through use of an arduino-based control circuit.


In joint second place were two teams, one of which consisted of students Niamh, Joshua, Isabelle, and Daniel, and the other William, Jonathan, and Maciej. They received prizes for their recycling bin game and recipe app, respectively. The recycling bin game took the form of an arcade game, where points were awarded based on getting the correct waste into the correct bin. The recipe app, meanwhile, demonstrated a very high level of proficiency in UI design, with an entirely custom-coded user interface fronting an app which suggests recipes based on what food the user has available in their refrigerator.

The winners and runners up received prizes including a Genuino Starter Kit and OneForAll gift vouchers, while every student involved in the competition received a certificate for taking part along with a Micro:Bit.

Both the coding competition and the conference itself were leaps into the unknown, but at this remove it seems reasonable to declare a resounding success on both fronts. Delegates left the conference happy, and students left with smiles on faces all round (there were even one or two business cards collected by the students from conference delegates - watch this space!)

It was rewarding not only for the students but also for everyone else here at the Academy of Code to see the students put what they have learned with us into practice, and we can’t wait to re-run the exercise with Nick and the IoT4F team again next year.

A big well done to everyone involved!

6 Reasons You Should Learn to Code in 2018


There’s an idea that’s been gaining ground in the public discourse lately: Everyone should learn to code.

Bill Gates, Mark Zuckerburg, Steve Jobs and even Barack Obama have all publically stated that coding is a must have skill for future generations. But… why? If I learn to code, how exactly will it benefit me? Should we learn just because we are being told it's an important skill?

So many people dismiss coding because they have no intention of becoming a software developer. Would you tell someone they don’t need to learn to write unless they plan on becoming a writer? We learn to read and write because it opens up a world of opportunity and learning to code is no different.

Whether you are a child or an adult or whether you have a professional interest or are looking for a new hobby, this blog will tell you exactly why learning to code should be your 2018 New Year's Resolution

(our next blog will be a guide on how to start your coding journey)



Coding is fun

AoC_Summe_2015 (6).jpg

First and foremost, programming is an incredibly fun and engaging activity. What other hobby allows you to make animations, games and even robots? There are tons of example projects out there, suitable for all ages and experience levels.

In our experience, kids are often surprised at how quickly they adopt real coding skills. Typically, they latch onto a project and experience immense satisfaction once they see the end product. Once a project is finished, they are eager to move to the next challenge.


Coding improves academic performance


Logic, problem-solving, and organization are some of the cornerstones of programming, and practising with code helps you develop these skills in all parts of your life. Programming helps students visualise abstract maths problems and teaches them to tackle problems in a systematic way.

Beyond maths, it should come as no surprise that coding also improves language skills. Through programming, students learn the value of concision, structure and planning in their writing. People who code are also taught the importance of accuracy in their work and how crucial it is to define, plan and implement the steps required to solve a problem.


Coding helps brings ideas to life


We all get brilliant ideas now and then. How many times have you thought of a useful website idea? Or an app that could solve an everyday problem? The ability to code separates those who have an idea from those who can make their ideas a reality.

If you want your child to be a thinker and innovator who can bring ideas to life, encourage him or her to learn how to program. For inspiration, check out the Irish billionaires that founded Stripe - what started as a fun side project quickly become a multi-billion dollar company.


We need to be able to communicate with the technology around us


Computers have automated a lot of roles that used to be manual, which causes a problem for people who aren't digi-literate. Software is the modern language and controls so much of our day-to-day life.  Having no clue how any of this works is dangerous, and whilst it’s certain that not every job in the future will involve programming, the role of code will continue to become more and more central.


Career opportunities

Almost every company out there, from startup to multinational, rely on technology to drive their businesses. Even if you aren’t into software development, your ability to work alongside myriad software solutions is critical to how you are valued in your firm. Being able to understand these processes and integrate them to work for your company will doubtless increase your value in the firm.


It could be as simple as using SQL to manage customer databases, or PHP to design a company website. The most frequent use of coding in the workplace is to automate a repetitive and laborious task. Whatever the reasoning, a foundation knowledge of programming will greatly improve your usefulness in the professional context.


Anyone can learn it

Unlike many other hobbies out there, coding has a relatively cheap buy in. Most of us already have a PC or Mac at home. For those who don’t, you can have a Raspberry Pi up and running for well under €150, using the abundance of free resources online to teach yourself coding. While we’re big proponents of the benefits of classroom education, the reality is that there has never been a better time in history to be an independent learner. Knowledge is free now in a way that it’s never been free before - the only question is if you will learn to harness it.


Computer Science as a Leaving Cert Subject



Computer Science for Leaving Cert students is finally here! Students from 40 schools across Ireland will be the first to take part in the pilot Computer Science Leaving Certificate curriculum, due to be examined for the first time in 2020. 

The program will be the first of its kind, allowing students to learn computational thinking, to read and write in various computer languages, to design web pages, animations and games, and to learn about the role of technology in society. 

In making the announcement, Minister for Education Richard Burton commented that  “this is a very exciting time for education in Ireland. There is a digital revolution taking place which is having a transformative effect on our economy, workplace, and lifestyle.

“The introduction of this new subject will teach our young people flexible, solution orientated thinking. It will teach them to be creative, adaptable learners”.

Having engaged with the Department of Education during consultation events last year, we are extremely excited to be seeing the work done by all those involved coming to fruition. We’re looking forward in particular to hearing from our colleagues in the 40 pilot schools who are already hard at work preparing to deliver the new course. 


For our part, we look forward to getting involved more directly in the wider rollout in 2020, and look forward to adding Leaving Cert Computer Science classes to our growing roster of evening, weekend and in-school coding and technology classes.

As always, our goal in all of this is to introduce kids to the endless possibilities of a life of IT literacy. Not only are coding and advanced IT literacy growing necessities for professional careers, but they are also a deeply fun and satisfying set of skills to develop. The wider integration of these skills within the context of mainstream schooling represents part of a hugely positive shift for future generations. Indeed, this announcement is a timely and vital support for Ireland’s position as the prominent technology hub in Europe, a position which has already earned us huge economic windfalls through the presence of major multinationals such as Google, Microsoft, Twitter and Facebook.

While the overall thrust of this announcement is hugely positive, there are challenges to be overcome yet. Resourcing schools and teachers to keep at the forefront of technological advancements will be a major challenge for the Department of Education, while sourcing appropriately skilled teachers in the first place will not be easy.

Another concern which has surfaced is around the possibility that this intervention could do more harm than good when it comes to driving more students to study computer science at third level. This has been the experience in other countries, and is a concern which we shouldn’t dismiss lightly. Dr Mike Brady, the Director of Undergraduate Teaching and Learning in Trinity’s School of Computer Science and Statistics, expressed fears to the college’s University Times newspaper that the subject would become a prerequisite for college-level courses. “I would really dislike a situation where we were turning away really good students who didn’t do computer science. Someone with very good maths or physics or numeracy in general who, for one reason or another, perhaps because it wasn’t available, didn’t choose computer science.” 

While we still await the publication of the finalised curriculum, there is much to be excited about. This announcement marks the latest step in a long-awaited development in Ireland’s education system, and we look forward to seeing where it brings us next.

Happy coding!

What to Buy a Coder this Christmas

It’s just a few days till Christmas and that stocking still needs filling. If your shopping list includes someone who loves computers and programming, you are in luck! At The Academy of Code, we compiled a list of the must-haves for the aspiring coder. Use our gift guide to help find the perfect gift for the coder in your life.

Even if they aren’t a coder yet, take a look at some of these amazing gadgets. Who knows? Maybe this Christmas is the perfect opportunity to introduce a someone to the endless opportunities of coding.

All gifts are between €40 and €350, suitable for all ages and coding experience levels.

From all of us at The Academy, have a Merry Christmas.


LEGO Mindstorms EV3 Robot -  €349.99



Combine the timeless appeal of LEGO with cutting edge robotics and you have a fun and educational toy that can walk, talk, shoot weapons, grip objects and just about anything you can imagine. Programming the robot is incredible easy and offers the builder immediate gratification as they can see they creation up and running in a matter of minutes. The software is available for both Windows and Mac and works like a visual diagramming tool. While on the pricey end of the scale, Mindstorms has an incredible reputation for sparking imaginative play. This set is best suited to those aged 10 and older.

Micro:bit - €42.00


Micro bit.jpg

Designed by the BBC as part of its Make it Digital initiative, the micro:bit is one of the world's smallest programmable computers. This is a very reasonably priced starter-kit, yet has unlimited possibilities. Micro:bit offers an easy to code advanced block language, as well as supporting more advanced learning through javascript and python. It can also act as the "brain" in an electronics project by linking up with other components, as part of a bigger circuit.

For its size, the micro:bit is an incredible educational tool that will let teachers, parents and students have fun with code to create games, wearable tech and other devices. Its small size and built-in sensors make it quick to code and entertaining to use.


Raspberry Pi - €35 - €55 (depending on set)


Raspberry Pi.jpg

(take time to look through the sets to figure out what ‘extras’ you need. We suggest this set, as it includes most the cables you will need and a 3inch monitor to display the projects)

The original Raspberry Pi was a work of wonder: For about €35-55, you get a caseless computer with HDMI and analogue composite video output. Now in its third major iteration, the Raspberry Pi 3 is faster, more flexible and set to be more popular than ever.

As a cheap, multi-purpose computing platform, the Raspberry Pi has revolutionised the coding-enthusiast industry. This is great for giving kids their own device which they can use for programming, electronics projects and more! Note that you’ll need a tv/monitor and keyboard.

That said, a little setup and a lot of other parts are required to get it up and running. There is a wealth of resources online to help the aspiring coder get their Pi up and running, regardless of level. We recommend this for ages 14+ and for those with some experience in coding already.

Kano DIY Computer Kit - around €100


Kano‘s grand claim is that it lets kids build their own computer. What that boils down to is plugging in a series of pre-fabricated pieces, following a storybook which offers some context for what they’re doing. Advanced electronics this is not; think of it as a primer to get kids as young as six interested in how hardware works. Hardware is only half of the story. Once you've built the "laptop," you'll learn how to make games like Snake and Pong, manipulate Minecraft using code, and program your own music. The guide is child-friendly and easy to follow.

Leaving Cert Computer Science - One Step Closer

It's been a long time coming, but with the publication by the NCCA earlier this month of a draft curriculum (PDF) it seems as if Leaving Certificate Computer Science might finally be close to becoming a reality. The current "fast track" timetable puts the first exam appearance by the subject in June 2020, meaning it will be available for those entering 4th year this coming September (or those sitting the Junior Cert this coming June and skipping Transition Year). 

From our perspective, there's a lot to like about the proposal. The focus on practical applications is promising, and the 30% of marks allocated to coursework seems appropriate. There appears to be plenty of technical depth in the proposed curriculum, including study of CPU hardware, character sets, algorithmic complexity and sorting and searching algorithms. The course also includes a broader study of computers' impact on society, including sustainable development (this last part seems a little incongruous at first, but as part of a broader approach to including sustainability in all curricular strands it makes perfect sense).



There are also some areas we believe can be improved or need further work. Two in particular jump out at us from this draft of the curriculum proposal. The first is the heavy reliance on group work, which forms the backbone of the practical portion of the curriculum. It is envisaged that in this portion of the course “[s]tudents assume different responsibilities in each project, rotating between the roles of team leader, project manager, communications manager, and programmer”.

There are of course real benefits to group work, but it is our opinion that in the context of introducing computer programming to students for the first time it is counterproductive to give some students an “opt-out” from the coding portion of the assignment. Indeed it appears from the description that only a quarter of students will actually be coding during each 6 week project block. Even with rotation between the roles for each project, it is not at all clear to us that this approach will yield better educational outcomes than individual projects, and certainly not when that is measured in terms of computer science learning outcomes.

The second area in need of attention is not one which is within the scope of this recently published document, but it is an area which will ultimately the determine the success or otherwise of this initiative, and that is the actual delivery of this curriculum. It has long been our concern, backed by frequent communication with a wide range of schools, that most principals intend to either a) not offer the course at all, or b) press their physics/maths/technology teacher into service as a computer science educator. It is our strong view that neither solution is satisfactory.

The latter in particular could do serious damage to the reputation of the course, resulting in teachers delivering the course who, through no fault of their own, are neither skilled nor qualified to do so, and learning outcomes suffering accordingly.

We look forward to hearing what proposals will be brought forward to address this, and engaging with the NCCA and the Department of Education in developing solutions to address this problem.

Overall, with those small caveats out of the way, we are beyond excited that this step has finally been taken. It represents the culmination of literally decades of lobbying effort (for which the lobbyists in question are owed a debt of gratitude from us all), and a major leap forward for our education system. Getting student studying computer science at Leaving Cert level will inevitably broaden the range of individuals applying to proceed to third level education, as well as those who carry the skills of computer science into a wide range of other career tracks.

We look forward to being part of this bold new frontier in Irish education.



New Grading System at the Academy of Code

Grading students at the Academy of Code has always been something we've tried hard to get right, and generally it's been something we've struggled with. The nature of coding is that the material will immediately click with some students, while others will need more time to engage with it before they are ready to move on to the next concept. Over the course a single term this can mean vast gulfs emerging even within a class of the same age group, never mind one with a 3 or 4 year age spread (as many of our classes have).

In an effort to alleviate the issues this causes (boredom on one side, and frustration on the other) we generally allow a certain amount of leeway for students to progress at their own pace. This works well, and allows many students to thrive, but something we've heard from many parents is that they would like some sort progression for students, so that they always have something to work towards. 

That's why we've introduced our new grading system, as of the start of our summer camps this year. Pictured above are two returning students, who received beginners (white), junior grade I (red) and junior grade II (yellow) bands at the end of their week with us this summer.

This also coincides with our adoption of class booklets (previously we distributed lessons one at a time, as the previous lesson was completed - this was both inconvenient for students, who were limited in the work they could do at home, and also a nuisance for us, as it meant keeping a huge stack of paper on hand, and transporting it to each class!). Class booklets have a progression chart on the back, to be dated and signed by teachers as each lesson is completed and checked. 


For later grades there will also be more onerous grading requirements - the unassisted completion of some significant piece of coding, demonstrating understanding/mastery of specific areas of coding.

We're excited about this, as it will give students a clear, multi-year path to developing their coding expertise with the Academy of Code. Students seem excited too (although perhaps as much for the new fashion accessories and bragging rights as anything else!)

We will have more information about these grades in the coming weeks and months, especially the later grades which will require much more commitment to reach than the first few, and which may also include developing websites, working on hardware (arduino/picaxe/raspberry pi/lego mindstorms), and much more besides. Watch this space!

Gender Balance and Diversity at the Academy of Code

Diversity in IT is tricky. Google make a big deal of their commitment to equality of all types. So do Microsoft (in spite of the odd enormous misstep). Tech companies like Pinterest have been very public about their attempts to improve diversity. Closer to home, there are several women only scholarships available to women entering STEM (Science, Technology, Engineering and Mathematics) career paths.

In spite of all this, a survey of top tech companies show that tech roles in Apple, Google, Microsoft, Facebook and Twitter are filled by only 10-20% female employees.

And we shouldn't be too smug at the Academy of Code either. We have 7 employees, and only 1 female (numbers fans will note that that places us right in the middle of that 10-20% range).

While it's hard to say what exactly we can do to help this situation, we have started by making some efforts over the best six months to ensure that our advertising is more gender neutral. (Mostly this has meant ensuring that pictures used totally misrepresent the actual gender ratios at our courses - we reckon Machiavelli did make some good points...).

But hey, it's worked! At least it's moved things in the right direction (probably - causation is hard to firmly establish). Summer camp aside (and we expect the balance on summer camps is inherently more balanced - we'll know more once numbers for this summer's camps are available), we improved from a steady 16% girls up to 21% in like-for-like classes this term. Adding some girls-only classes (after-school in the Teresian School) has pushed that number up to 29% female. Hopefully our summer camp this year will show another solid step closer to gender parity.

Which of course raises the question - is gender parity the goal? Well, no actually. Not for us. Our goal is to get to a point where gender balance becomes a non-issue. Roughly speaking, this is regarded as being somewhere around a third. In a class of 20, on average you need around 7 girls for them to not be at risk of feeling like interlopers in a class for boys, and that's where we want to be. Whatever the numbers that eventually go on to careers in IT, we think it is a crying shame that anyone would be turned off a potentially amazing career purely because of their gender.

So: here are our numbers. We're working on them. Long term we want to be part of a broader solution, but short term we just want to be part of the conservation. If we can keep our own numbers going the right direction, and get at least some of our female students excited about a career in IT that's a good start. We also hope this might be something of a wake up call for parents. Around three quarters of our students are in primary school. Whatever about industry trends at large, at that age parents are still essentially calling the shots on extra curriculars. So parents - why is it sons and not daughters you're sending us?? If you have any thoughts on what more we can do, we're always delighted to hear from you. In the meantime, we're going to keep working on it. Hopefully we will contribute to a very different kind of IT environment over the coming years.

(Gender diversity is not, of course, the only kind of diversity - we will return to this subject again!)

A Long 16 Months

The class diary was an experiment which, in spite of its success, we put to one side after week 12 of our Autumn 2014 term. It's been gathering dust there ever since. The diary itself was quite well received, with plenty of parents happy to get an insight into what was happening in class, but putting it together became more of a distraction than it was deemed to be worth. New curriculum development took over, as did recruitment, logistics, and all of the other things that go into bringing each Academy of Code term together.

16 months has left a lot of updates unpublished, and a lot has happened at the Academy of Code in meantime. Time for an update, it seems!

Three founders have become two, as Simon has moved on to other projects (and is greatly missed, by staff and students alike). In his place we have added David, Robert, Sarah and Sid, not to mention Daire, who has been in and around the Academy since that first set of summer camps - not directly filling Simon's shoes, perhaps, but doing a fantastic job in their own rights.

We've also added some new students. Quite a few new students, in fact. In Autumn 2014 we had only a little over 20 young coders in our charge. As of April 2016, that number is well over 200.

We've added locations - first the Teresian School in Donnybrook, for after-school classes, now St. Paul's Raheny, for summer camps. Several more schools are also in the mix for further expansion in 2016.

Most importantly, we have been able to maintain (and even increase) the standards which we set down on day one, way back in early Spring of 2014.

As we get busier we find there is more frequent and more interesting news to share, not to mention more exciting screenshots and videos we can pull from our classes to share. All that and more in the coming months - stay tuned!

(Oh, and the summer camp 2016 registration page is now live - we sold out a class earlier this year in less than 60 minutes, so if you have a date in mind, don't delay!)

Week 12: Parents' Night

12 weeks done - flashed by in the blink of an eye! - and not a whole lot more to say here about what was covered. We're looking forward now, to January and to next summer, and we have a whole heap of new things in store for both new and returning students.

Speaking of returning students, we hosted parents' night this past week, in the second half of the final classes of term. As you might expect there were a couple of students who ran into Muphry's law in relation to demoing software live (that's a lesson for next term - never demo your software live!), but overall most parents seemed to be somewhere on the "happy" to "blown away" end of the scale in terms of their reactions to the final projects.

And speaking of blown away, we've been blown away by the feedback from those parents, and by the number of students who have promised they'll be back to us next term. Not that we want to count our chickens prematurely, but even the fact that so many are interested in coming back is a wonderful affirmation of what we're doing. We were also pleasantly surprised that all of those parents were pretty much across the board delighted with the classes, and with the progress their kids have made over the past 3 months.

As communicated to many of those parents, the biggest challenge we've run into this year has been simply churning out lesson plans and project ideas fast enough to keep ahead of the class. It's a wonderful problem to have, but at the same time it's also nice to now have a month to put a bit of breathing room between us and them! We'll be tweaking our "new students" course content over Christmas, but what's really exciting us is the possibilities for the returning students. While we're relatively constrained in what we can do early on, with three months under their belts there is suddenly a whole world of options for us to explore next year.

No firm decisions have been made just yet, but we have a couple of demo apps coded up already (some students will have seen those last week) which are really whetting our appetites. If next term even comes half way to living up to its potential it's going to be an absolute blast!

Some screengrabs from the 2015 course. And this is just for starters!

Some screengrabs from the 2015 course. And this is just for starters!

After that there'll be summer camps (dates to be announced, and sign ups opening, early in the new year), but that's probably enough to be going on with for now.

Classes next year are taking signups already, and we do only have a finite number of places so don't hang around if you're hoping to nab a place!

Week 11: More Projects, and Looking Ahead

Time really does fly. It feels like only a few short weeks ago that Simon, Eamonn and myself (Diarmuid) sat down to discuss the idea of forming a company that would run computer coding courses. That would have been back in March, or thereabouts. Since then we ran an experimental Easter courses (to prove that our ideas more or less worked in reality) and then two weeks of summer camps. Finally, buoyed by the positive feedback from those first two forays, we decided to press ahead and advertise our first term-time courses this past August/September.

We've certainly run into our fair share of difficulties along the way. Our decision to hand deliver 10,000 leaflets ourselves back in September was, in hindsight, something of a false economy. My decision to cut up stickers by hand for our branded USB sticks was (again in hindsight) rather more labour intensive than I perhaps expected. And as for the "wait, I thought you had the keys..." incident - probably the less said the better!

What really matters, however, is the teaching, and on that side of things we could scarcely be happier. As detailed in the past few weeks' blog posts, our students are far surpassing anything we could have imagined at the start of term.

I'm reminded of a lecture by an academic named Randy Pausch* (available on YouTube, and more than worth the ~75 minutes of your time). He was teaching a new course in Carnegie Mellon called "Building Virtual Worlds", and his students had just achieved more in their first two week assignment than he thought they would in an entire semester. He called his mentor, and after hearing the story his mentor said "[...] you obviously don't know where the bar should be, and you're only going to do them a disservice by putting it anywhere".

We're not teaching undergraduates at a top university (although I have no doubt that, in just a few short years, many of our students will be undergraduates at top universities!). All the same, I can't think of a better philosophy the guide us over the coming terms. 

We won't be abandoning our curation of course content, but we will be pulling out all the stops to provide more and better options to students, and even more opportunities to put their own stamp on what they're doing. We don't ever want them to feel that they're doing "enough" without having to push themselves. Within a few more terms some of our students will hardly need that kind of curation at all, as they'll reach a point where there's little they can't do. In the meantime we will keep racing to keep our assignments and projects ahead of them.

We're extremely excited about next term, and about the number of students who have already signed up to come back to us. If you're even almost as excited as we are, we hope you'll come along for the ride!

Week 9 & 10: More Project Work

The project phase of term is in full flow at this stage. While this is an exciting time for everyone, it does make it a little difficult to summarise what they're all up to. This is a lovely problem to have though, caused as it is by everyone doing something interesting, and all moving forward at their own pace.

This is what we really hoped to achieve when we founded the Academy of Code, and to see such exciting results in our first full term is incredibly heartening. Not that every student is equally as brilliant as each other - that simply wouldn't be a sensible yardstick - but that every one of them moves at the top end of whatever their own pace is, and that they are constantly being challenged, overcoming that challenge, and then being challenged again.

Over the past two weeks one of the major features being added by many students was collision detection, in most cases between circles. (Detecting collisions between rectangles involves a lot more steps, so most students were encouraged to stick to the circles. A few brave souls did implement the rectangle collision detecting though - and mostly with reasonably solid results!) 

The images above show how we go about detecting a collision. The distance from a circle to its edge is half its width (this is also called the "radius", for those of you who slept through maths class!). By getting the distance between the centre of the circles (basic geometry, which Processing takes care of for us with the "dist()" function) we can tell quite easily if the circles are touching. 

If the sum of the radiuses* is equal to the distance between the centres then the circles are just touching. If the distance between the centres is larger than the sum of radiuses then they aren't touching, while if that distance is smaller than the radiuses then there must be an overlap. Not trivial, but also far from rocket science. Lack of exposure to geometry is the real barrier we run into here, particularly with younger students, but with a bit of gentle coaxing most students managed it at some stage in the past two weeks. We also have the demo below to allow us to step through frame by frame and see what's happening. 

This is a very slightly altered version of the basic portion of the game students produce in their first term. We've added the line between circles, along with the text readouts, to allow us to watch the values of the important datapoints and analyse what's happening in the program. The line will turn red when the circles collide. The orange ball can be moved left and right using the 'a' and 's' keys, while the program can be paused by pressing '0', resumed at normal speed by pressing '9', or incremented a frame at a time by pressing 'c' while paused. (NOTE: You will probably have to click on the frame for any of those key presses to work!)

What you're seeing above, by the way, is one of the very neat features of processing - it can be embedded straight into a web page, almost without having to make any changes at all!

(Technical note: it's actually not quite that straightforward in reality, for a couple of reasons. Mostly it's that switching from Java (on the desktop) to javascript (in the browser) isn't ever going to be absolutely perfect. We've found that the background() function gives up on us in the javascript version (although this isn't a universal problem, and so merits a little more digging), as does some image resizing. In addition there are likely to be some issues with any complex object inheritance structures, as well as issues with overriding (since java is strongly typed and javascript is weakly typed). When the time comes (maybe 5 or 6 terms in!) this will provide us with a fascinating way of talking to students about the differences between strongly and weakly typed languages, and about how languages implement inheritance, and all sorts of other similar topics.
Another issue we've run into seems to be a Squarespace specific one, namely that embedding our canvas directly in the html on Squarespace just won't work. We have a couple of theories why, but for the moment we work around it by hosting them elsewhere and embedding them here using iframes.)

We have a number of mini-applications like this which we've either used this term, or will introduce next term, and many more ideas floating around. Look out for them here in the not too distant future!

In the meantime we're now facing into our final two weeks of term, and looking ahead already to next year. If you haven't already spotted the signs, we're taking signups for January already. If you're interested, don't wait until it's too late!




*Or radii, if you like to more classical in your plurals.

Week 8: It's Project Time!

Some of our more advanced students (mostly those who attended our Summer Camp) have been working on their end of term project for a while now. For the rest, today was a big occasion: they finally got their hands on the first project handout.

Not that there's anything all that special about the handout*, but what it represents is a major vote of confidence in all they've learned so far this term. We've been building up to it since September, and now we finally think they have all the skills (or enough, at any rate) to build the block dodging game we've been teasing them with the past few weeks.

What are those skills?

Well, they need to be able draw objects on the screen (using functions). They need to be able to move those objects around (using setup() and draw() blocks, variables, and basic arithmetic). They need to understand program flow (that's setup() and draw() again, and how the computer moves through the code in those blocks). They need to detect key presses (using if statements, comparison operators and system variables), and they need to detect collisions (using more comparison operators along with some slightly more complicated arithmetic).

There's other stuff too - despite the mainstream narrative that all kids these days are "digital natives", the reality is that there's all sorts of other, more fundamental IT skills they've learned in the past 8 weeks as well. Things like using ctrl-c to copy and ctrl-v to paste have come in handy. Using ctrl-z to undo has, unsurprisingly, come in even handier. They've become a bit more familiar with the windows file system (finding where on the computer they actually saved things), and they've become more used to highlighting specific bits of text they need to cut or copy (not much call for that while using a smartphone or tablet, it seems).

The block dodging game is simple relative to a modern 'AAA'** game of course, but is not dissimilar in appearance to something like Tetris. The basic idea is that you start by having a block or ball drop from the top of the screen, and the player controls a block moving left-to-right on the bottom of the screen trying to dodge that block. If the player is hit he loses, if not the game continues. We add layers of complexity when we randomise the position and size of the block, when we start keeping score, when we make the game harder as time goes on, and in many other ways as well***.

Progress was overwhelmingly positive across the board. Everyone managed to get either the player block moving left and right on key presses, or the "attacking" block dropping from the sky and then moving back to the top once it had passed the bottom of the screen. If anything, four more weeks seems like way too much time - but over achieving students are hardly a teacher's worst nightmare.

The advanced cohort also made great progress (but then, they always do, consistently outstripping even our most optimistic projections for them). We'll be featuring some of their work on the site over the next few weeks, as well as the finished projects from all of the kids in both the Tuesday and Wednesday classes.

Until then! 


*Actually it's one of our less interesting handouts - no colourful code blocks, no pictures, just a single A4 page of text with the scant consolation of a colourful "The Academy of Code" footer. Pretty disappointing relative to the high bar we like to try and set.

**'AAA' being the tag used to describe the kind of super high budget games which, with a few notable exceptions, you probably love if you're a kid and hate if you're a conscientious parent. 

***Simon (one of the teachers here at the Academy) decided it would be fun to add his own face to the "player" block, and make the falling blocks look like ninjas. Based on our experience demoing at the Wednesday class it seems there's no better way of endearing yourself to a 9- or 10-year-old than write a computer game where you escape from ninjas. Take note, parents! 

Week 6: Becoming a Nodding Bear (or a Rubber Duck)

The essence of good programming is being able to approach a problem you've never seen before and plot your way through it using the various tools at your disposal. This is true of every programmer, from beginners right up to technical architects on huge projects. In fact, it's not just confined to programming. All engineering (and programming is certainly at least sort of engineering), involves this ability to approach a problem and find a solution in as novel or humdrum a manner as the situation dictates.

One of the first things we talk to our new students about is the idea of this "toolbox". We start with some simple commands: this is how you set the size of the window; this is how you draw a circle; this is how you draw a rectangle. We add to this as time goes on, but we never get to the point where we say "this is how you create a computer game". That, as you would expect, is instead a combination of all the little things into one big thing. 

Starting out, their most powerful tool is not really any of these things but rather the instructors. The instructors know all the answers (or at least in the narrow confines of the assigned problems we do...), and we will always be available to give an extra nugget of information when a student is truly stuck. 

After a number of weeks, however, something strange starts to happen. Bit by bit, they slowly stop needing us. 

They still have questions, of course. Even advanced programmers occasionally need a sensible eye cast over a particularly intractable problem. More and more, however, their questions are answered before they finish asking them. As an instructor, all we need to do is nod along until they work it out for themselves. We're reduced to the roll of "nodding bear".

(A software team I worked on referred to it as the Stanford Bear, but I can find no sources which credit Stanford with the original innovation).

The idea of the nodding bear is that a programmer, as part of her/his debugging efforts, explains their problem to someone or something else. This can be an instructor, a colleague, or literally a rubber duck or stuffed bear. The typical question might begin with "so I'm trying to make this box disappear here and reappear here", before trailing off with "but when I check if the position is greater than the size - wait, shouldn't that be less than..? Never mind...". As the nodding bear, all the instructor has to do is nod along until the student arrives at the solution all of their own accord. Neat, right?

We're only six weeks in, so of course there are still lots of questions coming at us, and of course there is a wide range of abilities in each of our classes. All the same, it's great to slowly start becoming closer and closer to the proverbial Nodding Bear.

This week we revisited our basic drawing tools with most of the students, before moving on to making a box fly around the screen and respond to commands. More than ever before these students are starting to see how the tools they already understand can be combined in new and interesting ways.

Meanwhile the more advanced group were pressing ahead with their block dodging game. They progressed notably on their collision detection code, and generally made good progress towards the finished game. With a bit of luck we might need to find an entirely new project for them before the end of the year!

Week 5: Movement, and the Start of a New Project

This week was exciting for both our beginner/intermediate group and our more advanced cohort. For many of the beginner group this was their first time doing anything that might be called "animation", and they were predictably excited about the prospect! For the advanced students, meanwhile, this week marked the start of their first major, multi-week assignment - more on that further down.

After a recap exercise, which involved using detecting keyboard input and changing the size of a circle in response (which is not nearly as easy as it sounds!) the first group started into their animation with an apparently simple "move the ball across the screen" task. With a bit of help most of them had managed to plough through this by the end of the class, but that's not to say there wasn't a lot going on. Quite the opposite! This task requires students to understand program flow (which means understanding which instructions will execute in what order, and why) as well as making use of variables to store numbers, and accessing those variables to modify them. On top of all that this also requires that they be very careful about their use of brackets. Every '{' must be matched by a '}', and every '(' matched by a ')'. 

All this combined means that this bunch of students, many of whom have been with us only five weeks, are now equipped with many of the skills required to produce some really amazing programs. We're all looking forward to seeing how far we can bring them in the next seven weeks!

On to the advanced crew, and their assignment was only just getting into gear this week. They've been tasked with building a "block dodging" game. The player will control a character who moves over and back across the bottom of the screen (think Space Invaders), and dodge blocks which are falling from the top of the screen (think a cross between Tetris and, well, Space Invaders). Early progress has been encouraging, with students successfully crossing some of the first hurdles, and displaying admirable breadth and depth of knowledge. Perhaps next week we will have some early demos to share.

Week 4: Keyboard Input

Like week 3, week 4 was always going to be a good one in terms of student reaction. This, of course, is one of the main reasons we use Processing. Unlike other languages (eg Java, or even Python/Ruby/etc), it's possible to very quickly progress to user input in Processing.

As a teacher it's gratifying to be able to reliably show a demo at the start of class and have students (literally!) gasping with astonishment and excitement. (At least, one hopes that gasping with boredom hasn't quietly become a thing without any of us noticing?).

That said, this week was also a tough one for many students, as they had to deal with the idea of "nesting" much more than before. Opening and closing brackets/braces isn't really a skill normally all that necessary, and when necessary it doesn't tend to be terribly difficult. In the code example below, which is perhaps on the high end in terms of number of nestings*, there are 6 separate pairs of curly brackets, all of which must be matched correctly in order for the code to function. Not all students managed to get to this level of complexity this week, but they all will!

void setup() {

void draw() {
  if (mousePressed) {
    if (mouseButton == LEFT) {
      if (keyPressed) {
        if (key == 'c') {
          ellipse(mouseX, mouseY, 50, 50);

You can see in the code above much of what we covered this week, most notably if (keyPressed) and if (key == 'c'). For those students who are interested in making games (which I think probably covers most if not all of them!) this was obviously exciting, as they got to see how easy it potentially is to take a user's input and do something with it in code.

In addition to key presses we also introduced students to variables this week. Variables allow a programmer to store something (a number, letter, word, etc) and refer back to it later. For example, we might set a circleSize variable at the start of our program, and make all subsequent circles with circleSize as a diameter. If we want to change the size of all our circles we then only have to change the number in one place. This also allows us to do interesting things like incrementing or decrementing the circle size based on mouse clicks or button presses. 

As you can see, and as the students are seeing, even in the relatively small number of classes we've had so far they have built up a formidable array of tools with which to tackle programming challenges. Next week will see revision of bracket discipline, as well as a some quickfire revision of the various functions we've used to date, and more opportunities to play with the user input features introduced these past two weeks.

More advanced students (mostly those who have previously attended a course with us) will also be moving on to bigger and more complex problems, requiring higher level thinking and more complex structures. Something for us all to get our teeth into then, and plenty to look forward to for all our students!


*For those programmers in the audience: don't worry, user-defined functions are coming up soon. We won't be encouraging quadruple nested if statements as a standard programming practice!

Week 3: Mouse Input

Having introduced the students to user input in week 2, this week we started to make things a bit more interesting with the addition of left and right clicks. As usual Simon kicked things off with a quick demo of what we're building towards. As well as demoing our very simple car game again, we also took a look at a simple but extremely cool shape-shifting demo (which we will be embedding below shortly). This simply draws a box at the location of the mouse, leaving a trail behind when the mouse pointer is moved. Left-clicking switches from square to circle, while right-clicking clears the screen. All quite simple, but very visually engaging!

It's always fantastic to see the reactions of students the first time they write a program that tracks the mouse pointer. The mix this term is about 70:30 new students to returning students, so there were plenty of big grins around the room when they got a circle drawing on the location of the mouse.

In Processing we can very easily set a refresh rate of 30Hz (simply by placing code inside the draw() block), so combining what they already know about the ellipse() command (used to draw circles/ovals) with this and the newly introduced mouseX and mouseY variables (which always give us the up-to-date location of the mouse) it's actually quite a simple exercise to make a shape follow the mouse. Simple as it might be, it's still a great confidence booster. It also really shows the power of combining a few separate pieces of knowledge to make something that's much more than the sum of its parts, and is a very solid introduction to the idea of program flow.

Working hard!

Working hard!

Even better is when they realise what the next steps are, and there was more than one student this week who was desperately trying to make those next steps come together before the final "save everything and shut down" call came! Most managed to make some use of stroke() and noStroke() functions to remove or change the outlines of their shapes this week, but the real power of all those tools (and more, like the briefly introduced void() function) are yet to be fully revealed. 

Left and right clicks will continue to be in focus next week, as we keep up our relentless work towards mastery (or at least a decent grasp!) of coding computer graphics with Processing. Until next week, then!