Transcript
            
            
              This transcript was autogenerated. To make changes, submit a PR.
            
            
            
            
              Jamaica real
            
            
            
              time feedback into the behavior of your distributed systems
            
            
            
              and observing changes exceptions.
            
            
            
              Errors in real time allows you to not only experiment with confidence,
            
            
            
              but respond instantly to get things working again.
            
            
            
              Close in
            
            
            
              the fall of 2016, I had the interesting challenge of teaching
            
            
            
              beginner programming to a class of university students who
            
            
            
              never actually intended to do any coding in their lives.
            
            
            
              Let me give you a little bit of context of how I got there,
            
            
            
              lay out my goals, and tell you
            
            
            
              about how that all went. So for
            
            
            
              context, originally it was actually not me, but a friend
            
            
            
              and colleague of mine who was invited to the university
            
            
            
              to do this course of beginner programming to art students.
            
            
            
              And I accompanied her to help out as a mentor,
            
            
            
              that is, mentoring the students, which means when
            
            
            
              they are all doing exercises and multiple students have questions
            
            
            
              at the same time, it's useful to have multiple people there.
            
            
            
              So she was going to be the teacher, I was going to be a mentor
            
            
            
              to help out at the end of the semester. She said she wasn't
            
            
            
              interested in teaching another course as a teacher,
            
            
            
              but she would be happy to come along as a mentor.
            
            
            
              I, on the other hand, got very excited about teaching. So I stepped up
            
            
            
              and said I would be happy to lead these next semester.
            
            
            
              I got very excited because I love thinking about
            
            
            
              how to explain difficult concepts in a way that is easy to
            
            
            
              understand. And by that time, not only had I participated in this semester,
            
            
            
              I also took part in multiple one day workshops
            
            
            
              of like crash courses of teaching beginner programming to non programmers.
            
            
            
              So I had seen a lot of examples and ideas
            
            
            
              and patterns and great teachers. But I also had my own
            
            
            
              ideas, and I saw some opportunities for
            
            
            
              improvement. Now, at the end, I ended
            
            
            
              up teaching three semesters to university students and
            
            
            
              also ones for high schoolers.
            
            
            
              And during that time, I was able to iterate on
            
            
            
              the curriculum every year, keep the things that were working
            
            
            
              well, drop the things that were not working that well,
            
            
            
              and get feedback from the students at the end of each semester.
            
            
            
              And now, that was a time of varying
            
            
            
              success, but also a lot of learnings.
            
            
            
              And I'm here to tell you about those learnings in
            
            
            
              order to understand why we did some of the things that we did. First,
            
            
            
              let's look at the goals. What were we trying to achieve?
            
            
            
              What would we have considered success at the end of the
            
            
            
              semester? Where did we want to get? And the
            
            
            
              bottom line is that these were people who are not programmers.
            
            
            
              They were not going to be programmers. They never intended to be programmers.
            
            
            
              And so my basic goal was just to
            
            
            
              give them a sneak peek into the world of coding
            
            
            
              and an experience and feeling of success,
            
            
            
              because I feel like this world feels
            
            
            
              like something unachievable for most people and
            
            
            
              I wanted to be inclusive, invite them in
            
            
            
              and give them a feeling of being capable of
            
            
            
              achieving success in this world.
            
            
            
              This kind of influenced the
            
            
            
              general format, which was no exam at the end of
            
            
            
              the semester. Thankfully, the university gave
            
            
            
              me almost complete freedom in how I was going to
            
            
            
              shape the requirements. The one thing that they set out was
            
            
            
              attendance was mandatory. But other than that, it was all
            
            
            
              up to me. And so even though I gave up homeworks from week
            
            
            
              to week, and I also gave them a task, at the end
            
            
            
              of the semester, there was no specific exam and there was no specific
            
            
            
              point where we had to get like, there was no
            
            
            
              problem if by the end of the semester we missed learning something
            
            
            
              that I was originally planning to do, because the idea was to
            
            
            
              introduce these to this world. This also very heavily shaped
            
            
            
              the mindset of how we were teaching. We were
            
            
            
              repeatedly telling them that there
            
            
            
              is no stupid question. These only stupid
            
            
            
              question is the one that you don't ask, because if you don't ask it,
            
            
            
              you stay stupid. And so we were trying to be very
            
            
            
              open and very safe and make
            
            
            
              everyone feel comfortable with them not knowing stuff and not understanding
            
            
            
              stuff, and make them understand
            
            
            
              that trying was more important than getting it right
            
            
            
              the first time. It was perfectly okay to
            
            
            
              poke around, even if you didn't have a very specific idea
            
            
            
              of what you wanted to achieve. And I
            
            
            
              made sure to tell them that I myself, as a software engineer
            
            
            
              who did coding for a living, I also often
            
            
            
              do that by trial and error, and I don't get it right the first
            
            
            
              time. And I told them that software
            
            
            
              engineering, when you write code, you don't write it from the top
            
            
            
              all the way to the bottom. You put
            
            
            
              something out there and then you massage
            
            
            
              it until it starts doing what you want it to do.
            
            
            
              This massaging comes from a deck lead of mine.
            
            
            
              And one other very important thing was how I
            
            
            
              needed to make some decisions around
            
            
            
              which specific examples and techniques
            
            
            
              and patterns to teach. And there was a trade off between
            
            
            
              patterns that were easy to understand and
            
            
            
              patterns that were widely applicable,
            
            
            
              as in applicable outside of the context of this course.
            
            
            
              To be a bit more specific, if there was a function
            
            
            
              that I wanted them to call, but it had a too complicated
            
            
            
              of a signature and I could easily wrap it in a
            
            
            
              helper function that was just much easier to understand than call,
            
            
            
              I had to make a choice of do I give them a helper function,
            
            
            
              in which case they will understand these easier, but then if
            
            
            
              they ever look up the documentation for the framework of what
            
            
            
              we are learning, they are not going to see that helper function. These, if they
            
            
            
              ever look up languages outside of my course, these are
            
            
            
              not going to see the patterns that I'm teaching. So I'm
            
            
            
              kind of closing them in a little bubble of my
            
            
            
              patterns and conventions and syntaxes
            
            
            
              and helper functions. So there is a bit of trade off there.
            
            
            
              And I made these decision that because these course was not
            
            
            
              about putting them on a certain level and to
            
            
            
              a certain curriculum and to a certain
            
            
            
              knowledge and skill level, this was more about making
            
            
            
              it click for them and making them
            
            
            
              experience, success and
            
            
            
              ability. I decided to go
            
            
            
              the way of putting them in a bubble.
            
            
            
              And I thought it's more important
            
            
            
              that they walk away with the feeling of
            
            
            
              being able to get into programming if they ever need to,
            
            
            
              than if they will see the exact patterns
            
            
            
              that also exist outside of this course.
            
            
            
              Even if the specific syntax or the specific helper
            
            
            
              function is not applicable in a different context,
            
            
            
              the skills are certainly applicable, the concepts
            
            
            
              are certainly applicable, and more than anything, what is applicable is
            
            
            
              that they have the understanding
            
            
            
              that they are able to do this and they are able to get
            
            
            
              into this. And so with this in mind,
            
            
            
              what did we end up actually teaching? Well,
            
            
            
              I wasn't coming up with this curriculum from scratch. I had
            
            
            
              examples and patterns in front of me from these circle
            
            
            
              of friends and colleagues who were already teaching such courses or
            
            
            
              workshops. And the
            
            
            
              programming language and framework that everyone used was
            
            
            
              one called processing.
            
            
            
              Now this framework was specifically created to
            
            
            
              teach programming to beginner. It is supposed to be
            
            
            
              very visual, very easy to understand, and very
            
            
            
              easy and quick to get to programs that are actually
            
            
            
              nice and enjoyable and do stuff.
            
            
            
              And so that was going to be my baseline. However, I did
            
            
            
              decide to go on a duvet. There existed a port
            
            
            
              of processing which was written in Java,
            
            
            
              and the port was written in JavaScript. It ran by the
            
            
            
              name of p five js, and I decided to use
            
            
            
              that ones instead of the original processing. And there
            
            
            
              were a number of reasons for that.
            
            
            
              Processing was already very well established, it was
            
            
            
              popular, it had a community and good tooling around it,
            
            
            
              and p five JS was not as well known as
            
            
            
              not as well supported. And still I decided that it was just these better choice
            
            
            
              for this particular course. One of the reasons why I went
            
            
            
              with that is the fact that processing was using Java
            
            
            
              and p five js was using JavaScript.
            
            
            
              Now why does this matter in this particular context?
            
            
            
              First of all, we all know that Java tends
            
            
            
              to be a little bit verbose and it's also pretty strict compared to
            
            
            
              JavaScript, which of course is a dynamically typed language, and it's
            
            
            
              also one that was born as a scripting language,
            
            
            
              and so it can be much more concise
            
            
            
              and expressive. And I thought that was very important at
            
            
            
              this point. Keep in mind that
            
            
            
              these were hungarian students who of course spoke English,
            
            
            
              but words such as void or string
            
            
            
              or integer, these are not part of your
            
            
            
              everyday vocabulary when you're just talking English
            
            
            
              as an art student. And so that was going to be a little bit difficult.
            
            
            
              And additionally, Javascript was flexible enough
            
            
            
              to let me do some custom conventions
            
            
            
              and modifications that would have been impossible to do with Java.
            
            
            
              Let me show you what I mean. On the left had side
            
            
            
              you can see an example with Java,
            
            
            
              and of course when you're creating variables, you have to tell the type.
            
            
            
              And now you need to remember these words. You need to remember to
            
            
            
              spell string with an uppercase, s and int with a lowercase.
            
            
            
              You need to remember that if you create a variable you need
            
            
            
              to write out the type, but if you modify it later you don't.
            
            
            
              You need to let's not even talk about arrays,
            
            
            
              that's way too much. And on the right hand side you see the Javascript
            
            
            
              equivalent. You'll notice that I just dropped
            
            
            
              VAR. Let const didn't do any of that,
            
            
            
              which is certainly not a good practice if you're actually writing production
            
            
            
              code. But if you just went to introduce the concept of variables to
            
            
            
              students, it's very handy because it's just so
            
            
            
              much easier. You write a name, an equal sign and a value,
            
            
            
              it doesn't even matter if the variable exists already or you're creating it
            
            
            
              right now, just works. It also had the added
            
            
            
              benefit of putting all of these variables in the global scope, which once
            
            
            
              again you wouldn't do that in production code. But when
            
            
            
              teaching, I found that understanding variable scope
            
            
            
              was just too big of a hurdle. It wasn't worth it to try to explain
            
            
            
              that. So it's just easier to say if you create a variable,
            
            
            
              it's there for you to use, and you don't need to worry
            
            
            
              about it. You will also notice that
            
            
            
              I'm not using any semicolons. Javascript lets you do that with automatic
            
            
            
              semicolon insertion. And yes, we all know
            
            
            
              that there are a handful of corner cases where
            
            
            
              you cannot rely on automatic semicolon insertion,
            
            
            
              and then your code does something else than what you intended it to do
            
            
            
              or just doesn't work. But I knew that we were never
            
            
            
              going to write that type of code, so it was just easier to drop it.
            
            
            
              And it might be second nature
            
            
            
              for you to hit the semicolon key on your keyboard.
            
            
            
              But keep in mind that these were hungarian art students,
            
            
            
              so they are not writing so many semicolons or
            
            
            
              special characters. Curly braces were also a big problem because
            
            
            
              it especially counts that on the hungarian keyboard
            
            
            
              we need to have more letters because the hungarian Alphabet
            
            
            
              has more letters than the Latin. And so many
            
            
            
              of the special characters that are just simple keys on an
            
            
            
              english keyboard, they need to be accessed via modifier
            
            
            
              keys. On a hungarian keyboard, you need to press
            
            
            
              altgr to access
            
            
            
              certain keys. I don't know when you use that. The last time, of course,
            
            
            
              I'm talking about Windows machines. And so
            
            
            
              it just proved to be very useful to be able to drop
            
            
            
              that. You wouldn't believe how much time people were wasting just
            
            
            
              looking for characters. And it's just not the
            
            
            
              useful type of time to spend when you're trying to learn
            
            
            
              programming. You could also
            
            
            
              say that, well, the code on the right hand side,
            
            
            
              that just looks like Python. So why didn't I just go with
            
            
            
              Python? And you would kind of be right, it does look like Python. I think
            
            
            
              Python is an amazing language to teach for beginner,
            
            
            
              and I believe there was some kind of port of processing
            
            
            
              to Python, but there are other aspects
            
            
            
              that I needed to keep in mind. And so let me talk to you
            
            
            
              about these as well. One of these considerations was that
            
            
            
              for P five js, I also had an extension
            
            
            
              developed by someone, which is
            
            
            
              that one of these considerations was that for P
            
            
            
              five js there was an open source extension called P
            
            
            
              five Play, which wasn't available.
            
            
            
              One of those considerations was that for P five js there existed
            
            
            
              this open source extension called P five Play.
            
            
            
              To understand why that matters, let me first show you what
            
            
            
              processing looks like.
            
            
            
              This is the example program that the website gives you.
            
            
            
              It creates a canvas a given size.
            
            
            
              Let me not get into the function name choice of size
            
            
            
              when what you want to do is create a canvas.
            
            
            
              But what you will notice is that this very
            
            
            
              minimal, very simple example that they give you on the web page,
            
            
            
              it already has more numbers than letters.
            
            
            
              And it's really difficult to sell when one of your
            
            
            
              bottom line messages is that you don't have to
            
            
            
              like mathematics in order to get into programming,
            
            
            
              because this is coordinate geometry.
            
            
            
              And let me tell you, not a lot of people like
            
            
            
              coordinate geometry. It's extremely
            
            
            
              useful, and at the same time, it's just not intuitive.
            
            
            
              This is not how people think about the world
            
            
            
              and about where things are and what they do. And so what
            
            
            
              p five play let me do is it gave
            
            
            
              me sprites. These sprites are some
            
            
            
              kind of actors in the program. You can create a
            
            
            
              sprite, you can put it somewhere on the canvas and then you can move it
            
            
            
              around, you can rotate it, you can change its appearance,
            
            
            
              you can make it move, and you can create multiple sprites,
            
            
            
              and you can make them meet and collide and behave differently.
            
            
            
              And this is just so much closer
            
            
            
              to our intuitive world of having actors
            
            
            
              which exist in a space and interact with each other
            
            
            
              rather than getting a canvas and then providing a bunch of
            
            
            
              numbers to have something show up on the canvas.
            
            
            
              And these, okay, what do you do with it now?
            
            
            
              I put that little turtle there because I got a lot of
            
            
            
              inspiration from a logo language,
            
            
            
              namely communist logo. That actually was the first language
            
            
            
              that I ever learned. Logo languages feature
            
            
            
              turtle graphics. They give you a canvas
            
            
            
              and they put a little turtle in the middle, and these
            
            
            
              turtle has a pen, and you can tell the turtle to
            
            
            
              move forward or backward or rotate, and as the
            
            
            
              turtle moves around, it draws a line with the pen
            
            
            
              and you can use this to create drawings. These is a very
            
            
            
              intuitive concept to grasp even as a kid, because if you
            
            
            
              can control a remote controlled car, toy car,
            
            
            
              you can control the turtle. It makes a lot of sense.
            
            
            
              And so I got a lot of inspiration from logo and
            
            
            
              P five play. Let me do something very, very similar with
            
            
            
              these sprites. Another thing is that
            
            
            
              if you take a look at this so
            
            
            
              called processing development environment, it's nice
            
            
            
              that it's a standalone executable that you download and run on your machine,
            
            
            
              but then you get the impression that code or program is
            
            
            
              what you type into this box. It lives in this box,
            
            
            
              that's the code that lives in its own bubble.
            
            
            
              That's all it can do. But with JavaScript
            
            
            
              it was very easy to just open up a browser,
            
            
            
              open the JavaScript console, and then change
            
            
            
              something on the web page that we were looking at. And that gives you
            
            
            
              an instant experience of just how close this programming
            
            
            
              language is to your everyday life and that
            
            
            
              it's right there under the hood. And of course you could argue
            
            
            
              that Java is right there under the hood of processing, but you
            
            
            
              cannot open that hood, whereas with the browser that you use every
            
            
            
              day, you can just open up the hood and start interacting
            
            
            
              with the web page using JavaScript, which is a very
            
            
            
              powerful experience and concept. So that's also why
            
            
            
              I did that. Not to mention that very helpfully,
            
            
            
              browsers have a JavaScript console which is a repl,
            
            
            
              read, evaluate, print loop, or if you prefer read,
            
            
            
              evaluate, execute loop. The processing development
            
            
            
              environment doesn't have that. It had an area where you
            
            
            
              write your program and then you can execute the entire
            
            
            
              programs from top to bottom, and then you can modify something and re
            
            
            
              execute it again, which is a bit of a more
            
            
            
              difficult concept to get familiar with than
            
            
            
              when your actor is there on the screen and you have command line,
            
            
            
              which is, as its name shows, is the place where you give commands
            
            
            
              or instructions. And so if you instruct your actor
            
            
            
              to do something, it just does it, and there you are,
            
            
            
              and then it stays in that place, and then you can continue giving it instructions
            
            
            
              and it will interact with you, it will react to your instructions,
            
            
            
              which is once again I think a really good introduction to programming to
            
            
            
              start with a repl, rather than writing entire programs at the very beginner.
            
            
            
              By the way, this is also something that logo languages do.
            
            
            
              And if you went another
            
            
            
              example, the official Python tutorial
            
            
            
              also starts out with opening these Python interpreter and
            
            
            
              using it as a calculator, which is not super
            
            
            
              useful per se, but once again a very easy to understand concept.
            
            
            
              You type something in, you get something back while you're doing Python,
            
            
            
              and then you can move into more complicated things then.
            
            
            
              Here's another thing where I changed how previous curses were run,
            
            
            
              which is that saving and distributing our code.
            
            
            
              I had seen cases of saving your code on a
            
            
            
              pen drive. I had seen cases of
            
            
            
              trying to save your code to GitHub via GitHub desktop.
            
            
            
              This was especially important because people
            
            
            
              were not always using their own machines. VV provided machines,
            
            
            
              and so they needed to be able to access their code even if
            
            
            
              they were using a different machine than on the class before.
            
            
            
              Not to mention if they wrote some code during the class and then they
            
            
            
              went home and wanted to write homework, they would have had to access
            
            
            
              their code. So previous teachers used pendrives and
            
            
            
              did GitHub desktop. But to be honest,
            
            
            
              GitHub, the git usage is just not something that
            
            
            
              you want to start your beginner course with. And even
            
            
            
              with a GuI like GitHub desktop, it just gave us a lot of
            
            
            
              struggle and a lot of problems and a lot of time wasted, and it's
            
            
            
              just not worth it. And so instead, what I
            
            
            
              did was I fired up JS being, which is
            
            
            
              an online coding sandbox, like JS fiddle
            
            
            
              and some others. This was the one that fit
            
            
            
              the purpose the best. And it's really great because once
            
            
            
              you are registered, you just need to log in and all of your programs
            
            
            
              are there, and then you go home, you log in, and all of your programs
            
            
            
              are there, it version controls them, so you don't need to worry about
            
            
            
              that. And it
            
            
            
              has a bunch of other nice features, such as if you
            
            
            
              get stuck with something, with your homework and you need
            
            
            
              to message your teacher, all you need to do is send
            
            
            
              over the URL. And sharing your code is as
            
            
            
              easy as that. It's just about sending
            
            
            
              a URL, or if you want to show it to someone else, you just
            
            
            
              send a URL. And if you want to run your
            
            
            
              code on a mobile device rather than your desktop, you just open
            
            
            
              the URL. Whereas with processing, these are all problems that
            
            
            
              you would have had to solve, as in how do you distribute,
            
            
            
              how do you share, how do you run it on a phone? And there are
            
            
            
              solutions for some of these problems, but all of them require extra
            
            
            
              work, extra setup, extra thinking.
            
            
            
              And with JS being, I mean, you don't even need to install anything on your
            
            
            
              computer, just like you do with processing development environment,
            
            
            
              or some kind of code editor or whatsoever,
            
            
            
              you just open up your browser and there it is. It's stupid easy and
            
            
            
              stupid streamlined. And it worked very well for us. I am
            
            
            
              somewhat sorry of using a floppy icon for saving.
            
            
            
              I know it's very outdated, but it gives me very nice nostalgia vibes.
            
            
            
              And so I had taught for three semesters,
            
            
            
              I had been teaching university students, and then one more
            
            
            
              semester for high schoolers, and at the end of each
            
            
            
              semester I asked for their feedback.
            
            
            
              And sometimes it was good, sometimes it was had.
            
            
            
              One of the main learnings was that when I was teaching a
            
            
            
              class of students who not only did not
            
            
            
              intend to do programming for a living, they also did not intend
            
            
            
              to do any programming during my course. They were totally uninterested
            
            
            
              and not willing to put any work into it. That course just
            
            
            
              failed. Like I wasn't going to force them to
            
            
            
              do work that they weren't interested in doing.
            
            
            
              I might not be a good teacher, but I basically gave up on
            
            
            
              them because they also gave up on the entire thing.
            
            
            
              And so we basically let that one go. But on other courses
            
            
            
              with a class of students who had no previous knowledge whatsoever,
            
            
            
              but they were interested and willing to get into the topic,
            
            
            
              we had really, really nice successes and experiences
            
            
            
              based on the feedback, the students really
            
            
            
              liked it. And the nicest feedback that I ever got
            
            
            
              was that at the end of one of these university semesters where
            
            
            
              students have to fill out a teacher evaluation
            
            
            
              form for the university itself,
            
            
            
              those forms are these evaluated by the university.
            
            
            
              And it turns out that for
            
            
            
              courses between ten and 15 students, so like small groups,
            
            
            
              I got the highest teacher status faction
            
            
            
              score in that semester, for which I got a nice prize.
            
            
            
              And that gave me some really strong feedback that
            
            
            
              I'm going in the right direction. This was all that
            
            
            
              I had for you today. I hope you find this useful. Have a good
            
            
            
              one.