Finding open resources


I found this resource courtesy of Stephen Downes’ OLDaily. It really struck me as unique, wonderful, and potentially very useful at the same time.

The Open Syllabus Explorer claims to map college courses with over 6 million syllabi.

I know that there are some college and university instructors that read this blog and I would encourage them to take a look at what’s available and might be helpful to them.

My focus is in K-12. In this case, it’s Computer Studies.

One of the powerful mailing lists that I follows comes from ACSE where Ontario Computer Studies teachers are sharing resources, asking for assistance, and looking for inspiration.

Teaching Computer Science is kind of an oddity. Unlike many courses where you just buy a textbook for student use, there aren’t that many textbooks for Computer Science teachers, particularly in 10-12. It’s a bit different if you’re teaching the Advanced Placement courses but for the regular Ontario courses, finding a textbook is incredibly difficult. Personally, I never used one.

Instead, I was always making up my own resources. They probably weren’t generic enough for others to use them but I felt they met my needs and the local interests of students. As such, I was always looking for new resources and ideas. It was always a hoot to find a new problem and work through it with students.

So, why college resources? There’s another dimension to all this. Sadly, not all students see the light and take Computer Science courses until they get to college / university. As a result, at post-secondary, there are often introductory courses. The ideas and inspirations there can be used as well.

I took a look and a search for a very popular programming language – Python. There are lots of filters to narrow your search if needed.

And the list goes on. Now, individual teachers would have to take a look for resources and test them for suitability but it’s a giant start beyond having nothing to work with.

At the least, you owe it yourself to check this resource out.

Step it up


One of the more fun, active, and interesting things that you can do with your micro:bit is to turn it into a step counter. These things are so popular in today’s world; a phenomenon starting with the Fitbit device. Now, you’ll find that counting steps is just one feature of a watch or smartphone that you own.

Making your own using the micro:bit is a pretty easy task and is one of the activities that you’ll find at the project page of the makecode resource. Or, another resource that goes a bit further in Python here.

While a lot of things can be created and run in the editor at the site, this activity is one that you’ll want a real physical micro:bit to play around with and to test.

The key to all this working is an example of another way of having the micro:bit accept input. You’re not going to use either the A or B button here but rely on the fact that the micro:bit can detect when it’s shaken. The assumption here is that each step will generate a “shake”.

I found that it worked nicely. Accuracy isn’t necessarily the goal here; it’s to get the excitement from seeing the activity in action.

In order to fully test it, you’ll need to attach the battery pack (and batteries $$) to the micro:bit so that, once you’ve loaded your code, it will work without being attached to your computer.

I took mine and tucked the micro:bit and the battery pack inside my sock and then took it for a walk. I did so some counting and it did display a count after I stopped and removed it. Unlike my watch, it’s a little more different to get an ongoing count while actually walking! I need transparent socks.

For your morning smile, I will admit that it did feel a little like being under house arrest and having to wear an ankle bracelet. (not that I’d really know) But, with the exercise complete, there really was a bit of a Wow! factor. You really can do some pretty sophisticated programming with this thing.

I think back to my original post for this series of posts about the micro:bit. Could I have done this in an hour when I first started to program? Absolutely not. Even the concept of the step counter would have been foreign at the time. But, in today’s world, what a wonderful introduction to the concept of real-world application programming for students!

I couldn’t have done that in an hour


With the upcoming Hour of Code and Computer Science Education Week beginning today, I’ve been playing around with a number of the tutorials that you’ll find online.

In particular, I’ve got my micro:bit out and am playing around with it using the Python programming language and the tutorials that can be found here. It’s lots of fun for me and I don’t hesitate at all when using the word “playing” in this paragraph.

If you’ve ever programmed in Python, you know that it’s a text-based language and I keep having to make sure that the syntax that I’m using is correct. There is a lot of room for error.

And, growing up learning to program, error was just part of the game. You learn to check and double-check to ensure that everything is correct.

I first learned to program in high school. Wait, Doug, they had computers back then?

Yes, indeed. Ontario even had a curriculum. It was called RP-33: Data Processing and was released in the 1960s. In 1970, there was also Informatics, Intermediate and Senior Division.

We didn’t have a computer at our school actually; we wrote our programs on punch cards and they were shipped to Althouse College in London to be run over night. The next day, we had a chance to see how well we did. Our programs were run on the computer (if I recall correctly, it was an IBM 1130) We programmed in the Fortran IV language and most of our programs were related to business functions. i.e. writing cheques, doing payrolls, inventories, etc. To think that this guy could write a program that would make a computer do something productive blew me away at the time and it still does today.

There were two elements that had to fall into place for success. First, the program had to compile successfully and secondly, it had to execute and generate the appropriate results.

It’s when I think about this that I get so impressed with the opportunities that the beginning learner has today. The second part – doing things correctly will always be the acid test to your programming skills. But, with the drag and drop interfaces that are so common, the first part actually becomes a non-starter.

Instead of learning the instructions and then the parameters needed, you just drag an action to the desktop. If the steps that you’re thinking about using actually fit together, they well, actually fit together.

From the Makecode website, I took a long look at micro:pet. It’s simple enough to get started – you’re creating a pet for a friend. But the whole package is a really rich experience. Yes, there is the coding part but beyond that, there’s making, language, interviewing, etc.

It’s the whole package.

I reflect back to how I learned to program. Typically, it was by learning one or two command or concepts and then doing a few examples and experience the success or lack of it and then move on. Even the simple act of running a program took 24 hours.

It’s just an entirely different world where beginning learners can do what I did and so much more inside an hour. It’s a great time to be learning how to code. I hope that it’s happening in your class.

As noted in this post from last week, I have created an updated Flipboard of resources for 2019. If you’re looking to join a professional organization of like minded coding teachers, consider the Association of Computer Studies Educators.

100 days


There are a lot of challenges shared on/to social media. You’ve probably seen them. Write a blog post daily for 10 days. Or post a picture you’ve taken daily f0r 30 days. Depending upon your devotion, these can be easy or difficult to go the distance.

In the program for the Bring IT, Together Conference, Peter Beens offered a session about 100 Days of Code. Not 10 days; not 30 days; but 100 days. This was like waving a red flag in front of me. I had to check it out.

The session was small which made for an intimate discussion with Peter.

So, off we went. Peter’s presentation resources can be found here.

I went to the session with a particular interest to finding out what Peter was learning about coding and how he found the inspiration to stick with it for the 100 days. He kind of headed away from that discussion by pointing out that, while the process was based on https://www.100daysofcode.com/, the key to success was to make it personal. He had bought into that concept which was the major takeaway from the session, not what he had done personally. I’ll buy that and in the slidedeck, you’ll find some of the challenges that he undertook.

He also encouraged us to think bigger. I found that interesting; use the concept but apply it to something that you’d like to pursue.

Using this approach, he offered these suggestions…

There were a couple of things that he demonstrated that I know that I need to do more and then there are a couple of things that have been nagging me all along that I haven’t addressed properly.

  • of course, the coding. I need to find projects of personal interest and code for more than random things every now and again
  • I do have a GitHub account, but I need to do more with it. Something Peter mentioned of note that really resonated was the more readable links for sharing
  • I’ve always meant to look into GitHub as a blogging platform. Mike Zemansky demonstrates this well with GitHub pages. https://cestlaz.github.io/
  • investigate GitHub for use in the classroom

These are not quick and easy things to address and I don’t see them coming to fruition any time soon.

But, we all need inspiration to move and keep learning. Peter provided that inspiration for me in this session. Thank you, sir.

Coding for Young Mathematicians


I summarized my thoughts about Lisa Floyd’s presentation at the Bring IT, Together Conference like this.

Calculators are successful in Mathematics not because we learn how to write the code to create a calculator but because we use it to get a deeper understanding of non-trivial Mathematics

When I saw this in the program, I knew that I wanted to attend. Lisa has been doing a great deal of research into Mathematics and Computational Thinking and was a keynote a few years ago. I didn’t know what to expect but I was hoping for something other than a “Let’s do something cool in Scratch and then try to tie it into Mathematics or some other subject area”.

I wasn’t disappointed.

I’ve attended many a session like I described above. I always enjoy them (despite the sarcasm) but I always wonder about the claims of how students all understand coding and Mathematics as a result. Is that really true?

I was hoping that this wouldn’t be another like that. Plus the fact that she mentioned Scratch AND Python was intriguing.

As she notes, “Ontario does not have coding in K-8”. Of course this is true but we sure have all kinds of Mathematics! She gave us a number of different examples featuring Geometric Art, Gtowing Patterns, Plotting on a Grid, Probability, … In the presentation, she gave us lots of examples and talked us through the process that she uses.

None of the examples started with a blank screen! She stressed the concept of having students remix her content. By running what she distributes, the students see a Mathematical concept and then their understanding is pushed and enhanced by working with the code to make things something better.

Her approach is very visual by showing the results of the program and then takes on the Mathematics concepts. Tweak this, change that, what happens when you do this? How can you make the output look like this. The primary focus was purely on the Mathematics and the coding was secondary. It was a refreshing approach.

Lisa’s approach was cemented for me on the Friday. I attended a session where we were programming robots using a drag and drop language specifically written for those robots. We were to program them to do a task without knowing just what was happening. Often the tool that we needed was in another menu and we were encouraged to try some numbers to see how far in one direction we could make it go. Turning wasn’t a matter of turning 90 degrees, but applying force onto one wheel going in one direction while the other went in the other direction. We eventually figured it out but lost considerable time in the process. There were something like six groups in the room and nobody got the right answer; some were closer than others. Lisa’s concept of remixing would have fit right in.

I really do like her approach. I made myself another note…

Instead of debugging the program, she could spend time debugging the Mathematics involved…

You can check out some of the examples she used, in Scratch, on her website. Type the URL correctly; Lisa notes that a person with a similar spelling as chosen a different career path.

I had an opportunity to interview Lisa. You can read it here.