How We Teach
Our teaching process is based on knowing that there are four core things you have to get to grips with when learning to code:
- Being able to work out where to start
- Knowing how to leverage other people's code
- Understanding how to debug problems
- Learning theory, such as syntax, as you go along
These four principles come from talking to some of todays best developers and finding out how they got to be so good at making things.
Working out where to start
One of the most difficult things to do as a beginner is figuring out how to start building a big idea. It's impossible to fathom the full extent of a project without first understanding how it can be broken down into small pieces. This is why a lot of people who have taken several coding courses that focus on theory and syntax still don't know where to begin.
This course is made up of ten examples of small things which could be used as a building blocks as part of a bigger thing; we'll try and put some of them together towards the end of the course.
Throughout the course you'll develop an understanding of how to break an idea down into smaller pieces, so when it comes to making things for yourself you'll be able to work out what bits you need and how to put them together.
Making things with code is about using other people's code as much as possible
For any of the things you're trying to build with code, it's likely that someone else has done something similar already. One of the great things about the internet is that there's also a good chance that they've published it online for other people to build on for free.
In practice, this is how modern applications are made. Once you've worked out how to break the big thing you want to build into smaller components, you can look for ways to leverage other people's code to fulfill these functions. You then write your own code to glue these components together and tweak / add functionality to suit your needs.
That's why we don't focus on coding everything from scratch. The aim of this course is for you to be able to make actual things with code as quickly as possible; and the best way to do this is by building on existing code wherever available.
Making things with code is about working out why something doesn't work
It's a common misconception that making things with code is mainly about writing lines of code. It really isn't. Most of a developer's time is spent working out why bits of code aren't working as expected, or indeed not working at all.
A lot of the time, error messages make about as much sense as "the whatsit in the thing is undefined around the stuff". Other times, they seem to go out of their way to hide information in something vague like "there has been an error". If you watch any developer at work, the process looks something like this:
- Write a bit of code
- Run it
- Read the error message
- If it immediately makes sense, change the code and try again
- If not, copy and paste it into Google, read the first StackOverflow answer, maybe Google some more based on StackOverflow responses
- Change the code based on findings
The more code you debug, the more error messages you'll be able to decipher without recourse to Google. The important thing to note is that error messages are perfectly normal; they don't mean you're doing something wrong, they're an expected part of the development workflow.
In this course, we'll be looking at error messages as a useful source of information rather than something scary or intimidating. By the end, you should be able to look at a Ruby error message, understand which bit of it is giving you useful information and know which resources to refer to in order to find out how to fix it.
Learning How To Learn
One of the most common mistakes when teaching people to code is to start by teaching "pure theory", completely separately to how this practically fits into making things.
This simply isn't how today's developers learned, they learned by starting with some existing code, making changes and seeing what happened. When they wanted to make bigger changes, they had to learn some theory, and so-on.
Our course is modelled on this process. In each exercise we'll provide you with some code to get you started. Sometimes this code will be broken and we'll guide you through fixing it ("debugging"). Sometimes it will need additions making and we'll guide you through which resources to use and how to put them together.
The important thing is that you find the actual solutions yourself because the little jolt of satisfaction you get when your solution finally works is essential to staying motivated!
The aim of this course isn't for you to memorise the exact steps required for the things we'll be making, it's to learn the underlying concepts and ways of thinking that will lead you to be able to make your own things with code.
We're always interested in chatting about all things learning to code. We're based in Google Campus in London's Tech City. Stop by for a coffee (or tea)!Make It With Code
Google Campus, 4-5 Bonhill St
London EC2A 4BX
P: +44 (0)2 032 894 803