Job Posting: Google Teaching Fellow

Here's what you need to know, Google's looking for an awesome educator.

A couple of years ago, +Dan Meyer  posted that the Curriculum Fellow job at Google he had previously worked on was hiring again. I saw that post, and immediately posted my resume to the Google Jobs website. I had no idea how much that action would change my life.

I was very happy as an educator. I worked at an awesome school that used Project Based Learning and had a great robotics team. But there were two things that compelled me to apply. First off I told my students and friends that the only two things that would make me leave my classroom were if the Mythbusters or Google wanted me to work for them. The second was how much I wanted to see others use Computer Science and Computational Thinking in their classroom.

I blogged often about Computational Thinking but I still wanted to reach a wider audience, plus it is difficult to create high quality lessons when you have a class everyday. Since working at Google I've been able to accomplish both of those things (in my humble opinion). The Exploring Computational Thinking reaches many educators each month who are starting to implement the lessons but more importantly the philosophy and tools into their classes. I've also had the privilege of working on many other awesome projects impacting education.

I'm happy to pay it forward and let you know about another awesome opportunity for educators, take a look at the job posting and see if it would work for you. You will have amazing managers, an exciting mission, and you will have freedom to create and innovate. Sounds awesome? You have no idea....

How I Used Google Drive to Create and Host My Web App and Hello Oppia

Has this ever happened to you? Back when my students and I were exploring Computational Thinking and developing using Python, and Processing. We ran into a big stumbling block, which was saving, sharing, and hosting our files.

Even though I had a very supportive IT manager, it was still difficult to have students develop anything substantial. Our students accessed all of their school files on a networked drive which was tricky and slow to access from home, students were not able to create or send zip files, and sharing their work publicly was difficult for numerous reasons. Have you experienced something similar?

For a project in my Masters program we were asked to develop a learning environment. After brainstorming for a little bit, I decided to create a environment where people could determine how well they could recognize the sound of a note and perhaps improve their ability to identify a pitch.

I realized this was an opportunity for me to dangerously overcommit and accomplish four additional tasks within this project:

• Improve my knowledge of web development by creating the environment using HTML and SVG (Scalable Vector Graphics like those created in Inkscape or Illustrator)
• Write higher quality code than I have in the past (Physics Gizmo refactoring is at the top of my list when I graduate)
• Develop and deploy 100% in the cloud
• Support my colleague's 20% project Oppia (more on that later)

Leaving Behind Bad Programming Habits

I am not a professional programmer and I did not study Computer Science at college, so I've picked up some habits that make it difficult to have code that is easy to update and maintain. I recently read Code Complete which taught me a lot about how to improve how I design and write code. I realize it is a tome, but I would highly recommend it and you can skip to the parts you want or need. I'm learning a lot from my previous creations and like any art, it takes a lot of practice to become good at programming.

I have been reading up on some of the new fun features HTML5 provides, but based on some advice from my colleague Neil, I decided to use SVG rather than the canvas. This turned out to be excellent advice and it was fascinating to learn how one can programmatically create graphics. Creating shapes using Python Turtle is one of my favorite activities for students to learn how to think computationally and creating your own SVGs is a great next step. In my experience, students love creating their own works of art and will endlessly play with it until they get it just right, then they'll tweak it to see what happens.

Developing in the Cloud

Why was it so important for me to be able to develop my application using only web-based tools? Well there's the reasons I mentioned above, where my students and I found it difficult to develop, save, and host code (let alone collaborate) from their school laptops. Plus, I have become so spoiled that I like the ability to have all of my files automatically backed up and accessible from any device.

When I started looking into options for ways to develop software online, there were some high quality paid services but these were more than I needed, were cost prohibitive for a classroom, and sometimes required you to use a command line / terminal which was not an option for students at school. On the other end of the spectrum there are many great websites that allow you to code in the browser, but often lack the ability to save your work, Sage and IPython notebooks are two excellent exceptions that would be great additions to your classrooms.

Recently it was announced that you could host a website from Google Drive. I added Neutron Drive and ShiftEdit from the Chrome Web Store and enjoyed using them both. They have many awesome feautres like syntax highlighting, lint testing, and collaborative editing and are each adding new ones all the time. Best of all I was able to write 100% of my code within Google Drive which meant my work was always backed up and I could keep working on it anywhere.

I highly recommend using this process for students to easily create, save, share, and host their work. I would love to see students collaborating on code much like they do with Google Docs for writing. If your school has Google Apps for Education, your IT manager can deploy these apps to your students right away.

On the right is a screenshot of the app I created for my class, click here to try it out. I plan to continue to develop this after I graduate. I'm also sharing the Oppia Opera code if you would like to play with it yourself.

Oppia

My colleague Sean, who works on the Course Builder project, spends his 20% time working with others on a project called Oppia that allows you to create branching explorations.

Think of it like a choose your own adventure tool, but the learner can explore any topic you set up. When I first met Sean almost a year ago, he demonstrated the idea that would later become Oppia using an exploration in combinatorics using three balls. Since then, the team has added more features so you can explore language, music, and more.

When I was developing the music app for my class, I asked Sean if it would be possible to integrate content from another site into an Oppia exploration. I had the PhET tools in mind when I proposed this to Sean and I'm glad to see they were able to pull it off as it opens up many of the simulations and tools that we use and love to have added functionality so students can have a guided exploration through a topic.

Here's a screenshot of a sample exploration where Oppia provides feedback to help you find a landmark:

The team has worked hard over the last few months to make it relatively easy to create and modify an exploration so try it out and send the team your feedback and ideas. Oppia is open source so you can run your own instance or modify it to meet your needs. It will be interesting to see Oppia evolve over time and I am excited to see how we can interact with content online so it is more interactive and feels more like a conversation.

Lots of updates in this post,  I appreciate you reading to the end. I've wanted to share these updates with you for a long time but my Master's program is consuming every minute I have these days. I expect to graduate in May at which point I can continue to explore, develop, and share many other projects I am working on. 

This Year, Rediscover Your Ability to Learn Anything

As I was reading an article critical of MOOCs and online learning (there seem to be no shortage as everyone likes a good straw man), I was annoyed by a certain statement made about halfway into the article.

"Every age has its autodidacts, gifted people able to teach themselves with only their books. Woe unto us if we require all citizens to manifest that ability."

Learning is our natural state of being. We can't help but learn new things. I don't want citizens to manifest the ability to "teach themselves" I want them to rediscover that with resources and support, one can learn anything.

If you are letting someone else set the curriculum and pace for your learning you will inevitably be disappointed. I have enjoyed my formal schooling thus far and have benefited from great educators but I considered them a supplement to my learning not the other way around. I've have always kept a stack of books at my desk since I learned to read. When the Internet emerged, I found both resources and community that addressed my questions that books and the classroom could not answer.

When I was a child, if I wanted to learn about a topic there were two options: learn about it in school, or buy the book. Now I have books, school, videos, forums/conferences, web pages, virtual simulations, online classes, and more. Almost all of these can be found via the Internet from a computer that fits in my pocket.

In this new world, enriched with technology, Educators are not obsolete, they are more useful than ever before. We no longer need to be disseminators of information, and this should be welcome news. For how could we ever hope to keep up with the rapid increase in information. We must be mentors, and as my colleague +James Sanders puts it, curators of quality resources. The author seems to agree with this when she says that education at it's core is, "one mind engaging with another, in real time: listening, understanding, correcting, modeling, suggesting, prodding, denying, affirming, and critiquing thoughts and their expression."

There has never been a better time to learn. Resources and communities are plentiful. Never stop learning.

What programming language should I use/learn?

I get asked often, "Which programming language should I start with?" or "I teach _______ which language would be the best for my classroom?" My goal is not to promote one language but show you the benefits of each of the more popular choices out there and let you make your own decision. There really is no one "best" language, just the best language for what you are interested in doing.

As always I promote technology that:

1. Enhances or encourages learning. Programming is one great way to implement Computational Thinking into your class.
2. The software is free and open source.

Disclaimer: These are intended to be a summary. They are presented in no particular order.

Python

Free? FOSS (Free as in zero cost and open source)

Requires an installation? Yes but there are web based options like sage math notebook. Python comes preinstalled on Mac and Linux.

Strengths: 

• The syntax is very high level so you and your students can take your ideas and very quickly turn them into code. 
• Python is interpreted so as soon as you press enter or run the code you can see the results. 
• It has a large number of modules and support for graphics (e.g. VPython), physics, math, language parsing and more.
• Great for prototyping, web, data mining/processing, and almost anything!

Recommended Tutorials:

    Think Like a Computer Scientist

    Codingbat

    Online Python Tutor

Javascript

Free? FOSS
Requires an installation? No

Strengths:

• Coupled with HTML5 and CSS allows you to add a lot of power and interactivity to your web pages and applications.
• Gives you to access web APIs (directory of available APIs) and use other services.

FYI: Javascript fails silently (meaning if there is a bug, it just won't work the way you intended, there won't be an error message) so use lots of debugging techniques and logs to debug. This is far easier than it may sound and is useful to learn regardless of what language you are using.

Recommended Tutorial:

    W3 School Tutorial

Processing

Free? FOSS

Requires an installation? Yes

Strengths:

• Designed to be very easy to make something visual, beautiful and/or interactive.
• With both Processing and Arduino, it provides an introduction to C++ that is less intimidating.

Recommended Tutorials:

    Official Processing Tutorials

    Examples in the Processing software (Select File and then Examples)

    Learning Processing

Arduino

Free? 

• Hardware: No but Open Source (Sparkfun, Adafruit, and Radio Shack are trusted suppliers)
• Software:  FOSS

Requires an installation? Yes

Strengths:

• Works with off the shelf parts (e.g. motors, LEDs) to cheaply and easily build projects that sense, move, light up, etc.
• Many "shields" are available to easily add functionality like Bluetooth, Wifi, audio, etc.
• Hardware is relatively inexpensive (~$20-30)
• Interfaces easily with Processing to add interactivity and data visualization.

Recommended Tutorials:

    Official Arduino Tutorials

    Examples in the Arduino software (Select File and then Examples)

    Sparkfun Education

Subscribe and follow Phil for more on education and technology.

Physics Gizmo is Open Source

I've put the source to Physics Gizmo on GitHub. If you are interested in helping me develop a tool for students to collect and analyze scientific data in an affordable way I encourage you to join the project.

Physics Gizmo on GitHub
Discussion Group Forum

Physics Gizmo on Google Play

More information on Physics Gizmo can be found at the original Physics Gizmo post on BrokenAirplane.


Subscribe and Connect to see how educators are innovating.

#CompThinkChat on Twitter - Join the discussion

Computational Thinking is showing up in discussions and talks everywhere I look. The Next Generation Science Standards reference them and the skills are implied in the Common Core.

A few days ago, I saw this tweet from @Kevin_Krenz:

and knew that this would be a perfect way to bring the community together to discuss and share experiences with Computational Thinking. Kevin put this planning document together and #CompThinkChat was born.

The first chat is Wednesday Aug 8th at 7pm CST (5pm PST/8pm EST) and continuing every other week. This may not be the best time for everyone who wants to be involved so add your suggested times to the planning doc and let's see what works out in the long run.

If this is your first Twitter chat, here's the steps to get started:

1. Sign up for Twitter.
2. Sign in during the scheduled chat time.
3. If you are using the Twitter homepage search for #CompThinkChat in the upper right corner. This filters out all tweets except those relevant to the chat.
4. Chat! Share your thoughts, questions, link, etc. Note: Make sure you add #CompThinkChat to your Tweets so everyone else can see them.

There are many ways to access Twitter, especially on your mobile device. I personally use Silver Bird for Chrome and Seesmic on Android but do a search and try a few out to see what works best for you.

If you miss out on a chat, they will be archived in the Exploring Computational Thinking General Forum.


Here's the document of Computational Thinking Resources I share in my presentations about Computational Thinking. All are invited to join the chat whether you have been using Computational Thinking since Papert, Wing, or if this is the first time you have heard about it. It'll be exciting to hear the community's thoughts on the implications and possibilities and I hope you will join us!

How many Aces do you need to win at War?

Python is a fantastic language for answering life's questions. It's amazing how such a powerful and popular syntax could be so great for prototyping and trying things out. So one day,  I was teaching my three year old, the card game War

Rules (the version I learned as a kid):
1. Give each player half of a deck of cards face down.
2. Each player turns over a card.
      - The player with the larger card adds both cards to the bottom of their pile
3. If the cards are the same, then it is War!
      - Each player adds three face down cards.
4. Repeat steps 2-3 as needed.
  

It's a great way to practice numeracy and comparing values while being simple enough to learn in a minute. He loved getting Aces and was sad when he started to lose (I have no control over this son!). It got me thinking, what is the minimum numbers of Aces needed to have a statistical advantage?

The trick for this code, was to make it optimized so it could run as many times as I wanted without using up too much memory or taking too long. Additionally, with a couple of data type changes, it became all the more important for me to brainstorm before what my program would look like. It is very tempting to jump right in but with a dynamically typed language like Python you will save a lot of headaches if you plan it out (for more resources on designing programs with your students I direct you to the Bootstrap Math Curriculum/Program).

Change num_games to see how many Aces are needed to have a statistical advantage and increase game_limit if you want to enable a game to go on longer (memory warning: some go on for a long time!). I'm really interested to see what fun discoveries you can make from the data in wins_num_hands.

So what question will you use technology to solve?

from random import shuffle

wins_num_aces = [0,0,0,0,0] #Each win, keep track of original number of aces
wins_num_hands = []
card_values = {'2':2, '3':3, '4':4, '5':5, '6':6, ' 7':7, '8':8, '9':9, '10':10, 
     'J':11, 'Q':12, 'K':13, 'A':14} #Ace is highest value

def createDeck():
    deck = []
    the_card_values = card_values    #local variable for faster processing
    for suit in range(0, 4):    #iterate through the dictionary 4 times
        for card in the_card_values:
            deck.append(card)
    shuffle(deck)    #From the random module
    return deck

class player:
    def __init__(self, halfDeck):
        self.hand = halfDeck
        self.num_aces = self.hand.count('A')    #Count aces in hand
        self.game_over = False
    def nextCard(self):
        try:
            return self.hand.pop()  #Returns next card if any left
        except IndexError:
            if self.game_over == False:
                winning_num_aces = 4 - self.num_aces
                wins_num_aces[winning_num_aces] += 1
                self.game_over = True
                return None
    def addCards(self, current_hand):    #Add the cards to the bottom of your hand
        self.hand = current_hand + self.hand


def warGame():
    deck = createDeck()
    game_limit = 10000
    p1 = player(deck[:26])    #split deck in half
    p2 = player(deck[-26:])
    current_hand = []
    the_card_values = card_values
    times = 0
    while True:
        times += 1
        if times < game_limit:    #restart game if going on too long
            try:    #Fails if there are no more cards left
                current_hand.extend([p1.nextCard(), p2.nextCard()])    
                p1_card = the_card_values[current_hand[-2]]    #2nd to last
                p2_card = the_card_values[current_hand[-1]]    #Last card
                if p1_card == p2_card:
                    for i in range(0,3):
                                current_hand.extend([p1.nextCard(),p2.nextCard()])
                elif p1_card > p2_card:
                    p1.addCards(current_hand)    
                    current_hand = []
                elif p1_card < p2_card:
                    p2.addCards(current_hand)
                    current_hand = []
            except KeyError:    #If a player runs out of cards (None)
                    wins_num_hands.append(times)    #Keeping track of data
                    break
                    return False    #Game is over
        else:
            break
            return True    #Too long a game, restart
            
 
numGames = 100    #Number of games to play
while numGames > 0:
    current_game = True
    while (current_game == True):
        current_game = warGame()
    numGames -= 1

print 'Wins with 0 Aces:',wins_num_aces[0]
print 'Wins with 1 Ace: ',wins_num_aces[1]
print 'Wins with 2 Aces:',wins_num_aces[2]
print 'Wins with 3 Aces:',wins_num_aces[3]
print 'Wins with 4 Aces:',wins_num_aces[4]
print 'Number of hands:', wins_num_hands