Fireside 2.1 (https://fireside.fm) Teaching Python Blog https://www.teachingpython.fm/articles Tue, 12 Oct 2021 13:00:00 -0400 Teaching Python Blog en-us Now What? Reflections https://www.teachingpython.fm/articles/reflection-framework Tue, 12 Oct 2021 13:00:00 -0400 sean.tibor@gmail.com 3dc70f70-e1ee-4ed1-b366-761559a037df Reflection is a powerful tool. And during this period of “Post Online Learning,” it is even more essential to take a moment to reflect on all that has happened during this chaotic or sometimes stressful time. Reflection helps us sift through all the emotions we experienced during these moments and identify, label, and sort these experiences. It has been a successful and interesting start to the year. Coming back to school in person was a bit surreal.

We made it through, now what?

As we did in the past, it is time for us to reflect on how things went in the first quarter, what activities were successful with this year’s group and what things need to be modified.

Reflection is a powerful tool. And during this period of “Post Online Learning,” it is even more essential to take a moment to reflect on all that has happened during this chaotic or sometimes stressful time. Reflection helps us sift through all the emotions we experienced during these moments and identify, label, and sort these experiences.

For @teachingpython, it is a time to evaluate our new group of students and adjust our activities. During our reflection, we use Rolfe et al’s Reflective Framework to look back on our process and goals.

There are a series of supporting questions under each label to help capture details and guide our thinking.

Miro has a great template of this Reflection Protocol, and it works well when working with collaborators.

What? Describe the events

  • What didn’t work well?
  • What could be improved?
  • What was the experience for the teacher?
  • What was the experience for the students?
  • What were the reactions to learning?

So What? How did this affect your learners?

  • What worked well?
  • What did not work well?
  • What outcomes did we want to achieve?
  • What outcomes were not accomplished?
  • What connections did students draw from the experiences?

Now What? What possible changes can you make

  • What adjustments could we make?
  • What new activities can we add to change outcomes?
  • What things will we do differently next quarter?

Reflection does not have to be as structured as this, however, the protocol really helps to set a precedence on our thinking. Once you get in the habit of going through the questions, the process flows naturally.

What things are you doing that need reflection? Whether it is the end of the quarter or just an end of a unit. Give it a try!

]]>
RIP Google Colab in Education https://www.teachingpython.fm/articles/rip-google-colab Mon, 11 Oct 2021 16:00:00 -0400 sean.tibor@gmail.com b9caf920-e238-4022-80bf-13ccc87c98f6 Starting in September 2021, students in K-12 schools began receiving warnings that their access to Google Colab was denied. Increasingly frustrating was that the issue was inconsistent across student accounts. One student could be happily coding away, while the student sitting next to them was unable to access their notebooks. At our school, our technology admins could see that Google Colab was enabled as a marketplace app for all students. One of my favorite apps that I discovered when I became a computer science teacher was Google Colab. Since my students were already very familiar with Google Docs, the concept of a Jupyter notebook within the Google Drive ecosystem was a very natural step for all of us. Students preferred the easy to use interface and we even started creating most of our class assignments using notebooks.

But then a few weeks ago, it all came to a grinding halt.

What's happened

Starting in September 2021, students in K-12 schools began receiving warnings that their access to Google Colab was denied. Increasingly frustrating was that the issue was inconsistent across student accounts. One student could be happily coding away, while the student sitting next to them was unable to access their notebooks. At our school, our technology admins could see that Google Colab was enabled as a marketplace app for all students.

After opening a GitHub issue on the Google Colab project, representatives for Google clarified that access to Colab was disabled starting on September 1 for students marked as being under the age of 18.

From cperry-goog:

We were impacted by the recent change which prohibits access for Education users under 18 to services without an on/off control in Workspace: https://support.google.com/a/answer/10651918?hl=en

We are working to improve access to Colab for Education users in the long run, though I cannot give solid timelines at this time, I am prioritizing this work. For the time being, note that the access policy does not apply to accounts not administered by institutions. As a workaround to allow students to access notebooks, you could also consider using one of our related products, Kaggle Notebooks: https://www.kaggle.com/code

Based on this information, it appears that Google for Education is driving the prioritization of Google Apps and Services that have the correct on/off control in Workspace.

Further, according to this article from TechCrunch, the push to restrict access for Google Workspace for Education students under the age of 18 is part of a broader push to tighten access for minors.

How we were using it

It may not seem like a big deal since there are so many alternatives to code in Python, but Colab had quickly become a core part of our lesson delivery, especially during the COVID-19 pandemic.

For example, a typical week on my computer science classroom might include an interactive coding session where we would teach concepts, a "choice board" homework assignment where students would complete various tasks, and a "class challenge" where the students would have a limited amount of time to figure out how to fix a piece of broken code or solve a coding puzzle.

Each of these assignments worked well in the Colab environment.

  • Interactive coding sessions could be started in a matter of minutes without any installations or dependencies
  • Assignments could be created in Colab and students could make a copy of the assignment and complete their portions either as text for answers to prompts or code cells for their coding solutions
  • Class challenges were easy to standardize knowing that dependencies were met and students could easily upload a screenshot of their final code into our LMS

Alternatives to Colab

As teachers, we've explored a variety of different tools for lesson delivery and coding environments. There are a wide variety of alternatives to Colab available depending on your needs.

Kaggle

kaggle.com

  • Cost: Free tiers available
  • Ease of Access: Easy to start (see caution below about privacy policy)
  • Educational Institution offering: None at this time
  • Control: Owned by Google

As cperry-goog mentioned in his response to the GitHub issue, Kaggle is another Jupyter-based coding environment owned by Google. As noted in the response, Kaggle's privacy policy strictly prohibits the use of their services for students under the age of 13 and requires verifiable parental consent for students between the ages of 13 and 17.

JupyterHub

jupyter.org/hub

  • Cost: Free, requires server
  • Ease of Access: More challenging technical setup and configuration
  • Educational Institution offering: Open-source, none
  • Control: Open-source, managed by institution

Another option is to set up your own JupyterHub server. While this gives you full control over the server environment and configuration, this can be daunting for your average K-12 computer science teacher. Additionally challenging is the coordination with your school or district's technology department to ensure security and policy compliance. But if you can overcome these challenges, there are quite a few third party packages and extensions to Jupyter like NBGrader that allow you to automate parts of your teaching process.

Replit

replit.com

  • Cost: starts at $35/mo per teacher or $750/yr for K-12 institutions
  • Ease of Access: Simple sign up, web-based
  • Educational Institution offering: Replit Teams for Education
  • Control: Run by Replit

This web-based coding environment continues to grow with features. Students can code in multiplayer mode for realtime collaboration, complete assignments using automated test code for grading, and even use graphics packages like Turtle in the browser. Replit runs virtual environments that act more like remote IDEs rather than Jupyter notebooks. While environments can be downloaded, shared, and even committed to Github, they cannot be exported to ipynb format if you require that kind of portability.

Mu Editor / Thonny / IDLE

codewith.mu
thonny.org
IDLE

  • Cost: Free/open-source
  • Ease of Access: Download & install
  • Educational Institution offering: N/A
  • Control: Locally installed, open-source

Of course, you could just forget all this silly web-based Python nonsense and just write and run local Python code. There are several great beginner-friendly Python editors - my favorite is Mu. The downside is that they require more effort to download and install, but they run locally and fast. Once you outgrow them, you'll start looking at more advanced IDEs like PyCharm or VS Code.

VS Code Notebooks

code.visualstudio.com

  • Cost: Free
  • Ease of Access: Advanced setup of multiple programs and packages
  • Educational Institution offering: N/A
  • Control: Locally installed

Although it's the most complex installation and setup, downloading VS Code, installing Python locally, and pip installing Jupyter will get you a pretty advanced setup. You don't have to run a JupyterHub server, everything is freely available online, and you can customize the offering as much as you need.

On the downside, you may end up in a spiral of dependency management, virtual environments, and ongoing updates that may cost you more time in the end.

Call to Action

So in the end, what can we do?

  1. Tell your Google Workspace for Education rep to bring back Colab
  2. Explore & use alternatives like Kaggle, Replit, or locally-managed servers
  3. Create workarounds

Some domain admins have tried creating Organizational Units that mark students as over 18 while they are taking the computer science course. Other educators have asked students to use or set up personal Google Accounts for Colab.

Unfortunately, educators in the K-12 space are stuck waiting for Google to restore access to Colab. And students who spent hours or days creating code in Colab will have to wait for Google to give them access back to their own code.

So now we wait...

-- Sean

]]>
CircuitPlayground Error Bingo https://www.teachingpython.fm/articles/circuitplayground-error-bingo Mon, 04 Oct 2021 12:00:00 -0400 sean.tibor@gmail.com 0bcbf793-208d-4989-bee8-38cdcca29868 As we're teaching using the Adafruit CircuitPlayground, the same errors come up over and over. In order to make this less stressful and more fun, we've made a game out of it! As we're teaching using the Adafruit CircuitPlayground, the same errors come up over and over. In order to make this less stressful and more fun, we've made a game out of it!

CircuitPlayground Error Bingo

]]>
Our Top 5 Bots for the Computer Science Classroom https://www.teachingpython.fm/articles/bots-topfive Thu, 09 Sep 2021 15:00:00 -0400 sean.tibor@gmail.com 6919e6fb-1dfa-4108-a533-64f76ab2aa1f Robots are important in the Computer Science Curriculum. Check out our top 5 bots to use! Robots have become an integral part of the Computer Science Curriculum in many schools, from cute caterpillars to humanoid ML Robots. They play an essential piece in intriguing, engaging, and activating the excitement in kids of all ages. Here are five of our favorite robot friends that we use for our K - 8 learners at our school.

  • Code-A-Pillar - This eight-segment robot is sure to get your youngest learner having fun and into coding. This bot has eight segments of coded parts that will send the robot in the direction pictured. Place the segments in a specific order, and watch how the segment lights up during each action. Kids get an early understanding of sequencing, problem-solving by doing, and critical thinking.

  • Dash - This quirky bot loves to roll around and make fun noises as the learners code them. Dash has so many advanced features that are used to teach a wide variety of computational thinking skills. In addition, this hearty bot is versatile, comes with four free apps and a wide variety of cool add-ons for more playing fun. Learners can practice learning about loops, sequencing, command algorithms, and conditions. For a slightly more advanced bot with different dialogue, check out Dash’s friend Cue. Cue offers a bit more than Dash, with an interactive AI feature, text-based coding in Javascript and Wonder, and a plethora of jokes and responses.

  • Spike Prime is one of our newest friends, and they have stolen my heart. These bots are super sturdy and allow for a variety of bot friends to be designed and coded. With a superb integration with Python, what more can a Pythonista ask for in a bot? How about a solid curriculum to boot? Lego Education provides many ideas and lesson plans that will help you integrate computer science with engineering, science, math, social-emotional skills, and more. Students can follow along with typical lego instructional guides or get creative and build their own creations. The Spike Editor is super sleek and straightforward, and the sidebar service menu of quick Python commands helps students recall and use Python to code their bot more efficiently.

  • RoboMaster- Want a bot that will get students in the door of your Robot club? Then the RoboMaster is your bot. Sleek, modern, and full of appeal, the Robomaster has everything you need to intrigue learners. This omnidirectional moving bot has speed and can be coded in Scratch or Python! Learners can practice high-level math and Physic concepts and AI technology. With a large set of commands, learners can program light effects, movements, and so much more.

  • AWS DeepRacer We love this bot! With a virtual feature and some background knowledge of machine learning and AI, AWS scores big on this bot! AI is here to stay, and with six sample projects included on the AWS website, you can have this bot moving and rolling around a designed track in just a few hours of ML training. This bot does take some learning, though. I have spent some time learning on the AWS Machine Learning Foundations Course, and it has been beneficial for my understanding of python and Artificial Intelligence.

]]>
Hacking the Classroom Hand Sanitizer Dispenser Part 2 https://www.teachingpython.fm/articles/hacking-the-hand-sanitizer-dispenser-part2 Tue, 03 Aug 2021 18:00:00 -0400 sean.tibor@gmail.com 9b449a18-cd85-4f17-bf22-7ef012af7766 In part 2 of this project, Sean hacks our classroom's hand sanitizer dispenser to encourage students to practice better hand hygiene. This project uses Home Assistant, the Amazon Echo, and an ESP8266 running ESPHome to make it much more fun to sanitize your hands. Part 2: Automating the Outputs

In Part 1 of this series, we hacked the hand sanitizer dispenser and got it talking to Home Assistant as a binary sensor. For this part, we'll work on a couple of useful automations in HA that will collect data and make it fun for students to sanitize.

By the end of this part, you should have a sensor that shows today's dispenses, an automation that makes Alexa speak and some lights flash, and even an interface to a local MQTT broker to send and receive data with other devices.

Making Alexa Speak

To make Alexa speak, I needed to send her notification commands using the excellent Alexa Media Player plugin for Home Assistant. The best way to install this was using the HACS project.

Adding Yeelight

I had a couple of Yeelight RGBW bulbs left over from a project last year that I wanted to integrate. This is an officially supported integration for Home Assistant. I put one of them into a lamp by the Amazon Echo and used the WhatsApp effect to flash the bulb green when the dispenser is triggered

Yeelight Device Screenshot

Dispenses Today

Next, I wanted to track the number of dispenses per day. I used the history_stats component for HA to add up the number of dispenses that day. The config entry tracks the number of times the dispenser went from OFF to ON since midnight that night.

  - platform: history_stats
    name: Sanitizer Dispenses Today
    entity_id: binary_sensor.sanitizer_dispense
    state: 'on'
    type: count
    start: '{{ now().replace(hour=0, minute=0, second=0) }}'
    end: '{{ now() }}'

The Actual Automation

Helpers

I created a simple dropdown helper to keep track of the quips for Alexa to speak. The input_select is used to keep a dropdown list of possible quips. The most recently selected quip is chosen as the current option on the dropdown.

Quips Dropdown

This makes it really easy to add and remove quips from the system as you get tired of them. You can also use Alexa's SSML tags to add inflection, emotion tags, and even interjections.

Automation Steps

The automation itself is triggered when the sanitizer_dispense sensor is set to moving. From there, several steps occur.

  1. The random quip is selected from the input_select.quips dropdown.
  2. The quip is sent to the Alexa Media Player's notify service.
  3. The Yeelight is sent the WhatsApp effect
  4. The Twitter integration sends the most recent quip to the Findeiss 1 Twitter account (@FindessO).

Full YAML file

Here's the full YAML file. Once you create a new Home Assistant automation, choose the option from the three-dot menu on the upper right and choose "Edit as YAML." Paste the following into the box and change the names of the devices to match the ones you set up in previous steps.

alias: Sanitizer Dispensed
description: ''
trigger:
  - type: moving
    platform: device
    entity_id: binary_sensor.sanitizer_dispense
    domain: binary_sensor
condition: []
action:
  - service: input_select.select_option
    data_template:
      option: |
        {{ state_attr("input_select.quips", "options") | random }}
    entity_id: input_select.quips
  - data_template:
      data:
        method: speak
        type: announce
      message: |
        "{{ states('input_select.quips') }}"
      target:
        - media_player.pc_s_echo
    service: notify.alexa_media
  - data:
      effect: WhatsApp
    entity_id: light.findeiss_1_table_lamp
    service: light.turn_on
  - service: notify.f1_twitter
    data_template:
      message: >-
        Someone used the hand sanitizer and I said "{{
        states('input_select.quips') | striptags }}"
mode: queued
max: 20

Tracking Historical Data with InfluxDB and Grafana

It's pretty easy to set up InfluxDB to track time-series data using the Supervised verison of Home Assistant. For more information, the Home Assistant documentation is very thorough. While you're at it, adding Grafana is a great way to come up with detailed visualizations.

Once you've added InfluxDB using the Superviser panel, make sure that you have your entities included in your configuration.yaml file. If you're running on a storage-limited device like a Raspberry Pi, then it's helpful to limit the number of recorded streams to just the ones you care about.

influxdb:
  host: a0d7b954-influxdb
  port: 8086
  database: homeassistant
  username: homeassistant
  password: !secret influx_db_password
  max_retries: 3
  default_measurement: state
  include:
    entities:
      - sensor.f1_sanitizer_dispenses_today
      - light.findeiss_1_table_lamp
      - binary_sensor.sanitizer_dispense
      - binary_sensor.east_doors
      - binary_sensor.west_doors
      - counter.printer
      - sensor.findeiss_1_temperature
      - sensor.findeiss_1_humidity

The Finished Project

This project has been running for the majority of the school year and I'm pleased to say that it works very reliably. I've even added a second Raspberry Pi to my setup that displays the Home Assistant dashboard on one of our classroom TVs.

Over the past year, our dispenser has been used 2,838 times. Hopefully that's killed a few COVID-19 bugs. 😀

]]>
Digital Citizenship Examples for the Computer Science Classroom https://www.teachingpython.fm/articles/digital-citizenship Fri, 30 Jul 2021 17:00:00 -0400 sean.tibor@gmail.com f595fbf8-488c-4dd5-97bb-f137d32d5074 Although a coding curriculum lends itself easily to incorporating many digital citizenship skills, even the best Computer Science course may not always find ways to directly teaching them. However, here are some easy ways to ensure that you focus on the three categories of digital citizenship. We sometimes make assumptions when it comes to students and using technology. For instance, we may assume that students are savvy tech users with incredulous talent because they use cell phones and computers daily. We can try to dismiss the fact that students are competent consumers of information but not necessarily mature content producers. Even more important, we may neglect to plan and instill citizenship skills in the core curriculum because students either have Computer Science classes and, by default, already have Digital Citizenship(DC) built into their curriculum. (The last one happens more often than others.)

Although coding curriculum lends itself easily to incorporating many digital citizenship skills, even the best Computer Science course may not focus as much as you think on directly teaching these important skills. Furthermore, it is a lot of pressure for just one class to bear. However, here are some easy ways to ensure that you focus on the three categories of digital citizenship.

For a better explanation of the nine elements check out, Mike Ribble's post, "Essential Elements of Digital Citizenship."


Respect

When students are coding, you open the door to the world. Access to produce, scrape, share, and build programs that can do amazing things is at their fingertips. However, not all playing fields are equal. Teaching students to respect their power and what can happen online should be a constant in any computer science class. Equal access and digital rights, appropriate conduct on social media, and understanding digital property rights and ownership are always in the forefront!

Here are a few examples to help students build respect online:

  • For helping students learn how to interact appropriately online, look into starting a Discord Channel, joining the Python Discord, or joining Twitter.

  • For teaching equal rights, follow the project Call for Code, create a project that focuses on the Social Good topic, or have students research great entrepreneurs in the tech-for-social-good sector. These companies use "digital technology to tackle some of the world's toughest challenges."

  • For using other coders programs, have your students cite their source code in docstrings or have them make GitHub accounts and clone the programs. Teach students that code is out there for use but reproducing it and claiming it as your own is not okay.


Educate

Educating students on communicating online, using digital materials, and being influential consumers is a considerable skill and takes a community to help students develop. And we can do our part in CS Classes too.

Here are a few examples to help students become more literate online:

  • For choosing the right tools, introduce your students to multiple editors and have them evaluate which editors work best for their needs. Have students investigate libraries from the Python Package Index and look for a library that can complete a specific job.

  • To find and evaluate the best tool, have them build literacy by searching for a particular solution to an abstract problem and analyzing the search results.

  • For being strong digital consumers, have students design a maker/tech project. Incorporate a materials list and budget requirement so that students need to search for the best and most economical materials online to build their project.


Protect

Safety online and oflinef is always our priority, but as teachers we need to ensure that we also model it in all classrooms, including computer science. Taking care of our online, digital footprint, and our offline, personal health should be everyone's job.

Here are a few examples to help students become healthier digital users:

  • One thing that is difficult to do when we teaching coding is not to use the computer. However, there are few options that you can do to help instill healthy use online. Use time blocks for work. Allow students to take a break after 25 minutes of work, encourage students to walk away from the screen for 5 minutes, and rest their brains and body. There are many activities that promote CS topics without using the computer online; check out https://csunplugged.org/en/ for a few examples.

  • For teaching about security, it is essential to discuss the importance of keeping passwords secret or using complex passwords. A fun activity is to help students code a password generator. While coding it, you can discuss the importance of longer passwords and not using common words. You can even discuss 2-factor authentication and maybe even add some AI programs into the course.

  • Students need to understand how websites can use data collected from Internet searches, phones, and computers can put them at risk. Discussing Machine learning is a fun entry point in seeing how websites use this data to collect information about the user. In addition, Common Sense Media has a great example lesson that can be modified and enhanced.

Taking an active part in teaching digital citizenship skills is very important in the computer science classroom. Help students understand the benefits of being producers and positive global creators.

]]>
Drill to Skill https://www.teachingpython.fm/articles/drill-to-skill Sun, 25 Jul 2021 08:00:00 -0400 sean.tibor@gmail.com 77c9b6b6-20ac-4538-b211-12835f2110ba Unlocking talent and growing your coding knowledge can be accomplished with a very important process of Drill and Skill. Get a brief peak of growing myelin, from the book "The Talent Code" by Daniel Coyle.

"Practice makes perfect."

"10,000 hours to be an expert!"

"Repetition, repetition, repetition!"

I heard all these quotes growing up, and it continues to persist in my adulthood for a reason. To be good at anything, you need to do it over and over again. Full stop.

Different pedagogies, educational philosophies, various school cultures, and teaching styles become jumbled together over time. Educational reform movements emerge, and often, old teaching methodologies get overlooked on the sideline. For example, the concept of drilling knowledge became a faux pas or an often overlooked classroom necessity when the methodologies of PBL, AGILE, MYP Approaches to Learning, standards-based education, and "playful learning" were introduced. These methodologies are easy to replicate and help students learn more effectively. Upon further investigation, they all have one thing in common; the simple fact that each follows a basic recipe that allows students to drill their learning and practice repetitively. Project-based learning, AGILE practice, and student-led discovery activities allow learners to investigate, stumble, and correct misconceptions and errors during each project iteration.

The act of 'doing,' making mistakes, and profoundly considering the outcomes are definitive ways to learn. Students must write a lot, fix writing errors, and manipulate their words to become better writers. Readers must read as much as possible, slow down their thoughts, and struggle over new words and concepts regularly to become expert readers. Athletes must practice daily, train their muscles, fall, and sometimes lose to develop their skills. Furthermore, developers must write many lines code, fix thousands of errors, iterate continuously, and rack their brains to solve problems to become expert coders. Regardless of what hobby pursued, skill to develop, or paradigm used, practice does make perfect!

An alert learner must practice time after time, day after day, to commit a skill to the long-term memory. However, it is not just any type of practice that is beneficial. Deep practice, with attentive learning, is the key. With deep practice comes neural development. Alternatively, as Daniel Coyle says, in his book Talent Code, "Practice makes myelin, and myelin makes perfect." (The Talent Code 2009.)

)

"Systematically firing" your neurons during active learning exercises helps to build the coating that solidifies your neural pathways. Again, this does not mean just doing more of the same thing. You must always be in the "sweet spot" of learning to build neural connections. The sweet spot is activated during activities defined by Bjork as "desirable difficulties," opportunities that require neurons to fire and struggle. Yes, the struggle is real!

I love this example that Coyle provides about deep practice. Imagine walking into an unfamiliar, dark room. You begin to explore, feel around, bump into things and possibly fall. You get up and explore more, circling the room multiple times. Eventually, bruised and full of adrenaline, you begin to build a mental image of the room, and eventually, you can walk it "quickly and intuitively." You practiced this learning little by little, over and over. And more importantly, you could feel and visualize the process as you learned. It was often painful, but this feeling helped you to learn more. This is deep "myelin" learning and an effective method of drill and practice!

'Drill and practice' is one of the most critical learning methods you can apply when learning how to code. It is not rote memorization of syntax or concepts or repetitively practicing the same things over and over. Instead, 'drill and practice' is an awareness that the learning is happening as you practice. It is this "feeling" of connection, repetition, struggle, and alertness that keeps your learning productive. So next time, you start practicing a new concept, relish the learning moment, repeat what you studied and practice what you learned.

> Happy 'Myelin' Learning!

Coyle, Daniel. The Talent Code. New York, Bantam, 2009.



By definition:
The term' drill and practice' is defined as a method of instruction characterized by systematic repetition of concepts, examples, and practice problems. Drill and practice is a disciplined and repetitious exercise used to teach and perfect a skill or procedure. As an instructional strategy, it promotes knowledge or skill acquisition through systematic training by multiple repetitions, rehearse, practice, and engages in a rehearsal to learn or become proficient. Similar to memorization, drill and practice involve the repetition of specific skills, such as spelling or multiplication. Developing or maintaining one's particular skills, the subskills built through drill and practice should become the building blocks for more meaningful learning. https://www.brainscape.com/academy/drill-and-practice-in-education/

]]>
Live Stream with PyCharm Edu on May 20th https://www.teachingpython.fm/articles/pycharm-edu-live-stream Mon, 17 May 2021 08:00:00 -0400 sean.tibor@gmail.com 34e2c000-5679-40ba-95b6-492e3025f118 Teaching Python will live stream Episode 69 with PyCharm EDU on Thursday May 20 via YouTube, Twitch, and Facebook Live! We're very excited to announce that we will live stream Episode 69 on May 20, 2021 with Valentina Kiryushkina, a software developer on the PyCharm Edu team! This will continue our series on Teaching IDEs for Python that we started with Nick Tollervey and the Mu Editor.

Our stream will start at 1pm Eastern Daylight Time in the US. We'll answer your questions live on the air. If you can't join the stream, please feel free to email your questions in advance to info@teachingpython.fm or through our website.

Set a reminder and catch the live stream here:

]]>
Five Strategies to promote Pattern Awareness in Python https://www.teachingpython.fm/articles/pattern-awareness Mon, 03 May 2021 20:00:00 -0400 sean.tibor@gmail.com 51c90cd7-69ed-45cb-89ed-c79f0197fe28 The brain loves patterns! Using pattern recognition techniques to teach concepts helps students develop a stronger understanding of code.

"Art is the imposing of a pattern on experience, and our aesthetic enjoyment is recognition of the pattern.”

― Alfred North Whitehead



An essential skill that is important to teach in Computer Science is pattern recognition. In 2016, Rittle-Johnson et al. completed a study on the effects of teaching pattern recognition in early math years. Researchers found that helping students find patterns and having strong pattern awareness positively affected student's understanding of more complex math topics in later years. Basic awareness and pattern identification suggest that the brain engages with concepts and tries to connect patterns previously identified. Students who were good at pattern awareness in math developed more confidence with later math topics.

Engaging with patterns and making connections helped students to stay connected with concepts too. Pattern awareness is a staircase-level skill with complexity that increases as the difficulty of the concepts increases. When students become good at identifying simple patterns, they began seeing these patterns and applying them to concepts elsewhere. Therefore, drawing deeper connections with the subject area.

The Cognitive Theory of Pattern Recognition Techniques states that patterns are dependent on a person's knowledge or experience. When dealing with patterns, increasing experiences and information can help the brain seek out templates or other prototypes in long-term memory. (This topic has helped stem machine learning topics regarding pattern recognition in computers. To read more about pattern recognition, click here: https://www.analyticsvidhya.com/blog/2020/12/patterns-recognition-the-basis-of-human-and-machine-learning/ )

Applying this technique to concepts taught in Computer Science is a great way to help students identify patterns in the specific coding language and transfer the knowledge to other Object Oriented languages. "Over time, exposure to these problem-solving situations gives us a subconscious familiarity with their essential nature that we can hardly articulate in words, but which we can easily put into action. (NOVA, 2013)"

A great way to introduce pattern recognition in Computer Science is with the concept of objects and methods. Even in the first few days of teaching students to code, showing how methods are applied to an object can help students progress as they learn more complex Python concepts. Helping students see the pattern between an object and the methods applied to an object helps them build the baseline understanding of how the relationships between them work in an object-oriented programming language without introducing OOP.


Below are five tips on how you can begin teaching patterns using Objects and methods.

1) Repeat and Highlighting

One of the first things to do after printing "Hello World" is to teach the students variable names and 'how to' assign a string data type. However, do not just type a variable and write a string. Try to have a specific way of repeating and highlighting the existing pattern and making a routine for future code-along activities. In our coding class, we refer to each data type as an object and reference the variable name interchangeably when referring to data types. (This simplifies things for Newbies.)

2) Active Teaching

We focus a lot of our attention and time in the early weeks, reading each python line of code aloud as if we were saying it in a sentence. We read both from right to left and left to right, ensuring that each symbol is correctly identified, seen, and spoken. This active teaching strategy helps to commit the language recognition to long-term memory.

For example:

This line of code will read:
[right to left] -- "the string Kelly is assigned to the object/variable, 'first underscore name' or
[left to right] -- "the object with the variable name, 'first underscore name' is assigned to the string Kelly.

I often interchange the words variable and object to reinforce that these are variable names, and we use them as placeholders. I try not to commit to the word variable or the object at this point but stick to saying both. However, identifying these as objects makes it easier to talk about applying a method to an object. (Remember these are 10/11-year-olds coding for the first time.)

3) Tangible metaphors

It is essential to associate the pattern with something familiar or tangible to a new coder. For example, if we use a metaphor for an object they know, like a piece of bread, when we start to discuss methods, it is easy to explain that a method can be applied to an object. We can use bread as our object, and 'Toast' is our method. We can apply the "toasting" method to the bread to change it. We can also apply the "buttering" method to a piece of bread to change it to 'buttered bread.'

Did you notice how the object has a method applied to it? This reminder helps students make connections when we transition from strings to lists or dictionaries.

4) Identify syntax patterns

The other pattern to highlight when working with objects and methods is the syntax and specifically the parentheses. Calling attention to the parentheses at the end of the method will prepare the learner to consider later what can happen inside the parentheses of the methods.

For example, when we append a list or apply the method append to a list object, we can fill in the parenthesis with the object we want to append. Identifying the parentheses early on in a string method like .lower() calls attention that this is a pattern in Python.

5) Always reinforcing the Basic Pattern

Calling attention to other instances that require understanding objects and methods, is when we work with libraries such as the turtle library or the pillow library.

For example, often expert coders 'import turtle as t' or 'from turtle import *.' However, I prefer not to teach these at first and show students only 'import turtle.' (You can also use the 'from turtle import Turtle' option, and it helps to accomplish the same pattern without needing to explain turtle.Turtle())

This import helps enforce the rule that students need to use the object turtle with a new name; thus, when we apply methods to the turtle, we can make it 'move.'

Keeping to the basic patterns reinforces that a 'method is applied to an object,' and the object is 'turtle.' Using the import and naming turtle as t may lead students away from seeing patterns. Furthermore, can also identify new names of turtles as Bob or Sally for more turtle fun. This helps to call attention to the pattern that existed when working with strings and lists and other data types. We also can reinforce the argments within the parenthesis.

These are just a few of the ways to teach pattern recognition in early Python coders. The simple things you do when teaching the basics of Python can make a huge difference in students understanding later on. Helping students see the patterns with the grammar and syntax of any language can help students see the bigger picture. This solid knowledge base provides a template for coders when moving to more complex topics such as objects and functions.


Resources

Rittle-Johnson, Bethany & Zippert, Erica & Boice, Katherine. (2018). The roles of patterning and spatial skills in early mathematics development. Early Childhood Research Quarterly. 46. 10.1016/j.ecresq.2018.03.006.

"The Science of Smart: The Virtues of Confusion." PBS, Public Broadcasting Service, 19 Feb. 2013, www.pbs.org/wgbh/nova/article/the-science-of-smart-the-virtues-of-confusion/.

Youguo Pi, Wenzhi Liao, Mingyou Liu, and Jianping Lu (2008). Theory of Cognitive Pattern Recognition, Pattern Recognition Techniques, Technology and Applications, Peng-Yeng Yin (Ed.), ISBN: 978-953-7619-24- 4, InTech, Available from: http://www.intechopen.com/books/pattern_recognition_techniques_technology_and_applications/theory_of_co gnitive_pattern_recognition



Shop with Teaching Python

]]>
Five Steps for Building Rubrics for Authentic Assessments https://www.teachingpython.fm/articles/authentic-assessment-rubrics Tue, 30 Mar 2021 16:00:00 -0400 sean.tibor@gmail.com 12f54b4e-2620-4188-aee1-f55981963051 In this blog post, we will look at using rubrics to judge achievement on authentic assessments. In Computer Science class, designing quality learning experiences meaningful to our students is the ultimate goal. Developing ways to accurately evaluate students' learning using real-world situations that are applicable yet challenging is the underlying focus.

This blog series will take a deep dive into authentic assessment components and what entails quality assessments. Authentic Assessments in education are a complex topic full of multifaceted features.

Previous posts on Authentic Assessments:
Three Tips for Designing True Authentic Assessments
Setting High Expectations For Authentic Assessments in Computer Science



In this blog post, we will look at using rubrics to judge achievement on authentic assessments.


Rubrics are an excellent tool for both teachers and students when it comes to grading authentic assessments in Computer Science. To learn more about the history of who coined the term and the studies behind them, check out this article from Linda Suskie titled, "An assessment beach read: Where did rubrics come from?"

Because authentic assessments are designed to replicate real-life situations, grading them can be very subjective. Therefore, using rubrics help teachers to be consistent in their grading and stay focused on the criteria initially identified for the task.

Rubrics are not as daunting as they may seem and, with practice, become an excellent tool for designing and planning activities as well as grading them.


Here are five easy steps for designing quality rubrics for authentic learning assessments.

Step one: Writing out General Expectations (Skills or Content)

Write out what you want students to do and, more importantly, what they need to know to do it well. Writing clear expectations is the hardest step in building a rubric. However, if a teacher cannot quickly identify these primary criteria, the assessment may need more refining.

This process of identifying the end results first is often referred to as a "backward by design approach." This is when a teacher can look at the end product and work backward at the instructional steps and activities needed to lead students to an end goal. To learn more about Grant Wiggins and Jay McTighe's work on Backwards By Design, check out this short video and article from Vanderbilt University.

I always like to start with a list of things that the students will use for a final task. These are typically brief and also broad topics that come from my curricular objectives.

For example, students in Computer Science need to know the python basics concepts such as: data types, comments and docstrings, conditional statements, etc.

In the beginning, this list may be general, but as you make more task-specific rubrics, your list may contain more specific items. You will be more focused on seeking out the "Enduring Understandings" versus the things that may "worth being familiar with."

The carefully selected items from this list often turn into the "bolded" headers for my rubric. When converting these to headers, try to keep the items simple with generic concepts or skills.

Some concepts listed may be used repetitively throughout the course and often vary in complexity due to the specific topic. Therefore the concept may be used in the rubric more often than you think, but varying specifics. Other concepts may be necessary to know and do but can be used elsewhere in another assessment.




Step two: Listing Specifics for Completing the Final Task

Now it is time to break down the skills into specifics for the assessment. What precisely "can" be done with this topic. Consider the task, and the bold concept, list the essential concepts that could be covered in class and on this task.

Go through each item in the original list and write bullet points that break down the specifics for completing the tasks. Do not worry about sentences or punctuation yet.

We will use one of the criteria from the list of criteria above for an example.

Use of Comments and docstrings



An example bullet list may look like this:

 ⁍   single-line comment fits in one line
 ⁍   comments describe the purpose of the code
 ⁍   Comments are as close to the line they are describing
 ⁍   Comments do not use complex formatting
 ⁍   Not redundant
 ⁍   Docstrings provide the user with a general overview
 ⁍   Docstring has triple quotes
 ⁍   Docstring is appropriately formatted- has a primary one-line comment, then space then elaboration, then space
 ⁍   Consider the progression of programmer and skill level: from no documentation to full developer documentation

If this is the first time brainstorming, the list may be very long. However, after more experience, you will get the hang of it and omit the criteria that are not suited for your age level or task.

You may be more aware of what is possible and what is already pushing the students' limits.

For example, I know that my students may have had some practice with comments and docstrings. I want them to know the importance of documenting their work; however, it is not the most critical factor in this assignment. Therefore, after weeding out my list, I now have this bullet list for my 7th-grade students:



Use of Comments and docstring

 ⁍   single-line comment fits in one line, less than 72 characters
 ⁍   comments describe the purpose of the code 
 ⁍   Docstrings provide the user with a general overview
 ⁍   Docstring has triple quotes
 ⁍   Docstring explains the program and/or the function




Step three: Writing Power Statements

Now it is time to write power statements. I like to use "the student will be able to" in my rubrics to help remind students that it is their role to complete these steps. It sounds silly, but directly stating this helps to build ownership and guide feedback.

I sometimes use a Bloom's taxonomy Verb Chart (Click here to see an example) to formulate my bullet point statements. Some statements will require recall or knowledge acquisition, and others may need analysis or application. Using these words can also change the strength or complexity of the statement.

After adding power statements, my list looks like this:

Comments and docstrings: The student will be able to...
design single-line comment that follows the PEP8 rule of fewer than 72 characters.  
effectively provide comments to describe the purpose of the code 
develop docstrings that provide the user with a general overview and understanding of the program,
creates Docstrings  with triple quotes in the correct location
explain the purpose of a function using a docstring

Notice how I used bold to highlight my power verbs? Power verbs help students and act as a reminder that this specific action is essential for the assessment.

There are varying degrees of understanding and knowledge needed, but these vary in conceptual understanding on Bloom's taxonomy levels. Choose your power verbs carefully and make sure your students know the difference between the power verbs.





Step four: Deciding on your Rubric Format

Now it is time to decide on your rubric format. There are many formats used; you can scale the levels 1-3, 1-4, 1-5. You can weigh the bold concepts on the importance, or you can use a single-point rubric.

I prefer the latter. You can read more about the single-point rubric here.

After I have copied my objectives, my rubric will look something like this:

I like giving students the flexibility to excel in the concepts they are solid or confident in and still provide the flexibility to differentiate learning. Using a single-point rubric ensures students first a) provide evidence of where they have met the expectation and b) demonstrate how they have exceeded expectations, they know where and how.

Having students write their accomplishments does two things. First, it provides students with a checklist; however, it also adds an extra assessment evaluation.

Step five: Testing it Out

All rubrics can be improved. Just because it looks and makes sense to you does not mean it is ready for implementation. I like to use my rubrics for nongraded assignments before the real assessment. Moreover, I like to use them in chunks. For example, I may use one or two strands for a small task or design a class challenge or teaching assignment for one of the criteria.

Some teachers may feel that giving these rubrics before the assessment or during teaching feels too much like "teaching to the test"; however, it is not.

If these are the criteria that you feel are important for your students to learn, doesn't it make sense that they know them and practice them?

Have the students provide you with feedback on the rubrics. Let the students be reviewers of their peer's assessments. Encourage conversations about objectives or other understandings that may need more work. By working with and improving upon the language in the rubrics as you teach, you ensure that the students can use and excel in the objectives that are important for the curriculum.



Rubrics are a great tool for authentic assessments, classroom assignments and formative assessments. They can help to propel learning and understanding as well as provide a method to assess fairly.

“Deliberate and focused instructional design requires us as teachers and curriculum writers to make an important shift in our thinking about the nature of our job. The shift involves thinking a great deal, first, about the specific learnings sought, and the evidence of such learnings, before thinking about what we, as the teacher, will do or provide in teaching and learning activities.” - Grant Wiggins

By designing rubrics, we enforce selecting objectives and specific learning outcomes before going through the activities we plan to teach and avoid the "forward teaching approach" that may be less beneficial for students.





Shop with Teaching Python

]]> Identifying and Teaching "Mistakes" to Help us Learn Code https://www.teachingpython.fm/articles/four-mistakes Fri, 19 Mar 2021 09:00:00 -0400 sean.tibor@gmail.com 6710c5c1-816b-4898-9acb-c76ebd20aac2 At the start of every coding course, computer science teachers can benefit from explaining to students the process and skills of learning how to fail. Most students' first reaction to using the word "fail" takes their minds to the gradebook and the repercussion that may be felt from their parents or on their GPA if they fail a class. However, explaining how mistakes can be used to enhance learning has many different advantages. I read an article recently, "Mistakes are not all created Equal," from Mindset Works. The article explains four types of mistakes worth understanding and identifying in your classroom. This article got me thinking about my process of how I teach "failure" in Computer Science.

Understanding and growing from "failures" or mistakes while learning to code can help strengthen your learners understanding of the benefits of failing forward, experimenting, and identifying intelligent failures.

At the start of every coding course, computer science teachers can benefit from explaining to students the process and skills of learning how to fail.



Most students' first reaction to using the word "fail" takes their minds to the gradebook and the repercussion that may be felt from their parents or on their GPA if they fail a class. However, explaining how mistakes can be used to enhance learning has many different advantages.

Not all mistakes are the same or have the same outcomes. When teaching the skill of "learning from failure," the first step is to make sure that we define and name the types of failures that occur. Using terminology helps students put this learning into context and understand them more. In addition to defining the types, identifying how each type of failure can improve and help students learn is equally important. However, be sure to differentiate and acknowledge the important difference between learning from mistakes, making silly mistakes, doing things haphazardly or carelessly, and making catastrophic mistakes like not doing our best during important life-altering events.


Let's define and explain the types of mistakes.

According to the article, there are "Stretch mistakes." "Stretch mistakes happen when we're working to expand our current abilities." The MindShift article discusses the Zone of Proximal Development, which is a good strategy for helping students "see the stretch" in a guided or facilitated way. However, I see more stretch mistakes and learning happen when students complete coding tasks of desirable difficulties independently. Unlike the learning that happens in the Zone of Proximal development, these learning mistakes happen when students attempt to tackle something independently and just out of their reach or challenging enough to produce multiple code errors or learning stretches. This type of learning failure also happens during the "Figuring it out Stages" of a learning cycle. Again, this is when students need to seek new knowledge and challenge themselves to find creative answers to problems.

Regardless of how a student gets there, stretch mistakes are good mistakes to make, and they should happen continuously during the learning process. They are not high stakes, they should not affect a grade, and if used correctly, they should invigorate students and inspire them to seek out more challenges during learning. This quote from Frank Wilczek summarizes stretch mistakes well.

"If you don't make mistakes, you're not working on hard enough problems. And that's a big mistake."

Another type of mistake is known as the A-Ha Mistakes. These are failures that are derived after outstanding learning achievements. In my class, we tend to call these the "Clicks and Metacognitive A-Ha's."

'Clicks' happen when a learner is practicing the "Thinking about thinking" or "learning how to learn" techniques continuously. During the lengthy process of obtaining knowledge, connections are made. The 'A-ha moment' is us, learning from what we did not know before and making connections between the new knowledge we have acquired and previously learned information.

The best part of these "Click" moments is that we finally realize the mistakes we had been making and the sudden "A-Ha" of understanding is invigorating. Through thinking about learning and reflecting on the process of learning, our mistakes become apparent, and a new neural connection is made.

"We must master many subjects in order to implement our dreams. Our personal journey begins by gathering appropriate learning experiences and awakening our minds to observe, evaluate, and recall what we experience."― Kilroy J. Oldster, Dead Toad Scrolls

As defined in the article, sloppy mistakes are those careless mistakes that happen because we are not paying attention. In Computer Science, newbie coders tend to make a lot of Name Errors or Syntax Errors.

Understanding that focus, particular processes, and coding habits need to be formed when you first start to code is fundamental. The bad news is that these sloppy mistakes are normal, expected and a regular occurrence when coding. Sloppy mistakes happen when you are learning something new and will always happen regardless of your experience. The good (and bad) news is that as a person becomes more experienced with coding, and even though the mistakes still happen, they will hopefully become easier to spot, identify, and correct.

Computers have no forgiveness for silly and sloppy mistakes, and programs will not run when you have an error. However, to help the process, teachers can guide the students in identifying sloppy mistakes made in code, discuss ways to identify and fix them, learn to read tracebacks better and more importantly, see the benefit of paying attention to small details. Students sometimes do not identify these mistakes, but pointing them out and acknowledging the opportunity to learn from the mistakes is very important.

As stated in the article, "sloppy mistakes can be turned into aha moments" if you embrace them!

"When given an AHA moment, Do not ignore it. Pay attention to it. Your mind is directing you to your truth" ― Christine Szymanski

Lastly, let us not forget about the mistakes that we should always try to avoid or, better yet, if not avoid, at least minimize the opportunity and quickly learn from them. These types of mistakes are typically tied to large consequences, like 'high-stakes" assessments or promotional goals. They can be stress inducing and in worse cases, they can also be life-threatening.

High-stakes mistakes can have a huge impact on meeting learning goals, growth mindsets, and sometimes our motivation. However, like all mistakes, a lesson can be learned from them. Limiting the opportunities of high-stakes assessments in your classes and minimizing the risks involved can help students find the benefit in learning from mistakes at lower costs. However, be careful of removing some level of stress or importance to assessments. Students still need to learn how to work under modified pressure with consequences.

No one likes to make mistakes; however, ensuring and teaching the skills to build reflection and growth in learning from mistakes can help prepare students on methods and techniques for learning from them.

"We need to accept that we won't always make the right decisions, that we'll screw up royally sometimes – understanding that failure is not the opposite of success, it's part of success."

― Arianna Huffington

It is essential that during your lessons, you continue to highlight the benefits of learning from failures. A teacher can help encourage this by avoiding multiple high-stakes assessments, providing multiple opportunities to challenge and stretch learning, and instead of focusing only on end goals, the focus is shifted to the process. Showing students what effective effort looks like during learning, that "stretch and a-ha" mistakes are teachable moments, and that no one is perfect is a great way to empower your learners; it is okay to remind them that everyone makes mistakes.

How do you encourage failures in your class?

]]> Active Learning Code-Alongs https://www.teachingpython.fm/articles/active-learning Wed, 24 Feb 2021 15:00:00 -0500 sean.tibor@gmail.com a8c50b31-534a-4a03-974e-9b39546a23a9 So how can Computer Science teachers change necessary code-along sessions into highly engaged active learning experiences? Open the doors of a classroom, and what do you see? Do you see students sitting in rows facing forward with the Teacher or projector at the center of the learning? Are students passively scribbling on paper or typing silently behind their computers? Or do you see movement, hear chatter, feel the fluidity of the lesson? Is there a transition of typing, talking, and listening throughout the class? Is the learning active?

Bonwell and Eison (1991) described Active learning as a "process of engaging students in "doing" activities". It is a multimode process of delivering topics, knowledge and engaging students in a deeper understanding of topics. Active learning is a unique technique but sometimes it is difficult for students and teachers to begin. (To learn more about Active learning check out The Center for Teaching at Vanderbilt article Active Learning

There are many reasons why active learning is not used often in classrooms:

  • Teachers must change their roles as knowledge experts to experienced mentors.
  • Active learning lessons take more time to plan and to teach.
  • Active learning requires students to transition their role as passive recipients into active risk-takers in the learning process, and this is sometimes a difficult transition for students.

Active learning takes commitment, and it is often easier to slip into a 'content expert role' in a computer science course. Instructors can get hooked into demonstrating cool tricks and code chunks that seem to flow with ease; and teachers can cover more topics in a shorter period of time. However, students may be quickly copying the instructor's code, but they may not have time to process or "chew" into the topics.

Although computer science teachers may feel that the students are engaged with code alongs, the lessons' copying and coding techniques may resemble old-school lecture and note-taking activities from other curricula, resulting in less learning than originally planned. This lecturing resembling activity can result in computer science classes becoming a face forward, rote learning experience instead of an active one.


So how can Computer Science teachers change necessary code-along sessions into highly engaged active learning experiences?

The code-along activity can become an incredible active learning experience. It can be a high engagement activity that propels student understanding to a new level. A typical "I code, and you copy" event becomes a brainstorming, questioning, discussion, demonstration, and highly motivating experience! (To learn more about Active learning activities check out Queens University Course on Active Learning Strategies. )

So how do you start planning for an active learning code-along? (If this is your first time using active learning exercises, make sure you know your students, have established rapport, and student norms are explicit.) Consider these questions as you are preparing your active learning lesson.

  • When preparing an active learning lesson, these questions are useful for planning:
  • What is the most important thing to remember is your lesson's objective?
  • What is the goal of the lesson?
  • How will you know that learning happened?
  • What will you assess?
  • What do the students already know?
  • How long will the lesson take?
  • What level of understanding do you want to achieve?
  • What are the desirable difficulty levels for the students?
  • What activities will you use to teach the concepts?


Let us use simple functions as an example:

  • Objective: Functions can be used to repeat an activity in your code and use them successfully to complete a specific repetitive task.

  • Prior Knowledge/Activities: Sample exercises, definitions, example code

  • Goal: Develop a generic "app" that has multiple functions.

  • Assessment: Students will manipulate the final code and add their flair.

  • Lesson duration: 45 minutes

  • Level of Understanding: Understand the importance of functions, can see the benefit to using them, can use basic functions in code.

  • Hook(Brainstorm): Ask students what to make: Give suggestions, a contact app, a friends app, a birthday info app, etc. The hook helps you connect on a topic that interests the students, and by providing some suggestions, in the beginning, you can guide the suggestions to ensure that functions will work well with that topic.

  • Possible Activities:

    Think aloud: Work together as a large group, one student explains one step on how to complete the app, and another student writes out the steps needed(in Pseudocode) to make the app. Ensure that you call on as many students as possible.

    Peer Instruction: The Teacher starts by asking a question, What would be a good name to define the function for _____? Give students few minutes to make a function name for all the steps designed during the think-aloud. Then call on students to define the function's name with "pass" and write these down for the code. Guide the names that are not descriptive, and check syntax.

    Work together in groups: Assign a function for each group to write a docstring for. Share.

    Pause procedure: Use the pause procedure to add wait time between posing questions and waiting for a response. Students will often wait and allow the teacher/coder to code for them. Be prepared to wait extra time initially and make sure that the same students are not solving all the coding challenges.

    Demonstrations: The Teacher begins coding on a particular function, demonstrates how to look up library methods and functions, for example, using the datetime documentation, or the Teacher can force code errors and challenge students to fix the code.

    Retrieval practice: Code some, and wait. Seek out responses and quick check-ins for students to recall previous concepts. For example, Teacher says, "This function needs a keyword argument. Why do you think this is true?" Have students recall what a keyword argument is, have them explain why and their reasoning."

These are just some activities that can be incorporated easily into a code-along lesson during Computer Science. What other ways can you turn your code-along activities into something more active?

“Give a man a fish you feed him for a day. Teach a man to fish and you feed him for a lifetime.”




Resources

Game, Prodigy. “8 Active Learning Strategies and Examples [ Downloadable List].” Prodigy Education, [www.prodigygame.com/main-en/blog/active-learning-strategies-examples](www.prodigygame.com/main-en/blog/active-learning-strategies-examples)

https://users.cs.jmu.edu/adamses/Web/CS430/Lectures/p52-mcconnell.pdf

https://cft.vanderbilt.edu/wp-content/uploads/sites/59/Active-Learning.pdf

]]>
Specialization is for insects https://www.teachingpython.fm/articles/generalists Thu, 18 Feb 2021 06:00:00 -0500 sean.tibor@gmail.com 4663a678-33f9-4771-8084-60fb058293ca Is it possible that everyone learning to code later in life can achieve the same goal? I believe so. Does one need to be a programmer and only code for a career? No, but you could if you wanted to.

"A human being should be able to change a diaper, plan an invasion, butcher a hog, conn a ship, design a building, write a sonnet, balance accounts, build a wall, set a bone, comfort the dying, take orders, give orders, cooperate, act alone, solve equations, analyze a new problem, pitch manure, program a computer, cook a tasty meal, fight efficiently, die gallantly. Specialization is for insects." — Robert Heinlein

I was at the right place at the right time, and now I am a coder. This is not the case for everyone in the educational system who teaches coding. Most people are often surprised when I mention that I only began coding three years ago. I did not come into coding of my own "free will", though the reason I am still at it and why I love it, would no doubt cause some surprise.

Anyone who wants to develop a specific skill set, for example, learning to play an instrument, has to maintain a focused and intense effort to rack up as many hours of practice as possible. This deliberate effort is guaranteed to allow a person to develop expertise in the subject. However, if one procrastinates, one is unlikely to achieve success, nor will one be able to "catch up" to others who started sooner and were more diligent and focused.

There is a direct correlation; the more effort one puts in, the more likely one is to succeed. This focused learning concept is not rocket science, nor is it a newfound method for learning something; so how come, then, more of us are not experts in our fields? Why are we all not specialists in something?



David Epstein, in his book Range, explores the concept of generalization and how it beats specialization. He proposes that one does not need a head start to be good at something; one must only try, and try again because learning by failing is the best way to learn.

Epstein highlights stories of the world's most successful athletes, artists, musicians, inventors, forecasters, and scientists, and throughout these epic stories, he proves that generalists, not specialists, are destined to surpass the greatest in the field. Generalists frequently set their path late, and they manifest numerous interests rather than concentrating on a singular one. They are also more imaginative, sprightlier, and far more relevant than their more focused peers.

Barbara Oakley, who wrote "Mindshift", also believes in the power of "second career" learners. Those that learn an opposite skill enhance their confidence and career prospects.

Is it possible that everyone learning to code later in life can achieve the same goal? I believe so.

Does one need to be a programmer and only code for a career? No, but you could if you wanted to.

I am no different from most educators who have a passion for learning. There is a desire to understand what is unknown and research more, and learn deeper in our obsession. I say obsession in a truly positive manner.

Nevertheless, is staying a specialist in only one field always the best option? How can we, as teachers, embrace lifelong learning if we do not struggle to learn something new throughout our lives? What new skill can you learn today that is completely opposite of your current role and may require you to struggle and fail?

What can you do that will surprise you?

For all those who say, "I can't code" or "You can't teach an old dog new tricks." I challenge you!

]]>
#mindshift https://www.teachingpython.fm/articles/mindshift Mon, 08 Feb 2021 06:00:00 -0500 sean.tibor@gmail.com ddc18750-19e9-4c16-b710-c273f396d60d I recently finished both the Mindshift book and course by Barbara Oakley and Terrence Sejnowski, and my motivation to write this blog comes from what I have taken in during this experience. I recently finished both the Mindshift book and course by Barbara Oakley and Terrence Sejnowski, and my motivation to write this blog comes from what I have taken in during this experience.

When I started to code, I really did not appreciate the powerful change that was about to occur, not only in my teaching but also in how I think and solve problems. After reflection, I identified moments where both my weaknesses and strengths benefited me; an understanding of the power of 'switching gears' between my passions and work; and a realization that a new way of encouraging students needed to be adopted.

The Benefits of your Weaknesses

Learners come in all 'shapes and sizes.' I learned quickly during my pre-med Biology program that I was not a good memorizer. It took a lot of effort for me to recall things. However, in some courses, like Anatomy, I excelled because it had a lab associated with them. I remembered muscle groups and bones from the lab and dissection exercises because I was 'doing' the investigation. Being active in your learning helps your brain to recall and process as you learn. Active learning is defined as "any approach to instruction in which all students are asked to engage in the learning process.

Mastering content or a new role in your job is possible. If you have the luxury of learning it at your own pace, wonderful. If you have a deadline, do not stress. Steady and consistent learning with positive growth is attainable. I like to remind myself of a quote from the book High Expectations Teaching, "Smart is something you can get." Take your time to digest new material at your own pace.

Always identify your strengths and weaknesses in learning. Look for ways to use your strengths to minimize, while still growing, your weaknesses. When I learned how to code, I took every possibility to talk code out and code as I learned. I also wrote things down a lot. I needed to "do" in order to learn.

When I started to teach code, I encourage the students to write a lot of code. In a one-quarter course, my 6th graders roughy type 8000 - 15,000 lines of code. People are surprised by how much my students learn. I know that part of their success is due to their "doing of the work!"

I am a very slow reader. I take every opportunity to read as much as possible and various types of reading material. To improve a weakness, you need to practice that weakness intentionally and faithfully. When you code or try to solve coding problems, it is essential to sift through reading material to develop a solution. My reading weakness is offset, yet still practiced by my strength in information and media literacy skills. I can locate valid and reliable information that is easier to comprehend. I improve my reading and research skills and become faster at finding the right information and still process what I read efficiently.

Focus on your weaknesses not because they set you back but because they help you find new ways to succeed. In Mindshift, they discuss the fact that bad memorizers are often very creative, just because you cannot commit things to memory as quickly as others, do not stress, you have a strength in you that they may not have. Use your creativity to enhance how you learn and work.

Ability to Switch Gears

One of the concepts that really played a critical role in my learning was my work environment. In the MOOC course, we discussed how the people you hang out with can strongly influence who you become. For me, this is a resounding, 'YES, I agree!" I would add that having two opposing environments in your life can be beneficial to your work and health.

Learning to code takes a commitment to learning. This is especially true if you are trying to make a career shift as a developer. You may feel that you need to learn everything you can, all at once, to try to catch up with those who have been coding for years. At times imposter syndrome may kick in, and you push yourself more. "Go! Go! Go!"

Trying to learn too much at one time is counterproductive. You need to switch gears and surround yourself with the right people. Your environment for learning is critical to your success.

At work, I tend to surround myself with active learners and do-ers. These are people who take courses for the experience of learning and not just the degree. People who take on projects because they learn by doing; people who read books to better understand life and who always push themselves to improve, not only because they have to, but because they are committed to becoming life-long learners. These people are continually pushing the limits and motivate me to always try to outperform my current self. Surround yourself with colleagues or peers that inspire you and help you improve.

At home, I am surrounded by family who reminds me that switching off and slowing down provides me more time to play, read magical stories, and create new things and crafts. They remind me that less is more, and the freed-up time makes space for more fun, love, and creativity. Switching off provides time for me to focus on my health and well being. And it gives me the added benefit of allowing my brain to organize all that information that I learned during the day.

These opposing lifestyles help to create positive environments that contribute to productivity and success. I like to think of it as an "extended 8 hour Pomodoro method" of work and focused learning with "extended 5 hours" of play and diffused learning. Switching gears and learning multiple things will help you grow your knowledge stack and 'broaden your passions.' Your environments can be various too, and not just at home.

Take a look at the environments where you live and work. Are they conducive to growth and improvement? Do they expose you to new areas that will encourage development? If not, change your environments,

Adopting a New Pedagogy

When I was little, I loved everything about porpoises. I wanted to be a marine biologist. I loved being on the boat in the middle of the ocean. People who loved me encouraged me to follow my passion, all except my Marine Scientist godfather, said, "Don't follow your passion, let that be your hobby. Being a Marine Biologist who only works with dolphins may be too specialized; you need to make sure that you have a backup plan."

Follow your passion. It is a common statement that many adults tell children. It is well-intentioned, but it can cause a bit of a stifle in the future. This also applies to adults. Following one passion is not bad, but it does not allow you to broaden yourself. To expand in areas and develop skills that may become your passion one day. Having a job where you are specialized or only know one thing can backfire on you and leave you questioning what next.

Don't encourage students to just "follow their passions". Encourage them to find many passions. Encourage them to find a love in learning and investigating new things, and developing the topics they love.

Picking up a hobby and learning something new can help you grow as a learner and help you in your current career. Take some online courses, learn new topics, pick up a new hobby or craft, or read various books. You never know how learning a new skill can brighten and open up your future. As quoted from the Mindshift course, "With the disruption of the new information economy comes plenty of new opportunities. Be prepared for a lifetime of learning!"

Resources

Mindshift: Break Through Obstacles to Learning and Discover Your Hidden Potential
by McMaster University https://www.coursera.org/learn/mindshift/home/welcome

Mindshift: Break Through Obstacles to Learning and Discover Your Hidden Potential Paperback – April 18, 2017

]]>
Four Tenets to Object Oriented Thinking https://www.teachingpython.fm/articles/object-oriented-thinking Sat, 30 Jan 2021 07:00:00 -0500 sean.tibor@gmail.com fba36255-1b28-4526-ab67-a2796cc6abe2 Understanding Object Oriented Programming as a new coder has always been something that has failed to make sense to me. I can copy it. I can read about it. However, when it comes to writing classes or teaching why a sprite is a way it is with a dunder init function, I struggle to do it. Moreover, I do not think I am alone.

Human beings do not live in the objective world alone, nor alone in the world of social activity as ordinarily understood, but are very much at the mercy of the particular language which has become the medium of expression for their society. It is quite an illusion to imagine that one adjusts to reality essentially without the use of language and that language is merely an incidental means of solving specific problems of communication or reaction. The fact of the matter is that the real world' is to a large extent unconsciously built up on the language habits of the group... We see and hear and otherwise experience very largely as we do because the language habits of our community predispose certain choices of interpretation."
Edward Sapir (quoted in [Whorf 1956])

This quote emphasizes the fact that the languages we speak directly influence the way in which we view the world. This is true not only for natural languages, such as the kind studied by the early twentieth century American linguists Ed- ward Sapir and Benjamin Lee Whorf, but also for artificial languages such as those we use in programming computers.

Excerpt from Oregon State book, OOP Thinking Chapter 1)


How do we get our students to start thinking about Object Oriented Programming while still teaching procedural coding practice?

Object Oriented thinking, a term that we have adopted in our classroom and curriculum, is a term that means moving from procedural thinking in coding basics into a more object/method process of thinking. Object Oriented programming concepts such as classes and instances are challenging topics for beginners to comprehend, but by reframing and helping students identify patterns, you can make learning OOP easier. Object Oriented thinking is a great way to get students to start thinking about Python objects, methods, and jobs in preparation for the transition into more complex OOP code.

Understanding Object Oriented Programming as a new coder has always been something that has failed to make sense to me. I can copy it. I can read about it. However, when it comes to writing classes or preparing my students for more OOP, I struggle to do it. Finding ways to teach students why a sprite is a way it is with a dunder init function, or how to think about writing classes without just copying someone's code is difficult. Moreover, I do not think I am alone.

When I first started coding, I googled OOP. I read a lot. I know Python is an OOP language, a language based on objects. Got it! When writing code from books, readers are instantly thrust into copying classes of rockets or other objects to move around a screen. You can replace class names and then call the code your own, but how much is really learned?

How much of what is copied makes sense enough to write an original program? I would wager that most students do not get it.


"The mind unlearns with difficulty what it has long learned." -Seneca

Objects have methods, and different instances of objects exist.

Creating a new class creates a new type of object. This allows for new instances of that type to be made.

The DRY method, don’t repeat yourself, of using Classes and instances allows us to limit repetition within code, and reduce redundancy.

We learn something. We use it daily. It becomes second nature and it makes sense to us. Therefore, it must make sense to everyone, right?

Wrong!

OOP languages make sense to many developers or lifelong coders but it is often difficult to find ways to explain it to new coders because it is difficult to "unsee it once you learn something. " And sentences like this one from, Geeks for Geeks make no sense to a beginner but seem very logical to an experienced coder.

"Creating a new class creates a new type of object, allowing new instances of that type to be made. Each class instance can have attributes attached to it for maintaining its state. Class instances can also have methods (defined by its class) for modifying its state."

It is difficult to see what new learners are unable to see. It is often hard to remember and teach the "stuck" feeling when you cannot remember what kept you from not 'seeing' the objects in the first place. A long-term coder who has mastered OOP concepts sees the patterns while a new coder fails to make the connection.

It wasn't until I started to see the patterns and connections that classes and methods made sense.


How do we get our students to start thinking about Object-Oriented Programming while helping them to transfer to a less procedural coding practice?

Teaching students about classes is not as easy as we think it to be. It is not a simple ' I code, you code'; they got it. It is a lot different than the procedural paradigm of coding. After 4-6 weeks of coding, students can generally write basic original programs on their own. The procedural method is easy for students to understand and mimic because it has been learned before, in science, in narrative writing, and in other courses. Write what you need to do from top to bottom and read it from left to right.

You see it in a beginner's code every day and as they progress to using more complex code in their turtle programs.

What if, during the early stages of teaching students to code, procedural instruction of coding is intertwined with OOP thinking?


To make real use of object oriented programming, we often need to teach students how to see the world in a new way. The way a programmer thinks about solving a problem is typically the way that the code will be developed. Transitioning the way we teach problem solving and designing code can help a student feel more comfortable with object oriented programming.

By introducing this way of thinking, students can begin to imagine pieces of code as objects that have jobs(procedures) and methods of doing their job. Furthermore, more complex concepts, such as objects, are introduced, and refactoring code throughout instruction can help students use terminology and skills necessary for OOP. Starting students with the refactoring of procedural code and identifying more object-oriented thinking can help students "unlearn" the need to make all code procedural and understand that they may need to use OOP to do cool things.

This video from Linkedin, offers insight into how students can see code in a more procedural cookbook way versus through objects and methods. These metaphors help to create mental images for the two thought processes of coders. Its simplicity and visuals offer learners and teachers a good starting point for Object Oriented thinking. Moving between procedural and object oriented paradigms happens as the code becomes complex and the need to reduce redundancy becomes obvious.


Four tenets to designing lessons that promote object oriented thinking

Teachers put a lot of time into designing lessons that help to develop skills in students. The collective skills that a coder needs to develop in order to produce original code are complex. It is not a simple task and requires a wide variety of skills that are intertwined. A few basic tenets can be used to help students develop a more object-oriented way of thinking.


The first tenet is to teach students how to read code both "top to bottom-left to right" as well as "right to left and bottom to top."

For example:

greeting = "hello"

Procedural:

The variable "greeting" is assigned to the string "hello".

OOP thinking:

Thinking: The string "hello" is assigned to the object called "greeting"



title_greeting = greeting.title()

For example:

Procedural:

Reassign the greeting variable to another variable name and make it title case.

OOP thinking:

Apply the title method to the String object to capitalize greeting and assign it to "title_greeting"


The second tenet is to use language that will help students communiate and develop a more object oriented way of thinking.

The information in provided in inline quotes and is repeated to the students. It is used to reinforce the language of object oriented coding.

For example:

Procedural:

import turtle as t #always write this to import turtle
t.forward(100) #make t move

OOP thinking:

import turtle #import turtle library with all the functions and methods
bob = turtle.Turtle() #assign the turtle object turtle from the Turtle class to an object named "bob"
bob.forward(100) #apply the method .forward() to make turtle move give it parameter for distance

I like to tell my students:
"The turtle module is a library full of all kinds of functions and methods that some cool coder programmed for us. These cool coders wrote all kinds of libraries with objects, classes, and methods, so that all we need to know how to do is read the documentation and write the essential lines of code.

I follow up with:

  • Different ways of doing something to an object exist in code.
    • We can apply functions and methods to make an object react.
  • Objects exist in Python, and we apply methods to them.
    • .lower(), .append(), .keys()


The third tenet is to point out the patterns and repeat often.

Throughout the course, I like to help students see patterns.

The patterns that exist in code are beautiful. Lining up different types of objects and methods in code can help students identify patterns easier. Using color and writing on whiteboards also helps. The basics of code and identifying a few easy patterns can help students understand more code complexities later on.

For example:


Methods are applied to the objects. Students can see this with string, list and dictionary methods easily.

The fourth tenet is to use mental images and comparisons with ordinary objects.

  • Objects can be different things, just like objects in our lives.
    • strings, lists, dictionaries, turtles are the same as chair, car, cookies, and games
  • There can be many objects of the same data type.
    • We can put many lists, strings, and turtles in our code. Just like we can have many types of chairs, cars, cookies, and games.

Helping students to start visualizing, and comprehending the patterns in code is a great way to help them comprehend OOP.

These four tenets are a good start for developing OOP thinking. There are many more techniques such as desiging and developing solutions that can also help with the mindset.

In addition, keeping these questions in mind as you develop lessons can help you plan more effective lessons for more object oriented thinkers:

  • How can I explain things better to my students?
  • How do I ensure that eventually, they will "see" objects and never unsee them?
  • When do my students need to know and understand classes and instances?
  • When is the right time to teach them this?

What other questions exist? How do you you get your students to start thinking about Object Oriented Programming while still teaching procedural coding practice?



Resources

“Instance Method in Python.” GeeksforGeeks, 2 July 2020, www.geeksforgeeks.org/instance-method-in-python/.

OOP Intro Chapter 1 Thinking Object Oriented. http://web.engr.oregonstate.edu/~budd/Books/oopintro3e/info/chap01.pdf.

Stone, Olivia Chiu. “Object Oriented Thinking - Python Video Tutorial: LinkedIn Learning, Formerly Lynda.com.” LinkedIn, 27 Nov. 2018, www.linkedin.com/learning/programming-foundations-object-oriented-design-3/object-oriented-thinking.

]]>
The NLTK library and Real Python Projects from Lee Vaughan https://www.teachingpython.fm/articles/real-python-projects Thu, 21 Jan 2021 10:00:00 -0500 sean.tibor@gmail.com 90125021-89dd-4bfa-862d-4acb535cced0 The best thing about Python is that there are a lot of Python libraries and projects that facilitate teaching complex topics in other curriculums. From data science and graphs to probability and math to analyzing text, using Python makes learning concepts, unique! I have been 'gifted' more books by my wonderful colleague. This project is from Lee Vaughan's "Real World Python" Chapter 3. I recommend this book for all Python learners!


The best thing about Python is that there are many Python libraries and projects that facilitate teaching complex topics in other curricula. From data science and graphs to probability and math to analyzing text, Python makes learning complicated concepts unique!

Analyzing extensive or lengthy text is one skill that is common in both English and Humanities courses. Students often have difficulty finding meaning or comprehending text. However, two python libraries useful for "scraping" the web and understanding language are Beautiful Soup and the NLTK project.

The NLTK project library is "a wonderful tool for teaching, and working in, computational linguistics using Python," it is "an amazing library to play with natural language." Overall, the NLTK library helps the computer to analyze written text.

Literacy experts have determined that readability for multiple ages increases when a sentence is 15 words or less. This code allows the user to select sentence length and the number of sentences to extract from the text to produce text that is easier to read and comprehend the text's overall meaning.

This project from the book Real Python Projects is an excellent example of how these two libraries work together and can help English teachers, teaching reading comprehension skills and analyzing text.

In this well explained and elegant project, each function is defined and explained.

The program gets a text from a website (requests library), tokenizes it into smaller sentences, removes stopwords or words with little meaning, and then looks for words with a higher frequency.

In Vaughan's example, he uses Martin Luther King's "I have a dream" speech. This speech is also useful in school and is a great activity to use in January to highlight Dr. Martin Luther King's birthday. It is also an excellent example to demonstrate how the NLTK library works. (To read more about the NLTK library, check out this tutorial from Data Camp, "Text Analytics for Beginners."

Projects like these are great ways to incoorporate authentic assessments and projects into any classroom.

]]>
Three Tips for Designing True Authentic Assessments https://www.teachingpython.fm/articles/authentic-assessments-truetest Sat, 09 Jan 2021 07:00:00 -0500 sean.tibor@gmail.com c5abf232-06de-4085-8c78-8a8f945f57a8 In Computer Science class, designing quality learning experiences meaningful to our students is the ultimate goal. Developing ways to accurately evaluate students' learning using real-world situations that are applicable yet challenging is the underlying focus. This blog series will take a deep dive into authentic assessment components and what entails quality assessments. Authentic Assessments in education are a complex topic full of multifaceted features. What constitutes quality, authentic assessments, and how do we identify meaningful conditions for students? One of the frequently used markers in designing an authentic assessment is ensuring that it is "tied to real-world contexts and constraints, and requires the student to "do" the subject."

In Computer Science class, designing quality learning experiences meaningful to our students is the ultimate goal. Developing ways to accurately evaluate students' learning using real-world situations that are applicable yet challenging is the underlying focus.

This is part two of a blog series that takes a deep dive into authentic assessment components and what entails quality assessments. Authentic Assessments in education are a complex topic full of multifaceted features.


Grant Wiggins asks a great question in many of his assessment articles. One question that permeates is, "What is a true test?" In Wiggins's explanation, a "true assessment" not only measures intellect but should also be a replica of performance that professionals experience every day yet differentiated to the appropriate age. The assessment should not measure a checklist of the average abilities that other students can achieve and the rote content from a text but should be less superficial, less recall of a single performance, and mirror the real-world goals.

When designing an authentic assessment for Computer Science, we first need to identify what are the actual tasks that we want our students to be good at by the end of the course. The "test" of proficiency in code should not be completed at the end of teaching each concept or done because we need another grade in the gradebook. A well-designed assessment is similar to a programmer's daily role to get the job done.

It is sometimes difficult to know or understand a professional programmer's role if you have never been a programmer. Therefore, designing activities that mirror authentic jobs in the field may be difficult. However, with proper research and discussion with other professionals, we can devise the student's learning experiences more accurately. Look for the skills needed as a programmer as well as the content and knowledge. Also, depending on the students' age, specialization in a particular field, such as front-end design or Machine Learning, or web development, maybe a primary focus of skills. If students are younger, focus on developing computational and soft skills, such as learning new concepts and applying them to other problems, communication skills, problem-solving, or asking good questions. The specific coding language may be a perishable skill for some students' future; however, focusing on durable skills can help ensure authenticity to the real-world experiences.

Grant refers to a concept known as "evidence of knowing." As educators, we must first decide the activities students will be good at and the proficiency level we wish them to reach before assessing them. What is it that we want them to do is the primary focus.

Knowledge is vital for students to obtain during instruction. Computer Science teachers have a curriculum filled with content that needs to be understood and recalled frequently to succeed. However, the ability to recall information is not an authentic assessment of a programmer. For example, knowing that a list is mutable, used to store and access various data types, be nested, and looped through is fundamental for a student to obtain and know; however, assessing these facts' by regurgitation is not a valid assessment. Students should use this knowledge to determine when a list is beneficial for solving a unique problem in an authentic challenge.


Here are three tips when designing authentic, true test assignments.

  • Look to do: As you dissect the curriculum, look for areas in the learning that focus on recall and disconnected "dysfunctional habits" and switch them for more process-focused, connected, and active activities that allow students to "do" the learning. Software developers research, design, test, evaluate, identify, determine, maintain, communicate and write code. It is a job that is always "doing" something. If most of your curriculum is watching, listening, or reading, switch those activities for more active learning activities.

  • Use what is there: Developers look for areas to modify existing programs or upgrade existing code. Use former students' code or your own code, and have students improve upon it. Can they make the code more pythonic? Simplify repetitive code? Or can they take two pieces of their own code, to make a "mashup," to create a new seamless product? One of favorite 6th grade activities is to have kids mash together a turtle library project with another project they have completed.

  • Make it a PBL: Design open-ended assessments that solve a problem. Project-Based Learning allows students to solve a problem in a variety of ways. Even if you do not have time to complete a true PBL assessment, use some of the structure to design open-ended projects where students have agency and create various solutions. For example, use inspiration from Caines Arcade and have students create their own arcade with the Microbits.

If designed well, the learning should be messy, require students to decide, and be more connected to areal-life situations. It is only after this learning that a "true test" of learning can be made.




Works Cited

"Authentic Assessment." Center for Innovative Teaching and Learning, [citl.indiana.edu/teaching-resources/assessing-student-learning/authentic-assessment/index.html](citl.indiana.edu/teaching-resources/assessing-student-learning/authentic-assessment/index.html).

Wiggins, Grant. "A True Test: Toward More Authentic and Equitable Assessment." Phi Delta Kappan, vol. 92, no. 7, 2011, pp. 81–93., doi:10.1177/003172171109200721.

]]>
Setting High Expectations For Authentic Assessments in Computer Science https://www.teachingpython.fm/articles/high-expectations-authentic-assessments Sat, 02 Jan 2021 07:00:00 -0500 sean.tibor@gmail.com 9fbe82d0-9ec0-46ed-80c7-1b54ef6a48ff Real-world coding tasks require a specific technique for completion. When solving coding challenges, a high level of coding knowledge and syntax is used. Programming takes commitment to improvement and time spent on iteration. When designing Authentic assessments in Computer Science, try to replicate the patterns in the real world. Setting high expectations for students is a great way to prepare them for authentic assessments. There is a difference in the quality of work when the expectations are NOT to "just get it done" versus doing what you can to learn and understand. Developing a growth mindset early on can help. Empower students and be prepared to provide them with the skills and critical feedback they need to succeed. What constitutes quality, authentic assessments, and how do we identify meaningful conditions for students? A promising direction is to start developing exercises that demonstrate a specific level of expectations set throughout a course. Therefore, this post will focus solely on one component of authentic assessments: high expectations for students.

In the Computer Science class, designing quality learning experiences meaningful to our students is an ultimate goal. Developing ways to accurately evaluate students' learning using real-world situations that are applicable yet challenging is the underlying focus.

This blog series will take a deep dive into authentic assessment components and what entails quality assessments. Authentic Assessments in education is a complex topic full of multifaceted features.

Most research shows that development and assessment that is authentic can raise learning outcomes in students. Therefore there are many aspects for teachers to consider when developing these types of assessments.

For this blog series, I will use the Meriam dictionary's short version defining authentic assessment and Grant Wiggins's conceptual explanation for clarification on the topic.

According to Meriam dictionary, authentic assessments are _"a set of methods or techniques for assessing the academic achievement of a student that includes activities requiring the application of acquired knowledge and skills to real-world situations and that is often seen as an alternative to standardized testing." _

Additionally, _"Wiggins (1990, 1992, 1993) emphasized that tasks should mirror real-world activities and assess students' "habits of mind" (1993)." Tasks are not authentic, necessarily, just because they are similar to real-world tasks, but they must mirror the complexity, collaboration, and high-level thinking necessary for the most intellectual of professional problem-solving and decision-making. The assessments act as instruction and skill-building opportunities, not merely as tools of evaluation." _ (Defining Authentic Assessments, 2012)

To read more on Grant Wiggins's clarification of the topic of Authentic Assessments.

Every student progresses at their own pace. When setting expectations for students, you must develop adaptable, challenging situations and, most importantly, show compassion for their individualized learning paths.

The best place to start demonstrating high expectations in the classroom is to be the teacher who believes that all students can achieve. This should be a primary goal.

Send a Clear Message

A confident and passionate teacher trusts the process and attempts to instill this passion in students. The message is clear and consistent. Students know the teacher's intentions and that learning, not the grade, is the focus. Students understand that the teacher's role is that of a facilitator of their knowledge and not a giver of information. The expectation is that it is the student's job to learn. The ownership of learning is on the student, and this message is clear and consistent throughout the course..
Read more on How to Develop High Expectations in Teaching.

Establish the Mindset

Another quality is to set a growth mindset in the classroom.

In our classroom, we have this sticker. The progression from "I won't to I will" is an excellent reminder that a growth mindset is necessary to learn. It is one of the most critical foundations in developing expectations of growth in the classroom. Getting students to believe that their abilities are not static and that learning requires hard work and commitment is vital to developing their growth mindset. All students can learn, and students need to hear this and believe in the words that we choose to use in class.
Read more about Mindset

Empower Students

Teachers must also instill self-empowerment in their learners. Every child is equally capable of being successful. Practicing heutagogy and learning ways to build agency and choice into the classroom provides a concrete path for high expectations. The self-determined learner understands that there is a path for developing competencies and capabilities. Learning to code is not something that originates from cramming or memorization of vocabulary concepts.
Read more about What is Heutagogy

Give accurate and consistent feedback

Use "wise feedback" to promote growth and improvement, making sure to state your expectations explicitly. The phrase, "I am giving you this feedback because I have high expectations, and I know you can reach them." This statement is used when completing code reviews or "assessment reviews. Then direct feedback is given versus the immediate answer. How can the code be improved and what resources can the student use to improve upon the assessment. (Breaking the Cycle of Mistrust, 2014)

Hard Work pays off

The ability to learn is not linked to an innate ability. Learning is challenging, and learning that comes easy is NOT always real learning. Avoid praising only high academic achievements; switch the praise to individualized achievement. Stress proficiency in the learning process, not just completing the tasks. Teach strategies on "how to work hard in learning," not just working a lot. Provide students with the skills needed to solve coding problems and devise opportunities for students to "work hard" on challenging tasks.

"Nothing in the world is worth having or worth doing unless it means effort, pain, difficulty… I have never in my life envied a human being who led an easy life. I have envied a great many people who led difficult lives and led them well."― Theodore Roosevelt

Real-world coding tasks require a specific technique for completion. When solving coding challenges, a high level of coding knowledge and syntax is used. Programming takes commitment to improvement and time spent on iteration. When designing Authentic assessments in Computer Science, try to replicate the patterns in the real world. Setting high expectations for students is a great way to prepare them for authentic assessments. There is a difference in the quality of work when the expectations are NOT to "just get it done" versus doing what you can to learn and understand. Developing a growth mindset early on can help. Empower students and be prepared to provide them with the skills and critical feedback they need to succeed.




Resources

“Authentic Assessment.” Merriam-Webster, Merriam-Webster, www.merriam-webster.com/dictionary/authentic assessment.

Grantwiggins, and Grantwiggins. “Authenticity in Assessment, (Re-)Defined and Explained.” Granted, and..., 26 Jan. 2014, grantwiggins.wordpress.com/2014/01/26/authenticity-in-assessment-re-defined-and-explained/.

“Hard Work and High Expectations: Motivating Students to Learn: KidSource Online, Inc.” Hard Work and High Expectations: Motivating Students to Learn | KidSource Online, Inc., kidsource.com/education/hard-work-and-high-expectations-motivating-students-learn#sthash.a5dkz8BG.dpbs.

Napper, Kristine. “The Necessity of Having High Expectations.” Edutopia, George Lucas Educational Foundation, 26 June 2019, www.edutopia.org/article/necessity-having-high-expectations.

“Practical Assesssment, Research, and Evaluation: Vol 17: Iss 1.” Practical Assesssment, Research, and Evaluation | Vol 17 | Iss 1, scholarworks.umass.edu/pare/vol17/iss1/.

Saphier, Jon. High Expectations Teaching: How We Persuade Students to Believe and Act on Smart Is Something You Can Get. Corwin, a SAGE Publishing Company, Learningforward, RBT, PDK Phi Delta Kappa International, 2017.

“What Is Heutagogy?” Heutagogy Community of Practice, 5 Mar. 2013, heutagogycop.wordpress.com/history-of-heutagogy/.

]]>
Three Learning Theories to Guarantee "The Click" https://www.teachingpython.fm/articles/learning-theories Mon, 28 Dec 2020 08:30:00 -0500 sean.tibor@gmail.com 8e44d79f-a1a4-4331-ac0a-2d4f5ad3c3d8 Many learning theories have proven to help learn how to learn. Using a combination of them throughout a course can help to improve click moments for all students. How does a teacher plan for and design a curriculum that ensures the "click"?


The "click" is a magical moment that every teacher awaits. Sometimes referred to as the "a-ha moment," it is defined as the "moment of sudden realization, inspiration, insight, recognition, or comprehension."

It is a beautiful time when light bulbs come on, and learning happens. It is a moment most teachers anticipate and one we strive to repeat. For most teachers, predicting the exact time for every student's click is difficult, and ensuring success with all students, although desirable, sometimes impossible. However, if specific instructional techniques and learning paths are applied, one can devise a plan that can have a more substantiated success rate.

Every quarter, I tell students that computer science may seem like the most demanding and challenging class ever; however, it is not far out of reach. The hardest thing that they have to do is to "Trust the process." It is a lot to ask of 6th-grade students, but I believe so much in the process and work hard to improve upon it each learning rotation. From qualitative research and reflection, I have found that the' "click" typically happens in weeks four to six of the course.

Every student is different. Learning varies for all brains. Therefore, it has been challenging to identify the exact strategies and order that guarantee learning for all my students; however, a few techniques have proven beneficial to the learning process. These techniques and learning theories are relatively reliable, and using a combination of them helps ensure that learners can learn. The caveat is the word "learners," or those that want to learn.

Here are the top three strategies I use to promote learning in my computer science class:


Spacing, Repeating and Interleaving

My College Anatomy and Physiology teacher told us every day in class, the only way to learn is by “Repetition, repetition, repetition.” This concept stuck with me, not only because he said it with a solid Latino accent, but because he was right!

Learners must repeat items enough times for the neural connections to become "used" and fused. "Neurons that fire together, wire together." (Stevens, 2019) However, it is not enough to have rote learning and regurgitation over the same item day after day. Memorizing rote topics is a useful technique and does help learners retain vital vocabulary and concepts, but real learning does not happen outside of the context. Implementing a spiraling approach in the instruction, with both rote and contextual repetition mixed in, helps promote neural connections.

Space topics out throughout the course to allow a period of interleaving of new concepts. Every lesson becomes a different representation of the same subject as new concepts are weaved into the process and taught within a new context. The repetition of this process repeatedly throughout the course allows the brain to "mix up" related topics and gives the neurons time to rest. (Read more about interleaving here: The Scientific American)

A straightforward first dialogue repeated throughout the first 3-5 weeks is this type of conversation.

“What is this piece of code?
It is an object.
“What type of object is this?”
It is a string.
How do we know it is a string?
It is surrounded by quotes.
“Let’s apply a method to this object and assign this string to the variable name...”

The dialogue is trivial; it happens in the first two classes of computer science. However, I repeat this when teaching print statements, input functions, items in a list, dictionaries, methods on objects, and every time we see a string.

When teaching computer science, concepts appear in various situations but typically with the same patterns. Things that seem trivial to you may be the one thing that may deter retention for a student.

Showing topics in various contexts allows students to connect to many concepts, repeating these patterns in the brain, allowing neurons to wire together in multiple patterns. Find ways to interleave these concepts with different activities, graphing flow charts, reading articles on other topics, playing Minecraft, or completing a Gimkit or online quiz game.


Mental Images

Throughout the course, look for ways to help students make mental images with new vocabulary and knowledge. Dual coding theory, hypothesized in 1971, states that images and texts could help support the memory of new complex items. Although some doubt lies within this theory, many learning specialists confirm that using mental images to help learners understand topics is critical to advancing understanding.

Some studies show that a person that can “see” an image in their mind, learns two and half times faster than those that do not. Helping students visualize the complexities of what happens “behind the scenes” of everyday objects helps them make connections to code. (Read more about mental images in learning here: Using Mental Imagery)

When coding, the use of only words and conversation tends to be the norm. Find ways to “draw” the concepts out on the whiteboard. Making graphs, sketches, or using physical components while teaching helps students “see” the code clearer in their minds.

One simple example is the explanation of inputs and outputs. Students are instructed to think about an electronic object in their home that requires them to “do” something in return for something happening. Students tend to visualize a remote or perhaps their Alexa or even their computer login. Have students sketch out the flow chart for this activity, assigning an input, decision branch, and output. The flowchart can have structure and correct form or allow students to draw the chart so that it makes sense to them. This simple activity leads us into many opportunities to discuss input functions, buttons, sensors, and conditional statements.


Desireable Difficulties

It is natural to learn from opportunities that challenge us. Desired Difficulties in learning are opportunities designed to be more difficult than average and should take longer than usual to solve. These activities require thought and often challenge the brain to access both long and short-term memory.

The hardest part of using desirable difficulties in class is trusting the process. Most teachers and students want the learning to be more comfortable and take a shorter amount of time. However, when learning is hard, more errors and mistakes happen. Students can become frustrated that they are confused, or feelings of lack of abilities can happen. However, Dr. Robert Bjork and Dr. Elizabeth Bjork propose that learning occurs when there is a struggle to solve and slow down the learning process. What may appear as students not learning promptly or being successful is the opposite.

Learning that

a) requires time to process,
b) accesses different parts of the brain, and
c) promotes thinking differently about a solution,
creates different learning pathways and long-term retention of knowledge for all learners.

(Read more about desirable difficulties here: Desirable Difficulties in the Classroom)

Every week I try to provide opportunities for students to process and challenge their minds. There are many opportunities for this to happen in a computer science class. One way is to incorporate what I use to dub “5-minute challenges”. These weekly challenges are short coding problems designed to reinforce learning but are new and slightly different from what students have already seen.

Initially, I limited the amount of time on “5-minute challenges” as not to “waste” opportunities for class instruction; however, now, students are given more time to process and work through the solution. Moreover, learning opportunities are not wasted, even though more class time is used. The challenges are often complicated, but most students can solve them when given time to process and seek the solution.

"If I, as a teacher could get a student to generate an answer rather than my giving it to them, they'll remember it much better later on, but they have to be able to generate it by virtue of what they know already and the cues the instructor would give them. They have to succeed at the generation." - Dr. Robert Bjork

The best part of these challenges is that solutions can vary, thus providing opportunities for class discussions afterward and the thought process on how the problems were solved is shared.

Many learning theories have proven to help learn how to learn. Using a combination of them throughout a course can help to improve click moments for all students. To find out more, look into cognitive science strategies in learning.

Have fun reading and trust the process.


Resources

“‘Desirable Difficulties’ Can Lead to Deeper Learning and Better Retention.” "Desirable Difficulties" Can Lead to Deeper Learning and Better Retention | Tomorrow's Professor Postings, tomprof.stanford.edu/posting/1419.

Conyers, Donna Wilson and Marcus. “Brain Movies: When Readers Can Picture It, They Understand It.” Edutopia, George Lucas Educational Foundation, 13 May 2014, www.edutopia.org/blog/brain-movies-visualize-reading-comprehension-donna-wilson.

“Neurons.” How Do I Learn, www.washington.edu/howdoilearn/neurons/.

Pan, Steven C. “The Interleaving Effect: Mixing It Up Boosts Learning.” Scientific American, Scientific American, 4 Aug. 2015, www.scientificamerican.com/article/the-interleaving-effect-mixing-it-up-boosts-learning/#:~:text=Instead, your brain must continuously, that interleaving strengthens memory associations.

Stevens, Alison Pearce. “Learning Rewires the Brain.” Science News for Students, 3 Dec. 2019, www.sciencenewsforstudents.org/article/learning-rewires-brain.

Sumeracki, Megan. “Learn How To Study Using... Dual Coding.” The Learning Scientists, The Learning Scientists, 1 Sept. 2016, www.learningscientists.org/blog/2016/9/1-1.

“UCLA.” Bjork Learning and Forgetting Lab, bjorklab.psych.ucla.edu/research/.

“Using Mental Imagery Processes for Teaching and Research in Mathematics and Computer Science.” International Journal of Mathematical Education in Science and Technology, Vol. 00, No. 00, 15 July 2009, 1–13

]]>
The Art of Perfecting https://www.teachingpython.fm/articles/curriculum-review Mon, 21 Dec 2020 07:00:00 -0500 sean.tibor@gmail.com 909e483f-431a-46b4-baaa-1719534e91e7 Reflection regarding curriculum design and learning outcomes should always be at the heart of curriculum planning. Becoming part of the "quality culture" where improvement is the only option, feedback is critical, and alignment to standards and goals are a significant focus is a full-time endeavor. How is a successful computer science curriculum designed?


When the semester or year ends, consider what could have been better about that marking period? How can the curriculum be improved for the next group of students? Reflecting on past courses and discussing change opportunities are essential for promoting students' quality experiences and good practice.

Reflection regarding curriculum design and learning outcomes should always be at the heart of curriculum planning. Becoming part of the "quality culture" where improvement is the only option, feedback is critical, and alignment to standards and goals are a significant focus is a full-time endeavor.

Whether you are just starting or teaching Computer Science for years, your first step when completing a curriculum reflection is to identify, list, and answer a few essential questions. These questions are guides for developing ideas and areas of concern to plan and modify the curriculum. It is good practice to keep the learning expectations at the forefront and remember what knowledge is the most important to retain?

I like to list as many questions on paper, regardless if they need immediate answers or not. This should become a checklist for curricular review and a great reminder of why and how to teach.



These are just a few of the larger questions to consider. Whether you are looking to redesign just a unit or an entire course, remember that learning happens as students create and maintain knowledge and meaning of content. Students should have opportunities to question their thinking.

1. What is the final goal?

Keep your end goal in mind always, regardless if it is only a unit redesign or multiple courses combined. What is the one thing that students will remember 10 or 20 years from this date? What is the Big Idea? Why is this meaningful to the students?

"If an idea is “big” it helps us make sense of things. So, an idea is not “big” merely because it categorizes a lot of content. “Change,” “relationships,” and “number system” certainly encompass an enormous amount of knowledge and understanding, but these concepts don’t contain much insight or direction beyond their definition. They aren’t particularly powerful or illuminating on their own as concepts. On the other hand, “For every action there is an equal reaction” is a powerful idea about change: we can use it to study, organize, make sense of phenomena, and predict changes in motion. " - Grant Wiggins

2. What concepts are critical to know? How can new and current topics be incorporated into the curriculum? "How can we keep the content current and find effective teaching materials that create a student-centered learning environment? "

Understand that not all the content can be taught in one course. What content is critical to know yet also allows students the opportunity to expand should they desire? What are the building blocks you will need to make a solid foundation of learning?

3. How are students acquiring knowledge of the content?

Make sure the delivery of content is active. Do not become the sage on the stage when the content is complicated or "hard to learn." Passive learning is not the same as active learning. Active learning gives the teacher foresight into students' understanding; constant and constructive feedback is a large component of active learning. Find ways during active learning to assess each student and do not rely on the same type of assessment every time.

"But how do we get from transmission of information to construction of meaning? Such a change can entail a consider able shift in roles for the professor, who must move away from being the one who has all the answers and does most of the talking toward being a facilitator who orchestrates the context, provides resources, and poses questions to stimulate students to think up their own answers. " - Allison King

4. What tools or resources will students need to enhance their learning?

Tools help support the curriculum. What will students need to use in order to learn optimally? Will videos be made? Which editors will allow ease of learning?

5. What happens if a student already knows the content? How will we choose to respond when students do not understand or do not learn as expected?

How you choose to differentiate topics with students can set the pace for the entire year. Always have a plan for students that are beyond the scope of the content currently being taught. How can you extend the topic and still give the student opportunities to engage with the course's social aspect? Plan for students that struggle; set aside time to provide help. Look for alternative ways to explain complex topics and in different modalities.

6. What skills outside of the content should be part of the curriculum? What skills are the best for each specific age group?

Keep in mind the skills that you are trying to develop. How are you explicitly teaching and assessing those skills? Avoid assessing the skills that have not been taught or assuming that skills acquisition was at the same rate for every student.

7. What projects will be meaningful to learn? What type and variety of assessments will be used? What are we doing to ensure that our students are always learning?

Students learn best when assessments and learning require cognitive and social opportunities. Look for areas where the teacher is the giver of knowledge and find ways to change those lessons. Students require cognitive and social activities to learn optimally. The direct transfer of knowledge from the teacher to the student does not happen passively. Student learning is about knowledge creation, the transformation of experience into skills, and the application of qualifications to solve a problem that, in practice, is recognized as being competent.

8. What authentic assessments will keep students engaged and connected? What is the best language for the student? Is it inclusive?

Design coding activities within a context that students will understand. Try to embed them into situations that apply to student's lives. Each group of students is different. Be ready to be flexible and look for ways to connect the content to the student group's context and the individual student. The learning changes over time and space very quickly.

9. What activities allow knowledge creation and application of current knowledge at the same time?

Learning is a mixture of activities. What knowledge do the students already have in their "toolbox," and how can the lessons help students develop and merge existing knowledge and new knowledge successfully?

10. How can feedback be used to improve student's learning?

Providing quality and timely feedback improves learning. Feedback also allows students to learn from their mistakes? Students not only need feedback, but they must learn how to use it as well to improve. Find opportunities to give a variety of feedback time in your lessons and for grading. Design lessons that allow time for peer editing and improvement. Seek out assessments where feedback is critical to the assignment.

Lastly, develop a personal learning community. Find people within your community to discuss content and learning activities. Encourage peer and mentor observations. Seek out people to help you reflect and evaluate your teaching strategies and content. Embrace change and redevelopment of your curriculum.






Resources

Chapter 6. Feedback: The Long View—Does Feedback Improve Learning http://www.ascd.org/publications/books/116066/chapters/Feedback@-The-Long-View%E2%80%94Does-Feedback-Improve-Learning%C2%A2.aspx#:~:text=Increase%20students'%20interest%20in%20feedback,with%20obvious%20value%20and%20interest.

From Sage on Stage to Guide on the Side https://faculty.washington.edu/kate1/ewExternalFiles/SageOnTheStage.pdf

Improving Students’ Learning Outcomes - Curriculum and .... http://www.oecd.org/education/imhe/43977531.pdf

Online Teaching Resources: Where in the WWW are They .... https://journals.physiology.org/doi/full/10.1152/physiol.00003.2007

What is a Big Idea? https://www.authenticeducation.org/ae_bigideas/article.lasso?artid=99

]]>
Six Tips to Improve Information Literacy https://www.teachingpython.fm/articles/information-literacy Sat, 12 Dec 2020 09:45:00 -0500 sean.tibor@gmail.com 5eb0867d-0d8b-4255-93b7-6e4267821844 Many computer science tutorials, online or in books, are heavy in text and new vocabulary. Even Python kids' books are heavy in new vocabulary, making the informational text challenging for many students to use. This article is a summary of a presentation I did at a conference. Practice Makes Perfect


After instruction and 'code alongs,' I always assign supporting articles and texts from online sources to enhance student knowledge. The texts are often online and consist of short tutorial articles, code explanations, or hardware projects. The intended reading assignments are assigned to help strengthen coding knowledge and build more skills. However, these activities were never without a "fight" and often did not produce the expected outcomes.

As I replicated lessons each quarter, I began noticing a pattern with students. Moreover, scorn began to develop for the ever so familiar and anticipated, "I am so confused!" statement after reading an excerpt or webpage tutorial.

Instead of supporting the learning and enhancing the lessons, the text assignments appeared to be hurting the learning and hindering progress. I began to think that students could not read! And was desperate to change strategies.

"Could not read" may be a slight exaggeration. Students were capable readers of fiction and had many opportunities to develop comprehension with DRA tests in the lower school. Also, students could read the assigned text and, for the most part, state what they read. However, after further investigation, I determined that students were reading but not comprehending or processing the assigned informational text. Their information literacy skills were not well developed for informational text and reading tutorials online.


"Literacy is the ability to read, write, speak and listen, and use numeracy and technology, at a level that enables people to express and understand ideas and opinions, to make decisions and solve problems, to achieve their goals, and to participate fully in their community and in wider society. Achieving literacy is a lifelong learning process." -Defining Literacy Literacy Advance

Many computer science tutorials, regardless if they are online or in books, are heavy in text and new vocabulary. Even Python kids' books are heavy in new vocabulary, making the informational text challenging for many students to use.

"To become proficient in critical thinking – at least in a literate society – students need to be able to handle text. The text may be long, complex or both. To make sense of it, students cannot skim, rush ahead or continually get distracted." -Naomi Baron

Information literacy skills, are the skills needed to identify, find, evaluate, and use information effectively. A deficiency in these skills makes it difficult for students to comprehend text if the student cannot understand a minimum of 80% of the words. (Check out this interesting website to understand what 80% comprehension feels like.)

Students often developed their coding knowledge during code alongs and by watching screencasts and video tutorials. However, their competence of both the subject's knowledge when they read about it and the skills to develop more knowledge from reading, was low. I decided to make a focused intent to improve their literacy skills.


Activites to Promote Information Literacy


Over the years, I modified the lessons. I started implementing activities and strategies to help students engage with informational text and build their literacy skills. Here are a few activities that can help increase students' skills when reading.

  • Have the students read, read, and read some more. By increasing access to informational text, students will become more comfortable and competent in deciphering unknown or new vocabulary as they read.

  • Take snippets or shorter paragraphs and photos from web pages and copy them into documents. Reduce the number of hyperlinks and instead list webpages in a resource section at the end of the document. This technique reduces distraction from the clickbait and focuses their attention on the text alone. Also, it allows you to use photos to support the new vocabulary. and organize the text that is not critical to the learning.


  • Have students practice with potential vocabulary words out of context. Have students explain the definitions to partners and give them opportunities to become familiar with vocabulary. Eric Matthes created Python Flash Cards, this type of rote learning helps familiarize students with new python terms, such that when they see the word in an informational text, their brain will identify it as a word they may know.

  • Give students more time with informational text. If the text's length takes approximately 5 minutes to read, double the time and make sure students read the text more than once.

  • Teach comprehension strategies explicitly while modeling how to read informational text. Show students techniques such as "skim, scan and deep reading" and identify new words in a sentence. Show students how to translate one sentence at a time and provide them with procedures for processing new vocabulary while reading.


  • Always assign informational text for authentic purposes. Ensure that the text they read is both practice for developing competence and text that develops knowledge for an activity that they need to complete.


  • Using a "Find, Read, Do Explain" technique allows students to engage with informational text, complete an activity, and lastly, explain the activity in their words. This technique helps students comprehend and commit new vocabulary to short-term memory.


These are just a few activities that can be used in the classroom to improve literacy skills with coders. Using techniques daily in class will help students develop their programming skills, provide students with lessons on developing their lifelong learning skills, and develop competency and knowledge in other subject areas.

"The more that you read, the more things you will know. The more that you learn, the more places you'll go.” ― Dr. Seuss, I Can Read With My Eyes Shut!

]]>
Developing Critical Thinking Skills with Coding https://www.teachingpython.fm/articles/teaching-criticalthinking Thu, 03 Dec 2020 15:00:00 -0500 sean.tibor@gmail.com f9765dd8-72dc-465c-ad4a-8e66f8fd80b5 Critical thinking is not “just thinking,” but it is a process of actively evaluating and applying the information to improve upon a process. Students develop many critical thinking skills when they learn to code. Why Build Critical Thinking Skills?

Critical thinking is a skill that is essential in schools. Combining other skills such as analyzing, evaluating valid and reliable information, and synthesizing it to obtain an educated answer makes critical thinking so fundamental for students to grasp early on in their education.

It is critical for successful learning and is a skill used for life. Developing these skills helps to create lifelong learners who are curious, independent, and have broad interests.

A good learner knows that only memorizing and regurgitating knowledge may help one develop book smarts; however, a person who can formulate a new answer after gathering multiple sources of information is critically smart. Learners who bury themselves in quality research, weed out opinions, cipher through documentation, and develop an answer grounded in truth is a person guided to find the most accurate solution to a problem.


What is Critical Thinking?

Critical thinking is best described as a habit of mind, a way of thinking. It is a process that requires the use of logic to solve a problem. It is the thinking of intellect and derives from a continuous need to improve upon the answer.

Defining the skills embedded within critical thinking is difficult without first identifying what it means to be a critical thinker.

A critical thinker knows how to ask the right questions. They apply the Right Question Technique or QFT by default, without knowing about QFT. This type of thinker knows that vital questions must be raised, addressed, and formulated clearly and precisely. As we know, “A problem well-stated is half-solved.”

Effective critical thinkers know that all aspects of a problem need to be explored and there are always hidden facts that may need to be hashed out. Being able to clearly identify the problem helps critical thinkers solve complex problems.

A critical thinker knows how to break large problems into smaller bite-size pieces. This type of thinker knows that complex problems happen in every facet of our lives. Therefore, this type of thinker has developed patience and grit that helps in becoming an effective problem-solver.


How can you Develop Critical Thinking through Coding?

As a learner, before you can explore the skills of critical thinking, the opportunity needs to exist. A learner needs to have the content and the desire to apply the skills.

"Critical thinking relies on content, because you can't navigate masses of information if you have nothing to navigate to." -- Kathy Hirsh-Pasek

Learning to code or program is an area where learning how to think critically is inevitable. Studies conducted at Carnegie Mellon show that programming is beneficial to cognitive development and that starting to code early is an excellent basis for children when learning how to learn.

Here are a few reasons why learning to code is beneficial to your brain.

  • A person who codes is a person who develops their critical thinking skills daily. For programmers, encountering a complex issue occurs every second and although every coding problem may be different, there is a system to solving problems.

  • One of the reasons coding develops critical thinking is that coding can be messy. When you code, you need to try many different solutions for your programming problem. Good coders can analyze which program works the best. You are guaranteed to make mistakes. Learning is not linear and coding is not a linear task either.

  • Coding teaches you to use critical thinking skills to debug coding errors. And failure IS an option in programming. With every coding error, you have the opportunity to fix the issue and build upon more skills.

  • A person who codes has to simplify complex problems. Every problem is made up of many smaller problems. Solving these small problems provides a workout for the brain. Programmers get continuous experience with critical thinking and breaking down problems, so much that professional programmers often can solve complex coding problems even when they are away from their computer.

  • A person who codes knows that asking the right questions can help to solve problems easier. Coding helps to build inquiry skills.

  • A coder develops the critical thinking skills that allow him/her to build a repertoire of information that can be transferred and reapplied in different concepts. Connections are made and problems become easier to decipher.


In this keynote presentation for Creacode's Home Alone Conference, Sean and Kelly summarize the importance of defining and developing critical thinking skills.

Critical thinking is not “just thinking,” but it is a process of actively evaluating and applying the information to improve upon a process. Students develop many critical thinking skills when they learn to code. This quote is a favorite of mine and sums up the need to think to learn to think critically.

"Critical thinking is thinking about your thinking while you’re thinking in order to make your thinking better." -- Richard W. Paul


1 Charles Kettering, the famed inventor and head of research for GM quoted, "“A problem well-stated is half-solved.”

]]>
Teaching Python in the News https://www.teachingpython.fm/articles/news Mon, 30 Nov 2020 12:00:00 -0500 sean.tibor@gmail.com 90e38130-0c2e-4fe6-8d04-b728abbb437d Here is a compilation of articles, presentations and blogs that Teaching Python has been featured on. In the News... with Teaching Python

Guest Podcast Appearances


Keynotes and Presentations



Interviews and Articles

]]>
A Bloom's Connection https://www.teachingpython.fm/articles/blooms-connection Mon, 16 Nov 2020 15:00:00 -0500 sean.tibor@gmail.com 676e672f-bb87-4050-b8e9-2d80e8b60f9c Over the years, Bloom's taxonomy has been revised, edited, turned into objectives, and redesigned to show suggestions from multi-layered activities, apps to use to meet Bloom’s taxonomy objectives, and some revisions show the goals as “grouped objectives.” Regardless of the modification, Bloom’s taxonomy is a useful tool to help both teachers and learners identify a learning trajectory that is efficient. What in Bloom's name?

If you are an educator and haven’t encountered Bloom’s taxonomy at least once, it is a rare occurrence. While studying for an Educational Undergraduate Degree, most teachers complete assignments on Bloom’s taxonomy. The projects and activities help undergrads quickly recognize, identify, and develop lessons from one of many pyramid-shaped charts’ with colorful levels. I remember writing multiple essays and ensuring that my educational pedagogy showed that Bloom’s was at the heart of my lessons.

For those of you not in education, Bloom's taxonomy was a framework developed by Benjamin Bloom and his collaborators. It is simplistic in design and identifies six major categories: knowledge, comprehension, application, analysis, synthesis, and evaluation. These categories have been modified over time, but the principle remains the same. Bloom’s taxonomy is one of the most widely used systems that presents learning in a clearly defined set of learning processes. It ‘helps guide’ teachers in developing higher-order thinking skills in the curriculum and the classroom.

Bloom's Taxonomy Pyramid

Bloom’s taxonomy was designed as such so that teachers could identify these objectives on the continuum and move lessons and assessments from a straightforward process to a very complex concrete or abstract one.

When I first learned about Bloom’s taxonomy, Bloom layered the categories in a pyramid shape with the categories listed above one another, designating a hierarchy in learning throughout the pyramid. Its design implied that a student must first have a strong foundation of knowledge to comprehend a topic and comprehend before synthesizing. While this is true in some situations, many institutions have realized that application and creating can be a part of the learning or the knowledge gathering phase. These learning steps are not as separated or hierarchical as once drawn.

Over the years, Bloom's taxonomy has been revised, edited, turned into objectives, and redesigned to show suggestions from multi-layered activities, apps to use to meet Bloom’s taxonomy objectives, and some revisions show the goals as “grouped objectives.” Regardless of the modification, Bloom’s taxonomy is a useful tool to help a teacher and learner identify a learning trajectory.

Making Connections

During a recent course on the “Science of Learning,” I encountered a cognitive science misconception known as the “GI Joe fallacy.” At the end of every cartoon episode of GI Joe, a child would always end the episode with “Now I know!” and GI Joe would say, “And knowing is half the battle!” This statement, by GI Joe, is the heart of the fallacy phenomenon. Cognitive scientists explain that although knowledge of topics is desired or recommended during the learning process, there is always a varying degree of rational thought, comprehension, and emotional knowledge that can affect decision making. Scientists propose that regardless of whether we know something, we can sometimes skew decision-making and analytical thought.

Upon further study by psychologists, sometimes what we think we know isn't always perceived or seen as accurate, and that “knowing is half the battle” does not necessarily mean that you understand or that you know the truth.

That got me thinking, how do Bloom’s taxonomy and the GI Joe Fallacy apply to my learning Python or how I teach Python. It boils down to “Knowing isn’t half the battle, nor is gathering knowledge an indicator that we understand.”

Newer Versions of Bloom's

Thinking about and using Bloom’s taxonomy in Computer science and coding is a helpful tool for both the teacher and the learner. I found this rearranged version of Bloom’s taxonomy that shows the top three levels as equally important.

I have been teaching Python for 2.5 years. I feel reasonably confident that I know the Basics of Python. I can evaluate student code for errors and efficiency. For example, I can teach functions, explain the concepts to my students, teach them how to code simple functions, put functions into more complex code, and explain to kids how to put functions into their code. I can even follow along with complex code. But one time, after coding and teaching functions for two years, I happened upon a simple but necessary explanation of functions, and something happened, a lightbulb came on, and an “OMG! Ah-ha!” followed!

This moment happened to me the other day! I was watching my colleague teach functions, the same thing I have taught before. It was a simple lower-level thinking lesson on Bloom's taxonomy scale, but it caused me to have this surprise “a-ha” moment. It was then when I realized a critical analysis of my learning path. I had cycled back into a knowledge/comprehension phase and made a significant connection to the current topic. What I knew before wasn’t half the battle of my real understanding of functions. I had missed something supercritical to understanding how to use functions.

I felt a “spark,” and I realized that I reached a point where a reliable neural connection had finally happened. I have been teaching the concept of functions for a few years, but what was it, and how did this linking of neurons finally solidify? How could a simple knowledge exercise spark my brain into a “synthesis “reaction? Was I suddenly able to understand and visualize a more involved piece of code and solve it?

Last summer, I took a course called “Learning How to Learn” with Barbara Oakley, and during this course, Barbara discusses these moments called “meta moments”. I have witnessed them with students many times and have become accustomed to designing situations for students. However, I do not recall remembering a moment like this happening to me in adulthood. I felt the neuron connecting two pieces and the knowledge solidifying. I identified that ‘click’ or ‘ah-ha’ moment and have been trying to explain the incident to other adult learners, so that we can replicate it.

Bloom's taxonomy started as a pyramid and has had so many mutations over the centuries. Teachers have listed out verbs, apps, and diagrams side-by-side in a circle; however, many educational theorists believe that the concept is durable and timeless regardless of the modification.

However, I agree with the University of Michigan, that Bloom's taxonomy is like the design cycle where ideation, research, prototyping, creation, and evaluation, cycle back and forth. This version of Bloom’s taxonomy shows the thought process that is needed when teaching and learning Computer Science.

Knowledge is gained at different entry levels depending on the concept, the skill, the topic, or the learner. And the depth of the knowledge does not need to be vast, nor does it need to be all-inclusive before creating, evaluating, and analyzing. However, it does need to cycle through in a quick Scrum or Agile learning approach.

Using this version, let’s investigate my “ah-ha” moment. I can recall facts and basic concepts. I can define, call functions, and add parameters and arguments to create useful functions in code. I can evaluate student code and analyze other codes to identify errors. I remember, understand, apply, create, evaluate, and analyze. I have completed my level of higher-order thinking skills. However, I gained more knowledge during this process and cycled back to the remembering and understanding stage. By completing these “higher-order thinking skills,” I was better able to understand functions deeper. But it is only after these stages where I can go back to understanding and remembering the concept better. I have evaluated and analyzed so that I can finally understand.

It is by following this pattern that my skills are growing. And it is this pattern that simulates in my teaching. When we teach a new subject, it is not essential to divulge every concept or insist on every idea is understood. It is only necessary to ensure that the learner is consistently cycling with information that he/she manipulates, transforms, and ingrains it on neural connections.

When a learner can now make explicit pictures in their mind, or design a metaphor, they develop an understanding that cannot be replicated by merely reading or copying code. For example, I like to think of functions like getting a phone number from someone. A phone number is a way to repeatedly getting in touch with someone; however, if you do not use the phone number or “call” the number, you cannot talk to that person. Functions are transactional.

Indeed, one can put together a more involved piece of code by copying it from a book. We can learn everything about the code and state what each line does, and build up a repository of information. But computer programming is more analytical than memorizing. SO start small, learn bites, not chunks, and truly understand it from a simple knowledge base.

Grow upward through the pyramid and get to know a topic. Do not be afraid to learn in small chunks. Do not challenge yourself to know everything at once but challenge yourself to play and apply those higher-level thinking skills to smaller bites of information.

"The eye sees only what the mind is prepared to comprehend."

- HENRI BERGSON, French Philosopher and Educator

]]>
The Metacognitive Process part 3 of 3 https://www.teachingpython.fm/articles/metacognition-kwl-part3 Mon, 09 Nov 2020 10:00:00 -0500 sean.tibor@gmail.com d893f15a-452d-4ef1-8d0a-3c1f7012bd8c Excerpt from Part 2, the Metacognitive Process

As you start to understand Python’s core concepts and syntax, your learning shifts more from content knowledge into more procedural knowledge. This transference happens when vocabulary, definitions, facts, and the interrelationships between them, start to connect, and conceptual understanding starts to develop. Your “What do I want to learn?” goal should begin to shift, and you should consider moving into the next phase of the metacognitive process before cycling through the process again. It is at this point where you should pause to reflect on the learning journey. Reflection!

A teacher knows that learning is a path full of collecting knowledge, transforming it with skills, and learning to apply both to solve a problem. As an independent learner, you need to be your guru of reflection. In Part 3 of the Metacognitive process, we will look at identifying what you learned. But before we do, list out what you want to learn, and then conquer your learning!

‘By three methods we may learn wisdom: First, by reflection, which is noblest; Second, by imitation, which is easiest; and third by experience, which is the bitterest.’ –Confucius

The KWL chart: It is just a Cycle

As you continue down your learning path, reflection becomes one of the critical areas for growth. Some educators have suggested modifying the KWL chart, presenting that more letters like H for “how”, A for “Actions,” and Q for “Questions” be added. This idea makes sense if a student needs reminding to complete these fundamental tasks. However, the process already happens in the column, “What did I learn” and this column is an integral part of reflection.

Look at the KWL cycle below, it is not a linear process when you are learning how to code. A good programmer knows that you need to be a life-long learner when coding.
KWL Cycle

As you recall, metacognition is thinking about your thinking. Regulating your thinking is a constant process. You need to keep in mind the tasks you need to achieve, your abilities, and how long it takes you to commit concepts into long-term memory. What are the strategies that worked for you as you were looking at what you wanted to learn?

You may think that you have gone through many resources and still the concepts aren’t sticking. Or you have some specific concepts where your comprehension is reliable, but other concepts take constant reading, researching and revision. Regardless, you need to ask the question why? Just reading over and taking information or memorizing isolated facts may make you a great communicator, but what about programming? Imposter syndrome may kick in when faced with a project where you need to code on your own.

What did you learn?

When you enter into a reflection phase for the first time, check the items you marked in the “Know” section. Can you make any other connections to what you knew and what you learned? Can you connect two concepts’ synapses in your brain to make a new permanent connection? Does a mental picture surface? Or is it oppoosite? Do previous codes or concepts manage to stay out of your reach in long term memory. What did you differently to make the connections? Go back, relearn and think about why it is not 'sticking".

“The brain’s capacity and desire to make or elicit patterns of meaning is one of the keys of brain-based learning. We never really understand something until we can create a model or metaphor derived from our unique personal world. Learning and memory are influenced by the sets, intentions and plans generated in the neocortex of the brain as well as by the information received from the immediate environment and from internal states, drives, and muscular responses. The reality we perceive, feel, see and hear is influenced by the constructive processes of the brain as well as by the cues that impinge upon it.”

– Merlin C. Wittrock

When I was learning functions, I understood the concept and I could easily define and call the function. However, as time progressed, I realized that I did not truly comprehend the concept entirely. After reflection, I looked at my examples. Most of the functions I wrote were futile, useless pieces of code that I wrote just to practice. The concepts and importance of functions was truly missed. I failed when I needed to rewrite some functions and reuse them in my code.

When you program, try to use the concepts in a way that matters or makes sense in the code. If a piece of code has a specific purpose, use it. For example, do not just use regex because it is an important concept to know. Could you write a lambda function? Better yet, is this something that could be combined. Is there an easier, faster way? Understand when and where code works best, and use it accurately.

Reflect on what you wanted to learn

Check off the questions listed in the second column first. DId you answer all that was asked? How did you answer them? Are the questions basic knowledge questions or are they analytical or practical questions. WHich ones do you still need practice with?

At this point, you are entering back into the “What do you Know” and “WHat do you Want to Learn” phases of the cycle. Can you clearly identify the concept that you know well enough to teach without notes? Can you code with confidence? Are you writing code that makes sense? What do you need to know to code with confidence? How can you improve your current code and make it more efficient? What other projects can you do to improve your understanding of a topic.

Reflection helps you to identify what still needs to be learned. Everytime you reflect, you gain a better understanding of yourself and your abilities to tie two concepts together in your brain.

For a quick summary of the all the stages, consider these steps:

  • Plan
    • Make and set a goal
  • Gather resources
    • Organize the resources so that you can come back to them when necesary
  • Recall and organize concept on paper helps you to remember
    • Keep track of how you are doing- Write it down!
  • Constantly monitor your learning- Avoid Imposter Syndrome
    • Keep track of how you accommodate your understanding
    • Did you need help?
    • Test yourself
  • Identify new knowledge and build knowledge from what you already know.
    • Don't be afraid to go back in the KWL cycle
  • Take action
    • Teach someone
    • Write some code
    • Blog about your experience
]]>
The Metacognitive Process part 2 of 3 https://www.teachingpython.fm/articles/metacognition-kwl-part2 Thu, 22 Oct 2020 15:00:00 -0400 sean.tibor@gmail.com aaf8a312-f082-40c4-a43a-7740cf44fadb Using the same skills that an adept teacher applies in the classroom, such as metacognition, can help one become a better learner. Metacognition helps guide you to change basic facts and vocabulary understanding into a deeper conceptual understanding of any topic. Excerpt from Part 1, the Metacognitive Process

While promoting a more in-depth understanding, a teacher will encourage students to use many skills. Students reflect on what helps build content knowledge, and teachers direct students to employ methods independently and build on what they already know.

Using the same skills that an adept teacher applies in the classroom, such as metacognition, can help one become a better learner. Metacognition helps guide you to change basic facts and vocabulary understanding into a deeper conceptual understanding of any topic.

In Part one of this three part series, we identified the need to list what concepts we may already know or what connections you can make to a new study topic. This
video by Django Girls does a great job of showing how to connect everyday understandings to new learning topics. Moreover, it helps solidify the importance of being able to explain complex topics with everyday concepts. Explaining the Command line with metaphors that connect to topics we already understand is a product of truly understanding a topic.

How can more metacognitive strategies improve the transfer of declarative knowledge into conceptual knowledge and make things stick!

Part Two: Getting “meta” with your learning: What do you want to Learn?

During the learning process, it is critical to identify the information you wish to learn. In a classroom/mentor situation, the teacher helps the student identify the gaps in what is known and what needs to be learned. A student who is aware of what they know or doesn’t know can better break down their learning process independently.

Like a student who is aware of their learning gaps, an independent learner, using the skimmed information in the “What I want to know” stage,
K-W-L chart, can apply critical learning strategies to identify the next moves.

Let us explore how:

I was in a unique situation where I was learning a topic simultaneously as I was teaching it. I was a “learner, doer, and teacher.” In learning how to teach python, I had to learn how to code it.

I was in a unique situation where I was learning a topic simultaneously as I was teaching it. I was a “learner, doer, and teacher.” In learning how to teach python, I had to learn how to code it.

I identified a learning path quickly, not only because of the tools I had as a teacher but also because of a specific need. I had to teach it.

However, that did not mean I was initially very successful.

My learning and teaching adapted as I learned more complex topics in Python. At the beginning of the learning process, most of the learning was declarative. “This is an integer, string, and float. These are functions. Here is an IDE.” Declarative

Being able to identify, define, and explain important concepts is crucial. Although declaring gained knowledge is a good start, making connections and explaining the concepts is a little trickier. Even more importantly, What about writing code? Furthermore, this is typically the asserted learning goal. “I want to learn how to code.”

Let us look at why this statement is too broad to be metacognitive.

What is it that you want to learn?

Identifying the ‘what I want to learn’ portion can sometimes be difficult when you are on your own. Most books on the market contain the same basics of coding Python. Learn the basics here. Learn to code in 30 days. The vocabulary is the same, the concepts roughly in the same order. The basics of python become the basics of turtle, and voila! You are a coder. Well, not really.

Getting Meta about learning can help, but it takes time, practice, effort, and awareness of the need. Without a teacher or mentor around to guide you, you are the person responsible for asking the questions to yourself? Learning is a process. It is not a static or closed-ended goal. Metacognition reminds us to be fluid, and that we must be in a constant state of progression in our learning.

It is time for another list. In this critical stage of learning, you not only identifying the path of learning, but you also set a goal. The goal must always adapt and progress. As an independent learner, it is up to you to keep tabs on the learning path and identify the gaps between what you thought you knew and what you need to learn. You need to advance at a rate that keeps you at a comfortable level of struggle. You are responsible for monitoring your comprehension, and you must remember to self-evaluate regularly.

“Learning is a process. It is not a static or closed ended goal. Metacognition reminds us to be fluid, and that we must be in a constant state of progression in our learning."

Do not waste your time writing out concepts and vocab words in this stage. Make learning goals. For example, as I started, my first goal was small, code Rock, Paper, Scissors without a tutorial, and explaining every line in the program. I needed to know this program forwards and backwards because I needed to debug my students’ errors without research or time wasted in class. At the time, I had only been learning Python for three months. Coding Rock, Paper, Scissors was an enormous feat.

When you are learning in a silo, learning to debug on a grand scale does not happen. I needed to invent ways to be prepared for my students. Practicing writing the code without a book or trying to solve code challenges can be an alternative. Look at issues on Stack Overflow and see if you can help replicate some fundamental questions asked. Alternatively, look at the Stack Overflow questions and code the solutions. Choose or identify the concepts suggested that make the most sense to you.

As I worked towards achieving my goal, I watched tutorials on how to code other activities; however I did not watch videos on RPS. I learned how to “Flip a Coin”, coded Michael Kennedy’s Birthday App, and practiced writing basic concepts such as for loops and conditionals over and over.

“One learns from books and example only that certain things can be done. Actual learning requires that you do those things.”

– Frank Herbert

Frank Herbert took six years to research and write his novel Dune. An equally long process is learning to code. Coding requires one to put in the effort, do the code and research the concepts.

Taking notes or writing things down is another way to “do” things during learning. Use inline comments, multiline comments, or a Colab document as places to write notes about code. I define every major code snippet to ensure that I can recall the concepts I have learned. You do not need to use these “notes” to study from; in fact, you will outgrow them quickly. However, writing down things helps your brain to make more connections to previous concepts and code.

To keep tabs on your learning, learn to ask yourself questions, draw flowcharts or write code snippets by hand, find a person to practice reciprocal teaching to, or if it is just you, write blog posts explaining your code. Learning requires cognitive and social activities that can help your brain move from procedural knowledge into conceptual knowledge. Find ways to discuss, do, and interact.

As you start to understand Python’s core concepts and syntax, your learning shifts more into procedural knowledge. This is when vocabulary, definitions, facts and the interrelationships between them, start to connect and conceptual knowledge starts to develop. Your “What do I want to learn?” goal should begin to shift and you should consider shifting into the next phase of the metacognitive process prior to cycling through the process again. This is the point where you should pause to reflect on the learning journey. Reflection!

A teacher knows that learning is a path full of collecting knowledge, transforming it with skills, and learning to apply both to solve a problem. As an independent learner, you need to be your guru of reflection. In Part 3 of the Metacognitive process, we will look at identifying what you learned. However, before we do, list out what you want to learn and then go conquer your learning!

‘By three methods we may learn wisdom: First, by reflection, which is noblest; Second, by imitation, which is easiest; and third by experience, which is the bitterest.’

–Confucius

]]>
Hacking the Classroom Hand Sanitizer Dispenser Part 1 https://www.teachingpython.fm/articles/hacking-the-hand-sanitizer-dispenser-part1 Sat, 17 Oct 2020 09:00:00 -0400 sean.tibor@gmail.com f3ef603d-d9ac-4a99-8447-0f515ad1f80c Sean hacks our classroom's hand sanitizer dispenser to encourage students to practice better hand hygiene. This project uses Home Assistant, the Amazon Echo, and an ESP8266 running ESPHome to make it much more fun to sanitize your hands. Parts
  1. Hacking the Dispenser
  2. Configuring Home Assistant for Automation
  3. How do we know it's working?

Note: this turned into a very long and detailed explanation of my project, so I've broken it up into three parts. This part focuses on the actual hacking of the hand sanitizer dispenser. Part 2 will show how to use Home Assistant to automate actions in the classroom. Finally in Part 3, we'll try to understand if it's actually working to change student behavior.

Carrots vs. Sticks

Last year before COVID-19, my classroom's hand sanitizer dispenser sat with dead batteries for months. I'm not even sure if it would have worked if we had new batteries. For obvious reasons, this year my classroom came equipped with a shiny new hand sanitizer dispenser, with the goal of getting every student to sanitize or wash their hands at least once every two hours.

Hand Sanitizer Dispenser

Over the first few weeks of school, I noticed that very few students sanitized their hands unless I told them to. As the CDC has noted, frequent hand washing and hand sanitizing is one of the best ways to prevent the spread of COVID-19.

My marketing/technology brain spun to life as I pondered this problem. How can I get my students to want to sanitize their hands? If I have to remind them, then it all depends on my reminders. This has a lot of drawbacks, like I often forget to remind them with everything else I'm doing, they might try to avoid it, and we have no data-driven way of knowing if my reminders are effective.

Just like that shaving soliloquy in The Hunt for Red October, I asked myself "How do you get middle school students to WANT to sanitize their hands?"

The answer I came up with was twofold: first, make it fun. Then, make it easy for students to see themselves in the data.

Home Assistant to the Rescue!

My idea was to make it so that when the dispenser activates, some lights in the room would flash colors, Alexa would say something funny, and students would be able to see how many times the sanitizer was used that day.

The trick was figuring out a way to automate all of this in an easy way. While I could roll my own solution using pure Python, there was a platform already designed for this. I had even already trained myself on how to use it.

My quarantine project during COVID was to automate more of my home using the Python-based Home Assistant project (formerly known as HASS) and I realized it would work very well to bring all of these parts together in a relatively easy way for the classroom.

I dug through the storage bins in my room and found a Raspberry Pi 4, some Yeelights and even an ESP8266 NodeMCU board that I could wire up to the dispenser. To make it easy to swap out boards, I added a 3-pin JST PH connector to the system to make it easy to plug in the NodeMCU.

Parts List

Wiring up the Dispenser

The dispenser was the most hands-on hack and the biggest question mark for me. How would I know if the dispenser was activated? It turns out that the dispenser works with an IR sensor that detects when a hand is under it, just like a touchless water faucet.

When the dispenser activates, it runs a motorized mechanism that dispensed a certain amount of alcohol-based hand sanitizer gel. Importantly for our project, it also briefly turns on a UV LED that shines on the person's hands. Using a multimeter, I was able to trace the leg of the dispenser's microcontroller chip that turns on the LED. Then, I made up a three-wire JST-PH wiring harness that connected to that leg and the dispenser's power supply.

Terrible Wiring Diagram

Dispenser Control Board

I had to solder a wire directly on the leg of the microcontroller to get the LED signal. Be very careful with this connection and take your time. I tinned the wire with a bit of solder to make sure I didn't add too much.

For the power connection, the dispenser uses a standard 2-wire JST connector. I made a Y-connector out of a male and female 2-wire connector that also connects to the positive and negative wires on a 3 wire connector. This allows me to plug the battery connector into the female and the male end into the dispenser board without changing any other connections. The three wire end is routed through a hole drilled in the side of the electronics enclosure, then plugged into a three wire connector soldered directly into the NodeMCU.

The ESP8266 communicates over WiFi, which tends to be power hungry. For now, I've plugged the dispenser into mains power so I don't have to worry about draining the battery prematurely.

Setting up Home Assistant

Now that I had my dispenser hacked together, I needed to set up the Home Assistant server on the Raspberry Pi. For this, I mostly followed the standard setup instructions. In addition to the standard setup, I added the ESPHome addon to make it easy to setup and control the NodeMCU.

Pros for using Home Assistant in the Classroom

  • Cheap (Runs on a Raspberry Pi)
  • Open Source (and frequently updated!)
  • Wide array of relevant integrations:
    • ESP8266/ESPHome for hacking the dispenser
    • Yeelight lightbulb for signaling the dispense
    • Amazon Echo for making announcements

Setting up ESPHome

ESPHome makes it easy to connect microcontrollers to a Home Assistant server. It's really full-featured, even including the ability to send firmware updates over WiFi to your boards. I configured the ESP8266 to act as a binary sensor, meaning that when the light was on, it would send an ON message to the HA server.

esphome:
  name: tibor_sanitizer
  platform: ESP8266
  board: nodemcuv2

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Tibor-Sanitizer Fallback Hotspot"
    password: "MeUPw7DTWxFi"

captive_portal:

# Enable logging
logger:

# Enable Home Assistant API
api:
  password: !secret api_password

binary_sensor:
  - platform: gpio
    pin:
      number: D2
      mode: INPUT_PULLUP
    name: "Sanitizer Dispense"
    device_class: moving
ota:
  safe_mode: true
  password: !secret ota_password

The key entry here in the config file is the binary_sensor gpio entry that tells the ESP8266 to monitor the D2 pin for the sanitizer's UV LED signal. When that light turns on, it will send a message to the Home Assistant server that the sanitizer is ON.

Testing Communications

Now that we have Home Assistant and ESPHome setup, we can test to make sure that the sanitizer is still working and that it's communicating with Home Assistant.

First, you'll have to add the dispenser as a new integration. If you don't already see the dispenser pop up as a new sensor on the network, you can go to Configuration->Integrations and press the Plus button in the lower right side of the screen to add the sensor.

Follow the prompts and name the device in the dialog box. When you're finished, you should have a new Home Assistant entity for the dispenser that you can monitor for state changes.

Sanitizer Entity in Home Assistant

When the sanitizer activates, you should see the state of the entity change from off to on, then back to off when the LED shuts off.

Summary

Whew - that was a lot of hacking, soldering, and nerve-wracking disassembly of the dispenser, but it should be communicating with your Rasberry Pi. When this part is finished, you should have a dispenser that functions just as before, but now sends a message to your local Home Assistant server when the dispenser is activated.

In Part 2, we'll use Home Assistant to automate lights and make Alexa say funny things to the students. Our goal will be to make it so that students can't wait to hear what she'll say next.

Finally, in Part 3, we'll look at the data collection side of this and hypothesize ways to further increase student usage. We'll also look at ways to use the data to prove that it's increasing student usage of the dispenser.

]]>
The Metacognitive Process: Part 1 of 3 https://www.teachingpython.fm/articles/metacognition-kwl-part1 Fri, 16 Oct 2020 09:00:00 -0400 sean.tibor@gmail.com 3079728b-da97-407e-ac63-1b2b2979dab0 Doing what you know, knowing what you learned, understanding what you want to learn more of… The Metacognitive Process of Learning. This is the intro to a three-part blog. “Learning is finding out what you already know. Doing is demonstrating that you know it. Teaching is reminding others that they know just as well as you. You are all learners, doers, teachers.” ― Richard Bach, Excerpt from Intro: The importance of learning like you are a teacher

Having different tricks up your sleeves, like an experienced teacher, can help you when you start to learn how to code. These tricks allow you to develop the metacognitive skills of learning how to learn. And knowing these strategies will help you analyze your learning material, reflect on what you are learning, and direct your path for learning.

In this three-part blog series, we will investigate three phases in a learning process, develop your metacognitive studying techniques, and focus our attention on improving your learning strategies. Whether it is your first day of coding or learning another skill for your career, using these processes can help you assess your learning journey and improve your coding knowledge.

Part One: What do you know?

When you first start to learn how to code, or if you want to learn a new concept in Python, your first thought is to turn to the Internet. Also, every experienced programmer recommends reading books, listening to podcasts, watching videos, or starting a course. Sometimes, if you are lucky to have one, you turn to a mentor. Regardless of the resource, usually, your main objective is to get a baseline understanding of new concepts, familiarize yourself with code snippets, and acknowledge any new vocabulary. You probably think that this step should be your first dive into the learning process.

However, you probably did not realize that the moment right before you opened the internet was a powerful opportunity for your learning process to be improved. So how do you engage this?

Let us look at it through a student-teacher scenario.

The process is dependent on what type of teacher you prefer to have instructing you. How a teacher chooses first to introduce a new topic of study to students depends on the teacher’s style or pedagogy. The deliverer of content, the “Sage on the Stage” person, is one type of teacher. This type will deliver the information required during your learning path. The Sage will tell stories that help you connect alternative concepts to the new topics being presented. Your role as a learner is to listen and visualize these connections. You are only a consumer of someone else’s knowledge. When learning independently, the experienced author, video, or tutorial has replaced the ‘sage’. Unfortunately, it is difficult to find quality resources that present concepts and the connections that your brain needs. However, a good “Sage on Stage” teacher knows that it is impossible for learning to happen without connection. Students need to experience connections to concepts to provide both a context and relevance, of meaningful and authentic learning.

However, as great teachers know, although sometimes entertaining, ‘Sages on stages’ do not always make the best educators!

Donna Ogle developed the KWL Chart in 1986, and the tool intended to help students activate their background knowledge before reading a nonfiction text. But over the years, this “tool” has been modified and used to help learners trigger and activate an understanding of different subjects and concepts. It is a great activity that every seasoned teacher should know, and every learner should try to apply. It is rooted deeply in the process of metacognition and focuses on being reflective and mindful of your learning process.

The KWL chart is divided into three parts but serves four functions.

  • Assisting learners in activating prior knowledge,
  • Setting an intention for the learning,
  • Linking new information to previous knowledge, and
  • Helping the learner to keep track of the learning process.

Let’s dive into using the KWL chart and how I have used it to learn Python.

There are many versions of the KWL Chart; the basis and the strength of it lie with three essential questions:

  • What do you Know?
  • What do you Want to know?
  • What did you Learn?

Identifying “What do you Know”: How do we apply the first part of the KWL method; what do you know?

If you are new to coding, you may not think you know much; however, this task may surprise you. If you have coded before or are working on solving a unique problem or task, you may have a more robust understanding of your current knowledge. In either case, list out what you know is true. Wrestle with the things that you do not understand. Try to tease out where you should start. You can use bullet points, sketches, lists of words; just get it all out of your head. List out books you have heard of, authors, courses that your friends have suggested. The list should be extensive.

Having an awareness of what we know helps our brains to assign meaning and find substance. We need to be aware of things in order to recall or comprehend it. The stimulation of asking questions, and engaging in a brainstorming activity requires your brain to start to categorize and chunk the information you already know to be true.

In the brainstorming process, I do recommend you skim a few books. The books serve two purposes. First, they help you identify that most coding books are very similar in the topics and context; however, some may approach it very differently. And secondly, they may not fit your learning preference. For example, I once read a book called “Explain the Cloud to me Like a 10-year-old”. This book was easy to read and helped me get a general understanding of what the cloud is and does. However, when it came to python coding, I liked reading Finxter Coffee Breaks and Python for Kids as my first book. Two completely different styles of writing, but both served the purpose. I didn't know how to code, and interestingly enough, I didn't code along with any of these books, but I liked the explanations, the code snippets, and from reading over the code, I was beginning to gain basic knowledge of what I already knew about Python.

As you build your list, focus on what you already know first. Do you already know a language? Do you know about the importance of syntax in languages? Are you familiar with the concepts of conditionals in math? Are you good at breaking down large tasks? Can you understand how a program flows? As you begin to read through your first book, identify the connections you can make to things you already know. Making connections between new concepts and concepts with similar attributes will help your brain make more connections. Furthermore, these joyous moments will help you when confidence is low or if you need to create relationships with other topics later on.

There are very few teaching tools that are as effective as they are easy to use. And what is even better, they are super to use when you are teaching yourself to code! The initial discovery of vocabulary helps the learner identify what is already known or what connections are made.

"To be a successful problem solver, focus first. We get stuck in problem solving when we don’t first prepare our brain by focusing on the basics. Don’t just dive into problem solving without studying the explanations first. You need to lay some basic trails on the focused pinball table.”

Barbara Oakley

As you are skim reading, you may realize that a book, is just ‘not for you.’ You may decide to switch up, do it. Do not let a book that you can’t connect to, stop you from learning how to code. More importantly, the more books you can quickly skim can help you gather different perspectives on learning how to code.

So go for it, list out what you already know!

]]>
The Metacognitive Process of Learning: An Intro to a Three Part Series https://www.teachingpython.fm/articles/metacognition-kwl-intro Tue, 13 Oct 2020 09:00:00 -0400 sean.tibor@gmail.com 3c294b7e-cf95-4e78-8daf-f597384f8815 Doing what you know, knowing what you learned, understanding what you want to learn more of… The Metacognitive Process of Learning. This is the intro to a three-part blog. “Learning is finding out what you already know. Doing is demonstrating that you know it. Teaching is reminding others that they know just as well as you. You are all learners, doers, teachers.” ― Richard Bach,

“Learning is finding out what you already know. Doing is demonstrating that you know it. Teaching is reminding others that they know just as well as you. You are all learners, doers, teachers.”

― Richard Bach

Introduction

One of the things that I realized as I was beginning to learn Python is that my strength as a teacher would come in very handy. A teacher’s “tool belt” is earned through years of grit, dedication, and intention. Teachers often don’t realize all the tools they have accumulated until there is a need. But we call upon these skills, not only for our students but also for self-guided/independent learning. My tools helped me identify and guide my Python learning journey. And being able to locate quality resources would prove to be critical to part of my success with coding.

In this three-part blog series, we will investigate three phases in a learning process, develop your metacognitive studying techniques, and focus our attention on improving your learning strategies. Whether it is your first day of coding or learning another skill for your career, using these processes can help you assess your learning journey and improve your coding knowledge.

Before We Begin: The Importance of Resources

Using different resources help you to decipher complex topics and then construct a new picture in mind. Teachers know that finding resources is only half of the battle. An adept learner has to sift through the resources that work best and process the concepts consumed during the learning. And this is just one of the skills that most teachers have in their tool belts.

Teachers know that deep learning begins with establishing a baseline of knowledge and carefully scaffolding new concepts to build brain connections. While teaching for deeper understanding, a teacher will encourage students through many skills. Students need to be reflective of what guides them during the process of building content knowledge. Teachers are always directing students to employ these methods independently and build on what they already know.

"An adept learner has to sift through the resources that work best and process the concepts consumed during the learning."

The Importance of Mindset

Adopting a positive mindset is continuously encouraged. Teachers recognize that learning is a journey of twists and turns, interlaced with mistakes and opportunities to fail forward. Therefore, it is best to guide students to embrace a positive mindset early on in the learning path. Once the growth mindset is accepted, a student will be more prepared to identify “fails” and use techniques to learn and fail forward faster.

A teacher knows that learning is a lot of finding out what you already know, understanding how to take in new concepts, discovering how a learner learns, and realizing the best learning method for students.

These tactics are tried and true methods that many teachers have researched, developed, and perfected to help keep their students along the positive learning path, despite their occasional twists in the wrong direction. These teaching techniques allow learners to continue to develop lifelong learning skills necessary for self-teaching and daily problem-solving!

The Importance of Learning Like You are a Teacher

Like an experienced teacher, having different tricks up your sleeves can help you when you start to learn how to code. These tricks allow you to develop the metacognitive skills of learning how to learn. And knowing these strategies will help you analyze your learning material, reflect on what you are learning, and direct your path for learning.

Now, Let's Begin with Part 1

When you're ready, let's get started with Part 1 of The Metacognitive Process: What Do You Know?

]]>
You might be teaching a 6th grader... https://www.teachingpython.fm/articles/teaching-6thgraders Fri, 11 Sep 2020 10:00:00 -0400 sean.tibor@gmail.com 93cc727a-0a86-43b4-ae19-cce3a32a1a68 I have been teaching 6th graders for a while now, but last year I started teaching 6th graders how to code. And what an experience!

Most of our students come from 5th grade where they use Chromebooks and in the Middle School students the students switch to using Macbooks for class. This is a big step for our 6th graders and for many, this is their first computer.

After teaching eight classes in a single year, there are a few easily identified and almost impossible to omit concepts that always make my coding instruction a little more challenging but funny!

I decided to write a list in a Jeff Foxworthy fashion, titled, “You might be teaching a 6th grader how to code, if…” Enjoy!

“You might be teaching a 6th grader how to code, if…...your students ask, “Excuse me, what's an application and how do you install it?”

Every quarter I help students install an editor from the internet and it is an hour long process! Explaining that an application is an app is a whole other conversation in itself. Privacy and Security settings, moving the application into the application folder, and many more topics happen after this question. I could avoid this lesson and download the apps for them, but the learning from this skill is a very important skill that students need to have to navigate their new computers.

“You might be teaching a 6th grader how to code, if...your students have twelve versions of the Mu editor installed in their downloads.

After installing the python editor, students either see the file in downloads or are still click on the .dmg file on their desktop to launch the 'already' installed program, thus installing multiple versions every class! There always seems to be a rogue dmg file that they have downloaded and I missed, but they always find it and launch another copy of Mu!

“You might be teaching a 6th grader how to code, if…your students are always claiming that “it's broken! ”

This is a complex situation from the start, but after a little deliberation, we identify the real problem. The "editor is broken and it won’t save files." After downloading, students either forget to install the application by moving into the Applications folder or forget to delete the extra files of the newly installed program hanging out in various locations on their computer and, thus the program is not happy. CMD + Delete is my friend and I try to teach them that it can be there friend too!

“You might be teaching a 6th grader how to code, if…your response to the question, “my file is gone” is a slightly sarcastic question “Did you save it?”

Students coming from a Chromebook experience are in the habit of using the awesome Google Drive features. The ‘automatic save’ even when it is an ‘Untitled document ’ can be a hard habit to break. I am always reminding students that they need to save their files, and more importantly name the file!

“You might be teaching a 6th grader how to code, if…...a normal response from you, the teacher is a very mom-like, “I don’t know where your file is, it is not my computer! Where did you last see it?" (Insert the 'I don't know where your shoes are look.')

As avid Google Drive user, 6th graders use of folders and storage is limited to making new folders in their Drive. The concept of moving the documents to a Drive folder is sporadic to say the least. Therefore, saving files on a device is often a new experience for our kiddos. I need to show students that files are stored in directories on their computer and there is a pathway to their files. Knowing where you save files is a must when working with editors and python files.

“You might be teaching a 6th grader how to code, if…"yes, it is okay to exit out of Mu" is a mantra that you say at the end of every class."

In this century, the idea of always on or plugged in is the norm. Teaching your students that it is okay to close down or shut down applications and their computer. And "yes, it is okay to close the application and "yes, your files will stay on your computer if you saved them correctly” are statements I hear in my sleep.

.“You might be teaching a 6th grader how to code, if…a common file name for your students is, thingy.py, supcode2.py, 1.py or ajefhkaehrihroe.py

Yes as a 6th grade teacher, actively checking in on how your students name their files is a thing. Not because teaching nomenclature is a highlight of 6th grade, but because it persists into adulthood. For my sanity, I attempt to help students name files appropriately, so that we can locate their file later.

“You might be teaching a 6th grader how to code, if…you wear a magician hat and wow your audience with super cool editor and computer shortcuts!

In the Mu editor, I love to use CMD+K or CMD+D or CMD+X and your students say, “Wow! How did you do that?” or “Oh my gosh, how did you type that so fast?” Teaching shortcuts whether coding or not can help your 6th graders learn to be more efficient. And sharing one or two shortcuts a week really can help the students learn, use and remember them.

“You might be teaching a 6th grader how to code, if…you have to say more than once in a 10 minute span of time, “When is the last time you shut down your computer?”

Yeah, what else can I say except yes, student’s never shut their computers down and yes they do not know how to shut down applications or force quit their computers when they write a very effective while loop. Other questions often asked are “Do you know how to use ‘Force Quit’” or “Are you connected to wifi?” Teaching simple troubleshooting techniques can save you a lot of time and headaches in the future.

“You might be teaching a 6th grader how to code, if…“how do I write a variable named guest_name and then ask the end user what their name is and then print it out”? is an actual Google search done by a 6th grader this year. (No lie!)

Google like a Pro was a super course I took many years ago and although I do not teach all the skills, I do teach some! Another mantra I use daily is, "Great coders no how to Google!" I model how to search for topics or words that 'we' do not know or understand and we discuss how to break down these topics into smaller, easier to search concepts and words.

In all seriousness, although 6th graders are needy, young and inexperienced computer users, teaching them to code is a very rewarding experience. Enjoy the laughs and make your own list of “You might be teaching a 6th grader how to code, if…”

]]>
Five Tips for Teaching Python When You Know Nothing About Python https://www.teachingpython.fm/articles/five-tips-for-teaching-python-when-you-know-nothing Sun, 10 Nov 2019 10:00:00 -0500 sean.tibor@gmail.com 453c2cfc-3174-4443-8551-f4400d112543 Although I didn't consider myself a "real coder" when I first started learning Python a year and a half ago, it's been an amazing learning journey to teach it to hundreds of students and talk about it with other teachers. Here are 5 tips for learning how to teach Python when you know nothing about it. When I started learning Python a year and a half ago, I did not consider myself a 'real' coder. Although I had taught Lego EV3 robotics, dabbled in HTML in college and grad school, fiddled around with MIT App Inventor and block-based coding, I was still pretty apprehensive about learning a brand new coding language and teaching it to students daily.

Fast forward to today: I have taught hundreds of students how to code in Python, launched a podcast about it, and even attended PyCon and made friends from around the world in the Python community. You can do it too!

If you are looking for a place to start and need a little help, here are my five top tips for teaching coding when you are a coding newbie.

#1. Order lots of books!

I'm not saying that all the books you order will help you learn Python, but as a teacher, having a lot of resources to fall back on can give you a little extra confidence. I recommend getting a full bookshelf of resources that are designed for all levels of Python. Make sure that you get some books that are designed for kids, such as Python for Kids by Jason R. Briggs, Python for Tweens and Teens by Aristides S. Bouras and a Python book for your personal interest. As a teacher, I suggest Automate the Boring Stuff with Python: Practical Programming for Total Beginners by Al Sweigart.

Knowing that the answers to your students' and your own questions lie somewhere within a book is very comforting for a teacher learning a new subject. When a student has a question and does not know the answer, you can help be a facilitator of knowledge and give the student a book. This tactic serves multiple purposes: you encourage the student to research and read about the subject, and it gives you a moment to regain some composure.

In reality, a teacher's role is not to provide answers and be the "sage on the stage," instead, we should be the guide that teaches students the important lifelong learning skills that engage and motivates them. Promoting research and information literacy skills to help learn will come naturally as you teach Python. It is a skill that you will want to instill early on in your course. Even advanced programmers often research answers on sites like Stack Overflow to seek out ways to solve coding problems. It is the nature of coding to research and learn new concepts. In addition to this skill, your students' questions and researching the answers together will push your understanding of the coding language further than if you were learning alone at home.

#2. If you're not on Twitter, get on Twitter!

The Python community is incredibly supportive and open. Even if you are not communicating with them directly, just being a passive voyeur on Twitter can help you learn a lot about the language and the lingo really quickly. There are a lot of teachers out there who teach Python to different age levels. Many people are also just learning Python to have fun and code. There are also many experts out there who know Python and are always willing to help you out. If you search "Python" on Twitter, you can find a few people to follow and start learning with the rest of us. I suggest following @mkennedy from Talk Python, @brianokken from the Test and Code and Python Bytes Podcast, and Julian and Bob from @pybites. These four people have been super supportive in our teaching python journey.

#3. Get a mentor

A coding mentor is a person that will be there to support you through this crazy time! This person does not need to know Python, but it does help a lot if they understand something about computer science or programming.

The most important thing is that you find somebody who believes in you and is willing to pep you up when you're feeling aggravated, listen to you when you're feeling lost or frustrated, and support and commend you on the progress that you have made along the way. Teaching is sometimes a lonely and stressful profession, and teaching a new subject is even harder, but it doesn't have to be! Good mentors know what it is like to be new at something, and they can provide guidance, motivation, and emotional support. Having a colleague, administrator, or someone at your school that is there to pick up your spirits on those difficult or challenging days will help give you the motivation to continue with your learning and teaching journey.

If you do not have someone at your school, I suggest looking outside of your division or find someone you can connect directly with online or in another school. Alternatively, go a step further and find someone on Twitter. My mentor, Sean Tibor (@smtibor), and I are always willing to meet new Pythonistas.

#4. Don't be afraid to learn from your students

More than likely, there will be one or two kids that are natural Python coders or students who have coded in another language. It is only natural, and we are teaching in_ their world_ now. This fact can be very intimidating, and it can be very tempting for you to try to prove that you are the smartest person in the room. Don't! It is okay to _NOT _have all the answers to every question. Empower yourself to let the learning be reciprocal between you and your students. Embrace it and let your students know that you are learning too!

Remember, you are not the sage on the stage anymore. You are modeling a life-long learning mindset. Remind your students about the importance of the learning path. A trait of a good teacher and a great Pythonista is knowing how to ask the right question to research. Also, their questions give you new topics that you may need to learn or investigate.

A good question is one where the student does not know the answer. A great question is where neither the student nor the teacher has the answer!

#5. Just Jump Right Into Learning

It does not really matter where or how you start learning; just do it. Use videos to explain topics that you don't feel comfortable explaining and short tutorials to practice code when you start to feel exhausted from learning. I suggest using a tutorial to help you start teaching your first days of class. It is a great safety crutch, and students often like watching videos. Nevertheless, remember, as your students are learning to code, so are you. Use your teaching to help reinforce your understanding.

I suggest YouTube videos from sentdex and short tutorials from Grok Learning. My students love both of these resources, and so do I. Learning alongside students has helped me to solidify the information and the foundational knowledge of Python. I often watched more and did more exercises than I assigned, but that is because I found them fun and engaging. Find activities that help you learn and that challenge you along your learning journey. Remember, it is okay not to have all the answers on your first day of class. However, it is never okay to stop learning new things!

Good Luck!

Learning how to code in Python has taught me a lot about who I am as a teacher and a lifelong learner. As teachers, we try to instill a passion for learning in our students but sometimes, after teaching for many years, we forget what it feels like to learn something new! Thus, I challenge you to learn something new. Learn how to teach Python!

Every day, I am still practicing and learning Python, and you can too. It's a good feeling to be reminded that you don't know all the answers, but you are confident that eventually, maybe with some struggle, you will find the answers and solve some great problems with Python. Don't be afraid to embrace the struggle, and Happy Coding!

]]>