Digital Citizenship Resources

Cross-posted from our previous blog site.

Here are some digital citizenship resources that are available for staff use:

One of our favorite resources is Common Sense Media. It includes resources sorted by grade or by theme. They have videos and downloadable (PDF) lessons. There are also eight iBooks for use on iPads or other Apple devices.

Media Smarts is another good site for digital citizenship classroom resources and lesson plans. There are Alberta-specific resources for all grades, and a set of videos and lesson plans related to media literacy.

As well, check out the NHL's Future Goals Program.

See also DigitalCitizenship.net and the Alberta Education Digital Citizenship Policy Development Guide.


Of course the main thing is to have these discussions with staff and students.

Elementary Music and Notes in Sonic Pi

In this activity we are going to play some notes with Sonic Pi.

The song "Johnny Works With One Hammer" is a fairly simple tune, listen to someone singing it:



Did you hear how the sound goes higher and lower? Sonic Pi will play higher sounds when you tell it to play higher numbers, and lower sounds with lower numbers. Try pasting this into Sonic Pi and pushing play to see how it sounds:

# Johnny part one
use_bpm 200
play_pattern [53, 53, 53, 57, 60, 53, 53]

Each of those numbers is a different sound, what we would call a different note. You heard higher numbers as higher sounds, which are higher notes. The use_bpm part is just telling Sonic Pi how fast to play.
But let's get back to our song. We've seen that we can play high and low sounds by telling Sonic Pi to play different numbers.

The number pattern for the first part of "Johnny Works With One Hammer" would be:
53 53 53 57 60 53 53
55 60 60 57 53 53

I've done the first line of the song, try pasting it into Sonic Pi and then completing the second line of numbers.

# Johnny part one
use_bpm 200
play_pattern [53, 53, 53, 57, 60, 53, 53]
play_pattern []

Did that sound like the song we are trying to play? It was close, but some of the notes are supposed to be longer than others. So instead of play_pattern we can use play_pattern_timed, like this:

# Johnny part one and two, with timing
play_pattern_timed [53, 53, 53, 57, 60, 53, 53], [0.25, 0.25, 0.25, 0.25, 0.5, 0.25, 0.25]
play_pattern_timed [55, 60, 60, 57, 53, 53], [0.5, 0.25, 0.25, 0.5, 0.25, 0.25]

The second list of numbers on each line is the amount of time that Sonic Pi will play the note for. Notice that the note 60 will be played for a longer time (0. 5 seconds). In musical notation we say that the shorter notes are "quarter notes" because they take up a quarter of a bar. The longer notes here are half notes. See what the notes would look like for this part of the song.

A quarter note is sort of a filled-in circle, a half note looks kind of hollow. Now let's try to make our program easier for humans to read by storing the note patterns and timing patterns before we actually play them:

# Johnny part one and two, with timing
play_pattern_timed [53, 53, 53, 57, 60, 53, 53], [0.25, 0.25, 0.25, 0.25, 0.5, 0.25, 0.25]
play_pattern_timed [55, 60, 60, 57, 53, 53], [0.5, 0.25, 0.25, 0.5, 0.25, 0.25]

That's starting to look complicated, but hopefully you can see how it can be broken down into parts. There are four "arrays" there, which are basically lists of numbers. The first one is called notes1 and it contains the notes for the first line of the song. The array called timings1 is a list of how long to play each of those notes. Then we just say play_pattern_timed notes1, timings1 when we want to have Sonic Pi play that list of notes with those timings. Let's try it including variables as well. Will this play the same song?

# Johnny with variables and arrays
quarter = 0.25
half = 0.5
notes1 = [53, 53, 53, 57, 60, 53, 53]
timings1 = [0.25, 0.25, 0.25, 0.25, 0.5, 0.25, 0.25]
notes2 = [55, 60, 60, 57, 53, 53]
timings2 = [0.5, 0.25, 0.25, 0.5, 0.25, 0.25]
play_pattern_timed notes1, timings1
play_pattern_timed notes2, timings2

In this example, we said the time for the shorter notes (quarter notes) should be a quarter of a second (0.25) and the time for a longer note (half note) should be half of a second (0.5). We could also have said:

quarter = 1.0/4
half = 1.0/2

or even:

quarter = 1.0/4
half = quarter/2

In case you're curious, the reason it is 1.0/4 instead of 1/4 is that we need to tell Sonic Pi that we want the numbers to be type float instead of integer. If we said1/4 it would equal 0. Don't worry about this yet though.

Hopefully you are starting to see that there can be a lot of math in music. So far we have done the first half of the song "Johnny Works With One Hammer". If I show you the musical notation version of the whole song, do you think you could translate it into something that Sonic Pi could play? It's a little bit like figuring out a code, you need to figure out what numbers mean the same thing as the notes in the musical notation.

You can also try out different instruments by putting a line like one of these at the top of your code:

use_synth :pretty_bell
use_synth :fm

So now you can make music with Sonic Pi. Try some other songs, and tell your friends.

Elementary Music and Sonic Pi Drum Loops

We are going to investigate drum beats and learn a little programming. If you don't have Sonic Pi installed, you'll need to have that done.

Paste the following code into one of the Sonic Pi workspaces, and click Run.

# Drum loop one, half notes
beat_length = 0.25

4.times do
sample :drum_heavy_kick
sleep beat_length
sample :drum_snare_hard
sleep beat_length
end

This is a basic drum loop. Let’s look at the parts of the code line by line.

1. The # symbol means that anything on the rest of the line is a comment. It’s for humans to read, the computer ignores it.
2. We’ve made a variable named beat_length that means a value of 0.25. We’ll use this a few times later.
3. This line is blank so we know that there is something different coming next.
4. Here we are creating a loop that will do something four times.
5. This plays a sample (recording) of a kick drum.
6. The command sleep means to rest for a certain amount of time (in seconds). It will rest for the time stored in the variable beat_length.
7. Play a different sample, this time a snare drum.
8. This tells the computer that it is the end of the loop that started on line 4.

Now lets try adding a few things to the code to make it look like this:

# Drum loop two, quarter notes
beat_length = 0.5

4.times do
sample :drum_heavy_kick
sample :drum_cymbal_closed
sleep beat_length
sample :drum_snare_hard
sample :drum_cymbal_open
sleep beat_length
end

When you click Run you’ll hear high hat cymbal playing at the same time as the kick and snare drums.

Bars of music often have four beats in them, so let’s change it to this and it will play four bars with four beats in each:

# Drum loop three, quarter notes
beat_length = 0.5

4.times do
sample :drum_heavy_kick
sample :drum_cymbal_closed
sleep beat_length
sample :drum_snare_hard
sample :drum_cymbal_open
sleep beat_length
sample :drum_heavy_kick
sample :drum_cymbal_closed
sleep beat_length
sample :drum_snare_hard
sample :drum_cymbal_open
sleep beat_length
end

Now try changing the value in the beat_length variable to 0.25 or 0.7, and try replacing some of those samples with different drum samples:

sample :drum_heavy_kick

sample :drum_tom_mid_soft

sample :drum_tom_mid_hard

sample :drum_tom_lo_soft

sample :drum_tom_lo_hard

sample :drum_tom_hi_soft

sample :drum_tom_hi_hard

sample :drum_splash_soft

sample :drum_splash_hard

sample :drum_snare_soft

sample :drum_snare_hard

sample :drum_cymbal_soft

sample :drum_cymbal_hard

sample :drum_cymbal_open

sample :drum_cymbal_closed

sample :drum_cymbal_pedal

sample :drum_bass_soft

sample :drum_bass_hard

Cool, eh.

Next we’ll try some different rhythms by playing some samples halfway between beats. If each beat before was a quarter note, these would be eighth notes (because half of a quarter is an eighth). Listen to the kick drum:

# Drum loop four, quarter and eighth notes
beat_length = 0.5

4.times do
sample :drum_heavy_kick
sample :drum_cymbal_closed
sleep beat_length
sample :drum_snare_hard
sample :drum_cymbal_open
sleep beat_length/2
sample :drum_heavy_kick
sleep beat_length/2
sample :drum_heavy_kick
sample :drum_cymbal_closed
sleep beat_length
sample :drum_snare_hard
sample :drum_cymbal_open
sleep beat_length
end

That seems to be getting a little long, though, let’s try the same thing with a loop:

# Drum loop five, another loop
beat_length = 0.5

4.times do
sample :drum_heavy_kick
sample :drum_cymbal_closed
sleep beat_length
sample :drum_snare_hard
sample :drum_cymbal_open
2.times do
  sleep beat_length/2
  sample :drum_heavy_kick
end
sample :drum_cymbal_closed
sleep beat_length
sample :drum_snare_hard
sample :drum_cymbal_open
sleep beat_length
end

Not much shorter, but hopefully you get the idea. We two spaces at the beginnings of lines 11 and 12 to show that they belong to a different loop. The computer ignores the spaces, but it makes it easier for other people to read your code. If you want to learn more about code style in this language, check out the Ruby Style Guide.

Getting back to loops, though, try this:

# Drum loop six, another loop
beat_length = 0.5

4.times do
3.times do
  sample :drum_heavy_kick
  sample :drum_cymbal_closed
  sleep beat_length
end
sample :drum_snare_hard
sample :drum_cymbal_open
sleep beat_length
end

You can see that on the first three beats we played the same samples, then different samples on the fourth beat.

Now let’s try some functions.

# Drum loop seven, with functions
beat_length = 0.5

def kickAndClosed
  sample :drum_heavy_kick
  sample :drum_cymbal_closed
end

def kickAndOpen
  sample :drum_heavy_kick
  sample :drum_cymbal_open
end

4.times do
3.times do
  kickAndClosed
  sleep beat_length
end
kickAndOpen
sleep beat_length
end

First we define two functions (using the term def) and then we can call them by their names to get them to do their thing. A function is just a set of instructions that you can reuse later. You might also hear them called methods, procedures, subroutines, or callable units.

Let’s try something with parameters.

# Drum loop eight, with parameters
def play_a_beat(chosen_sample, beat_length)
  sample chosen_sample
  sleep beat_length
end

4.times do
  play_a_beat(:drum_cymbal_closed,0.25)
end

The variables chose_sample and beat_length are passed to the function when it is called.

Now see if you can figure out what this next section of code will do, and then run it to check if you’re right.

# Drum loop nine, nested functions
def cymbalClosed(beat_length)
  sample :drum_cymbal_closed
  sleep beat_length
end

def loop_this(n)
  n.times do
  cymbalClosed 0.25
  end
end

loop_this 16

One more thing, if you want your beat to go on forever, or until you stop it, try this.

# Drum loop ten, in_thread
beat_length = 0.25

in_thread do
  loop do
  sample :drum_heavy_kick
  sample :drum_cymbal_closed
  sleep beat_length
  sample :drum_snare_hard
  sample :drum_cymbal_closed
  sleep beat_length
  end
end

So now you know the basics of creating beats in Sonic Pi. Show your friends.

If you’d like to play with electronic drum machines and make different rhythms, check out free drum machines such as:

WebAudio Drum Machine (online)

Keezy Drummer (iOS)

DMach (Android)

Hydrogen (Windows, Mac, or Linux)

GarageBand (iOS or Mac)

HammerHead (Windows)

what I'm up to these days

A while back I had been blogging daily about what I do, but had found that I seemed to then gravitate towards tasks that I could accomplish easily and then write about at the end of the day.

Instead, I'm going to occasionally write about some things I'm working on. This will include work-related things as well as tasks and projects related to the Masters in Education that I'm hoping to have completed by April 2016.

One of the bigger work-related projects I'm working on these days is open data. We are working on getting some of our data on Strathcona County's Open Data Portal, as well as taking data that we already release and posting it in a more accessible format. We are also interested in getting teachers and students utilizing open data. As I write this, International Open Data Day is coming up soon.

On a somewhat-related note, we're also looking at Open Badges to highlight professional learning among staff in EIPS.

In terms of ongoing work in EIPS, I wrote up a list the other day of things we are often talking to staff about these days.

• Online learning platforms (Google Apps, Classroom, Moodle, etc.)
• Assessment using digital tools (including plagiarism prevention)
• Digital citizenship (mostly safety, ethics, literacy)
• Educational uses for video games (e.g. Minecraft, Bridge Constructor)
• Digital signage for hallways (digitalsignage.com and risevision.com)
• Live video streaming to YouTube
• Podcasting (e.g. school announcements)
• 2D and 3D design and printing (or other computer-controlled tools)
• Getting students building/programming "Internet of Things" and data collection tools
• How to encourage design thinking and computational thinking

And a few things on my to do list at work:

• publish to do list
• plan Scratch Day
• Moodle migration
• automate creation of Google Apps users from PowerSchool
• build a Minecraft server image with a web-based (or VNC) control panel
• help plan summer school technology camps
• explore web-based project management ideas

And a little Python script I wrote today to translate addresses into latitude and longitude coordinates:

Hopefully next time I'll write about some course-related things that are in progress.

Datalogging to the Web with Python, Requests, and Phant

wikimedia.org

I've been looking at various ways of logging data to a web-accessible location, both for students and for my own learning. I think I've come across the simplest and most elegant way of doing this, using data.sparkfun.com (a free data logging service based on their phant engine).

Basically there are three parts to this, setting up the phant storage location, getting the data, and pushing it to the web. Aside from the hardware setup, this all should take about five minutes.

To set up the data storage location, visit data.sparkfun.com/streams/make and enter the appropriate information. Title and Description are required, and the Fields are the things you will be recording (e.g. humidity and temperature). You can change these later. For more information, check the documentation.

After you click Save, it is very important to make a note of the provided values since this is the only time you will get to see them. Copy them to a document and also use the "Send yourself a copy of your keys" option at the bottom of the page.

So now you have a free, Internet-accessible place to log your data. Of course if you'd like, you can even set up your own phant server.

Step two is developing a way to collect data. This could be something like a barometric pressure sensor connected to an ESP8266 module, a button connected to the GPIO pins of a Raspberry Pi, or data that are already available on the Internet. For this post, we'll use weather data from openweathermap.org.

Step three is to push the data. I like Python and I've recently discovered the excellent Requests HTTP library. If you're using a Chromebook or you don't want to bother setting up Python 2.7 and installing that library, you can use c9.io.

Assuming that you have Python 2.7 set up and the Requests library installed, here's some code that will log the current atmospheric pressure.

And there you have it, a few minutes to set up and a few lines of Python to start logging data to the web. Next I'd like to see this all done with a sensor or two connected directly to an ESP8266 module.

Grade 2 Social Studies Interactive eBook

Cross-posted from our previous blog site.

Exploring Iqaluit, Meteghan, and Saskatoon

Shannon Pasma and Karla Holt have created a universally-designed for learning (UDL) student eBook for Alberta's Grade 2 Social Studies Topic 2.1: Canada's Dynamic Communities. The free eBook explores how to get to each of the three communities as well the land, weather, activities, and seasonal clothing in Iqaluit, Meteghan, and Saskatoon. UDL activities and assessment activities are included in the eBook.

Below is a preview of the eBook.

Canada's Dynamic Communities eBook Preview from karlaholt

Please note that the eBook is not interactive in the preview. Download the eBook for the interactive version.

French Immersion Social Studies Minecraft Project: Government (Grade 6)

Cross-posted from our previous blog site.

Check out this Prezi created by grade six students at one of our elementary schools. They created an island in Minecraft to learn about government, laws, charter of rights, and services provided by government.

Voir cette Prezi créé par élèves de sixième année à l'une de nos écoles élémentaires. Ils ont créé une île dans Minecraft à apprendre sur le gouvernement, les lois, la Charte des droits, et les services fournis par le gouvernement.