PERFORMANCE TASKS

INTRODUCTION

     If  you've been able to look at much of the information on this site you'll see that integrating the CS standards in your classroom can result in a lot of interesting, student-produced artifacts/materials.  You might see interactive animations, multimedia presentations, data-driven research projects, as well as simulations and models. You probably are seeing a need for a way to format assignments centered around these skills - not just telling students to "write good programs" or "develop some interesting simulations."  And you are probably seeing a need for a way to assess these projects.  One approach for doing this would be through performance tasks.  These authentic assessments can be good ways to link content standards to the CS standards.  They allow for the development of these sometimes complex skills but within a framework that provides links to SOL's.  As you'll see from the resources listed below, they also allow for a great deal of creativity on the part of students.
     A good place to start in developing an understanding of performance tasks would be this series of blog articles by Jay McTighe: https://blog.performancetask.com/what-is-a-performance-task-part-1-9fa0d99ead3b  He lists the characterisitics of a performance task (He covers these in detail in the blog):
1. Performance tasks call for the application of knowledge and skills, not just recall or recognition.
2. Performance tasks are open-ended and typically do not yield a single, correct answer.
3. Performance tasks establish novel and authentic contexts for performance.
4. Performance tasks provide evidence of understanding via transfer.
5. Performance tasks are multi-faceted.
6. Performance tasks can integrate two or more subjects as well as 21st century skills.
7. Performances on open-ended tasks are evaluated with established criteria and rubrics.
     In the blog he discusses performance tasks in detail, providing examples and clear discussions of different aspects of the task - rubrics for example.  He also provides links to some detailed examples for different grade levels.  Here is the link for an upper elementary task involving designing a garden: https://app.definedstem.com/project/45183B20-A931-4C6F-A9DA-3BA27554B720
     Another interesting introduction to performance tasks can be found here:  https://tiie.w3.uvm.edu/blog/using-performance-tasks-as-a-way-to-measure-student-knowledge/#.XscdskRKiot
     Some of you might be familiar with the Design Brief format (http://childrensengineering.org/design-briefs/) that can be used to introduce design and engineering concepts to students.  This might be a good starting point for developing performance tasks.  There is a difference of course, Design Briefs usually focus on having students develop physical objects.  Working with the CS standards, most student products will be virtual/digital, but the emphasis on producing an object in response to an open-ended (no instructions, just criteria and materials) challenge is similar.
     It should be stressed that the rubric for a Design Brief task is very closely aligned to the Criteria you've developed for that Brief.  

Sample Performance Task - Mali

     There are many example Performance Tasks on the web, but for this section, I will walk through the design/development process.  I will use an established lesson as a start, then modify it to include CS skills.
     For this example I've chose 3rd grade History SOL 3.4 - The student will describe the oral tradition (storytelling), government (kings), and economic development (trade) of the early West African empire of Mali.  As a focus for the task I've chosen an activity from a lesson on Mali, from the VDOE site, Little by Little the Bird Builds Its Nest.   http://www.doe.virginia.gov/instruction/history/mali/instructional-resources/elem-lesson-plans/index.shtml#l1a6.
     The assignment is: "Have the students choose one of the sayings and figure out what lesson it is trying to teach.  Next have them create a fictional story based on the proverb."  The proverb I chose is "Don o don jiri be ji la, a te ke bama ye" (No matter how long a log sits in the water, it will never become an alligator should be a crocodile.)
     I think Scratch will be a good tool for this assignment.  There are many examples for using Scratch to tell a story and to include animation and dialogue (some of the examples from Google's CS First that I've discussed come to mind.)  If I look at McTighe's criteria for Performance Tasks, I think having students develop a Scratch program in response to the challenge is a good fit.   Part 3 of the blog article (https://blog.performancetask.com/how-can-educators-design-authentic-performance-tasks-part-3-5817561ae422) is particularly helpful in deciding if a particular assignment will make a meaningful performance task.
     So, at this point I have the content standard and the integrated CS standards 3.1 and 3.2.  For this activity, CS 3.2 seems very appropriate, The student will construct programs to accomplish tasks as a means of creative expression using a block or text based programming language.
     The next step will be to develop the challenge and a rubric.  I'll use a modified Design Brief as a format for the challenge.  That means I need Background, Challenge, Criteria, and Materials.

Background (from the same VDOE lesson):
In addition to the Griot, Grandmothers also play an important role in the oral tradition of Mali.  They share stories with their grandchildren each evening around the cooking fire when the meal is finished.  These stories are different from the type of story shared by the Griot at a village celebration.  The stories that the Grandmothers of Mali share are often fictional,  are usually about animals, and always contain a lesson.  Grandmothers use their stories as a way to help their grandchildren make good decisions as they grow up.

Challenge
Here are two proverbs that a Grandmother might share with here grandchildren:
  • Don o don jiri be ji la, a te ke bama ye. (No matter how long a log sits in the water, it will never become a crocodile.)
  • Don o don na kele aminye. (The same sauce every day is not good.)
You must choose one of the sayings and figure out what lesson it is trying to teach.  You will use Scratch to write a program that tells a fictional story based on the proverb you choose.

Criteria
Your Scratch program must include:
  • At least three characters (sprites) one of which must be the Grandmother/narrator.
  • The narrator must introduce the story, guide the reader through the story and help them figure out the meaning of the proverb.
  • There must be additional dialogue between/among the other sprites.
  • There must be at least two different backdrops.
  • The backgrounds must fit the story and must be content appropriate.
  • There should be animation
(Something to consider here - your criteria are going to provide the basis for your rubric.  Think carefully about what you want students to do and be clear and concise.)

Materials
(The materials students will use for this assignment will all be digital, mostly images.  You might want to point them to certain websites where they will find appropriate images - or they can simply draw their own backgrounds and characters.)

     At this point you might have the students create a storyboard for their program.  They might do something like an opening screen with the narrator doing an introduction, then 3-4 scenes with a dialogue between the crocodile and the log, then a final screen with the narrator summing up the story.
     The code for telling a story can be pretty simple.  Take a look at this sample story-telling program from the Scratch website: https://scratch.mit.edu/projects/138705775/editor/  You can run the program, then click the See Inside button to see the code.  There are three sprites interacting in this program.  Let's look at some of the code.  This section is for the Gobo sprite who comes in later in the program.


     This sprites program begins with an Event.  In this case it's not the Green Flag that usually starts a program, but it's based on a Backdrop switch.  Here, it's when the backdrop switched from a previous backdrop to backdrop3 (you can see the command for that switch in Giga's program.)  so, when the switch to backdrop3 occurs, Gobo waits 7 seconds, then appears (the Show command), then waits 1 more second, then begins talking.  The rest of the program has Gobo talking with the other characters, there's a backdrop switch, Gobo goes away (the Hide command), waits 10 seconds, then comes back (Show), then says something, waits, and goes away.
     So for my program I will have 3 sprites - a grandmother, a crocodile, and a log.  I will have 3 or 4 backdrops - one for the grandmother and 3 for the crocodile/log dialogue.  The program will open with the grandmother talking to a group of children, introducing the proverb.  Then the backdrop will switch to a stream where the croc and the log are talking - I will have 3 different backdrops showing different parts of the stream - then the final screen will be the grandmother explaining the proverb.  The story line will have the log telling the crocodile that since it's been in the stream so long now it's just like a crocodile.  The croc will ask the log if it can: go underwater, sun on the beach, or catch a fish (three backdrops), the log will answer No for each question, then the backdrop will switch back to the grandmother who explains the proverb.

Sample Performance Task - Atoms

     For this task I've chose VA Science Standard 6.5, Atoms, and I will focus on: a) atoms consist of particles, including electrons, protons, and neutrons.  I will be integrating CS 6.1: The student will construct programs to accomplish a task as a means of creative expression or scientific exploration using a block based or text based programming language, both independently and collaboratively,
a) combining control structures such as if-statements and loops.  As with the previous example, I'll be having students create a Scratch program and I will be using the modified Design Brief format for the task.

Background
     An element is made of identical or nearly identical atoms. An atom is the smallest unit of matter
and consists of a dense, central, positively charged nucleus surrounded by a complex system of
electron orbitals. Atoms are not divisible by ordinary chemical or physical means.  There are three basic subatomic particles that make up an atom: the proton, the neutron, and the electron.
     An atom can be distinguished from other atoms by how many protons it has in its nucleus. For example, an atom of hydrogen has one proton in its nucleus, whereas helium has two protons in its nucleus. The number of protons in a particular atom determines the atom’s identity and, therefore, is always the same. Protons have a positive charge, and electrons have a negative charge. In a neutral atom, the number of electrons is the same as the number of protons. Protons and neutrons are found only in the nucleus of the atom. Electrons are found in complex orbitals around the nucleus and are constantly in motion.

Challenge
     You will develop a Scratch program that defines and illustrates each of the three components of the atom: electron, proton, and neutron.  Your program will also include a visualization/animation showing how the three components fit together in an atom.  You must also provide a discussion of the makeup of different atoms - specifically the elements Carbon, Hydrogen, Oxygen, and Nitrogen.

Criteria
  • All three components of the atom must be correctly illustrated and explained.
  • You must present a visual model demonstrating the relative positions of all three components in an atom.
  • You must present a visual model of an atom for all the elements listed in the challenge and each model must have the correct number of components in the correct relative position.
  • You must have a clear explanation of why each atom is different, in terms of the numbers of component parts.
  • Your program must include if-then statements, loops, and animation.
Materials
(The materials students will use for this assignment will all be digital, mostly images.  You might want to point them to certain websites where they will find appropriate images - or they can simply draw their own backgrounds and atoms.)
     This challenge has students engaged in a fairly typical activity for this SOL, building a model of an atom.  The difference is that the model will be developed through programming and will be virtual and, to a degree, animated.  The program could start with a few screens just showing text and a simple drawing of an atomic component.  The next part of the program might have students using Motion commands with Loops to demonstrate the various components coming together to build a particular atom - the motion/loops might have the correct number of protons coming into the nucleus of an atom.

Lesson plan from VA DOE
http://www.doe.virginia.gov/testing/sol/standards_docs/science/2010/lesson_plans/grade6/matter/sess_6-4abc.pdf

Example Scratch programs about atoms:
https://scratch.mit.edu/projects/11504644/editor/
https://scratch.mit.edu/projects/107172152/editor/


Sample Performance Task - Photosynthesis

     For this task I've chosen Science 4.2 The student will investigate and understand that plants and animals have structures that distinguish them from one another and play vital roles in their ability to survive, and I will focus on: a) the survival of plants and animals depends on photosynthesis.  The CS standard will be CS 4.2: The student will construct programs to accomplish a task as a means of creative expression using a block or text based programming language, both independently and collaboratively, and 4.13: The student will create an artifact using computing systems to model the attributes and behaviors associated with a concept (e.g., solar system).  
     So this activity will have students using Scratch to develop a model of the process of photosynthesis.  I'll use the Design Brief format and I'll base the challenge on this diagram from KidsDiscover.com: http://cdn4.kidsdiscover.com/wp-content/uploads/2013/08/Photosynthesis-Infographic-Kids-Discover.png
   
Background
     "The word photosynthesis is taken from Latin words meaning “putting together with light.”
Photosynthesis is responsible for life on Earth. This process takes place in all green parts of a
plant. Within a plant’s cells are oblong structures called chloroplasts, which are filled with
chlorophyll. Chlorophyll absorbs light, and the reaction produces sugar (glucose) and oxygen
that are stored in fruits, stems, and leaves. The fruits, stems, and leaves are consumed by
animals. The chemical formula for this process is as follows:
6CO2 + 6H2O → C6H12O6 + 6O2
This chemical equation is read: “Six molecules of carbon dioxide added to six molecules of
water combine to produce one molecule of glucose (sugar) and six molecules of oxygen. Plants
produce small amounts of carbon dioxide. When there is no sun and the plant cannot
photosynthesize, the plant will take in oxygen and release carbon dioxide."   http://www.doe.virginia.gov/testing/sol/standards_docs/science/2010/lesson_plans/grade4/life_processes/sess_4.4c.pdf

Challenge
     You will create a Scratch program that will provide a model of the process of photosynthesis.  Your model will be based on the graphic below but will include animation and user input.

Criteria
Your Scratch program must include:
  • loops, events, graphics, animation, and the opportunity for user input
  • images/animations, and explanations for each of the key components shown in the diagram:
  1. sunlight
  2. chlorophyll
  3. water
  4. carbon dioxide
  5. oxygen

Materials
     As with the other tasks, the available materials will digital.  There are many example Scratch programs dealing with photosynthesis, here are a few, the result of doing a Scratch website search using the term: https://scratch.mit.edu/search/projects?q=photosynthesis.  Some are very complex, some a bit simpler.  Some of the programs have been designed as models and some as interactive simulations - here's a simulation:   https://scratch.mit.edu/projects/10372928/editor/  You can see there are lots of Ask commands followed by an evaluation of the response - the If-Else commands.


     If the player inputs a value that's too large or too small for some variable such as amount of water or amount of sunlight, the program evaluates the answer and responds with a comment telling the user that their answer was too little or too much.
     Some of the examples are simpler.  Here's an example:   https://scratch.mit.edu/projects/140852420/editor/  As you can see there's a lot of explanatory text, animation, and loops and events are used.


     So, depending on your particular class and how much Scratch they might know, you can choose a couple of examples to help them get started.  

Sample Performance Task - Ancient Rome Timeline

     
This task is for World History & Geography to 1500, WHI.6: The student will apply social science skills to understand ancient Rome from about 700 B.C. (B.C.E.) to 500 A.D. (C.E.) in terms of its impact on Western civilization by a)locating Roman civilizations in time and place and describing their major geographic features and b)describing the social and religious structure of ancient Rome. The CS standard will be  8.1 The student will construct programs to accomplish a task as a means of creative expression or scientific exploration using a block based or text based programming language, both independently and collaboratively, a) combining control structures such as if-statements and loops including nested conditionals and loops.  The task will be presented in the Design Brief format and will have students  creating an interactive timeline for the period, including  graphics, sound, and animation.
     Timelines can be very simple or very complex.  A simple timeline program might just have users tap arrow keys to scroll forward/backward along a timeline labeled with text linking a certain date to an important event.  For example, this Scratch project - https://scratch.mit.edu/projects/107944559/
provides a European History Timeline from 1300 to current times.  Several events are labeled on the line and longer events are shown as colored bars to indicate the time and duration of the event.  The coding is pretty simple, as seen below:

     When the Green Flag is pressed to center the sprite (in this case the timeline image) on the screen.  Then there are two sets of commands, one for the right cursor, one for the left cursor.  As you can see, when the arrow is pressed, the timeline moves forward in increments of 10 (-10 for the right arrow, +10 for the left arrow.)  The motion commands are set in if - then commands.  The light green blocks are Operator blocks and, simply put, let you do some mathematics in Scratch programming.  In this example, the Operator block helps the program decide what to do based on where the cursor is.  So, if 0 is the start of the timeline (coordinate for the Scratch field, not the year in European history) and -670 is the end, the green block looks at the X position of the cursor and tells the timeline which way to go.  
     What makes that work is that Scratch knows where the cursor is in terms of position along the line from 0 to -670.  To see this, go to the program, and click the See Inside button.  Once you're inside and see the code, press the Green Flag button to start the program.  Then, as you move along the line by pressing your right or left arrow keys, watch the X value change - it's right below the screen showing the timeline.  The Y value doesn't change since you're only moving left and right.  
     A more complex timeline might involve some interaction - when a user clicks on a certain date, windows with a description of what happened at that particular time, perhaps with images, opens.  An example of this kind of timeline is here: https://scratch.mit.edu/projects/201273/  Once you've clicked the Green Flag to start the program, you move your cursor to a particular dot and as you move over the dot, it changes color and a small box opens with the year.  Clicking on the dot opens up additional information blocks.  It's an interesting program in terms of design - it's not complete at this point but it's worth looking into to see how the author has made the program work.
     Click on the See Inside button.  You'll notice there are a lot of sprites, but only one, blank white, background.  Click on the Timeline first, you'll see there's no associated program, just a line.  The dots, sprites placed on the line, though, are coded.  Here's the code for one of the buttons:

     So, when the Green Flag is clicked, the button goes to the forefront (it might have been behind a box or window), appears (Show), and goes to Costume 1.  The costume is the appearance of the sprite - in this case a black dot.  If the mouse pointer touches the dot, it switches to Costume 2, a red dot with a blue center, and a text balloon with the year opens up.  If you look at the upper left of the Scratch screen, you'll see a tab for Costumes - it's between Codes and Sounds.  You can make changes to the appearance of a sprite, then call them up as needed - it can be a simple form of animation.  Then the programmer has used a forever loop that will check to see if the mouse is pointing at the dot and if not, keep the costume at 1 and saying nothing.  The second part of the program is activated when the sprite is clicked and it sets the value of the Variable Year to 1 - not Year 1, but the first year in the series.
     In the Text Frame block, the program checks the value of the variable and then changes costume - in this case the outline frame is a different color depending on the year.  The Picture frame works the same way, each year has a different color (costume) frame.  Then for the Image frame, the year is checked, then the relevant image (costume) appears.  The same logic for the different text segments - the programmer has used one sprite (in this case called Sprite6) for each year on the timeline for text.  But that sprite has different costumes with each costume being a different block of text.  So costume 2 is the text describing 1998, costume 3 is the text describing what happened in 2001.  

Background
     Ancient Rome was a powerful and important civilization that ruled much of Europe for over 1000 years. The culture of Ancient Rome spread throughout Europe during its rule. As a result, Rome's culture still has an impact in the Western world today. The basis for much of Western culture comes from Ancient Rome, especially in areas such as government, engineering, architecture, language, and literature.  

Challenge
     Your challenge is to develop an interactive timeline that will help us understand how Roman civilization and culture changed from about 700 B.C. (B.C.E.) to 500 A.D. (C.E.) 

Criteria
Your timeline:
  • must be interactive (clickable)
  • must include at least 15 key dates from Roman History
  • clicking on a particular date must open windows that outline the key governmental and social aspects of that time
  • must cover the period from 700 BC to 500 AD
  • must include the following events: (to be selected by teacher)
Materials
     As with all of the Performance Tasks listed, materials are digital and might include both content information and example Scratch programs.


     





Comments

Popular posts from this blog

PURPOSE

MICROBIT EXAMPLE

COMPUTATIONAL THINKING FICTION BOOKS