Category Archives: ISTE Student Standards

Turning computer science students into software engineers

As part of my Digital Education Leadership master’s program, we are asked to create or modify a learning activity that integrates technology in a meaningful way. My project focuses on group assignments in computer science courses. Often, group assignments do not achieve the goal of giving students a real-world experience of building software with multiple programmers.  One of the biggest issues is that the instructor typically starts a group project by describing the chapter to cover in a text book or the learning activity to be achieved.  Such group assignments suffer from all of the failures described in Understanding by Design by Wiggins and McTighe (2005), also referred to as backwards design.

Too often, computer science instructors use trivial games or a partial application as the basis of a group assignment.  Such assignments miss out on giving students critical, real-world experiences such as: investigating requirements, designing a solution, costing out the solution (in programmer time and difficulty), implementing the solution with fellow students/developers, integrating/testing the solution, and delivering the solution.

For my project, I want to follow the backward design process (Wiggins and McTighe, 2005) to give students a more real-world experience.  The backward design approach can be summed up by the following diagram, in which the educator is the designer:

Stages of backward design defined by Wiggins and McTighe Understanding by Design

I want to turn group programming assignments into a project-based learning experience for my students. As it turns out, the Information Technology group at my institution is in regular need of either new features to existing software or new software to address a specific scenario.  My proposal is to have students pick up one of these software projects, participating in all of the phases required in a real-world software development project – i.e., requirements, design, implementation, integration, testing, and delivery.

There are challenges with this project proposal.  First off, the software projects must not be too complex or too large such that the group of students cannot make any reasonable headway in the time given.  This may require picking only projects that are achievable, given the student’s timeline and skill levels. Another approach is to break down large projects into smaller projects, parts of which are given to different student groups.  Finding the correct approach will likely involve my working closely with members of the IT department to develop a list of potential projects. Today, I am not sure if any IT projects will be possible candidates for my students.

The positive side of this project choice is the opportunities it presents to the instructor to implement the ISTE Student Standard 2 Digital Citizen.  Students will have to develop an identity in the open source community in order to access required software in the public domain.  This will require students to use positive, safe, legal, and ethical behavior when engaging with other members of the open source community.  Students will have to manage their personal data and be aware of the consequences of using and sharing software with members of the open source community.

Stage 1 of backward design defined by Wiggins and McTighe Understanding by Design
See Appendix: Stage1 key – Results classification
Stage 2 of backward design defined by Wiggins and McTighe Understanding by Design
Stage 3 of backward design defined by Wiggins and McTighe Understanding by Design
See Appendix: Stage 2 key – WHERETO

Reflection

My initial plan for my project was to create a single lesson plan focused on requirements gathering.  However, in following the backwards design process, I quickly realized that students needed visibility into the entire process to understand this initial lesson plan.  The lesson plan then turned into the unit plan defined above, covering the major components of the software development cycle. While this turned out to be much more work than I had initially estimated, the end result is something much more useful and meaningful to instructors and students in three major ways.

First, the unit plan provides students a much deeper understanding of software development process.  Understanding by Design by Wiggins and McTighe (p. 84) gives these six facets of deeper understanding:

  1. Can explain—via generalizations or principles, providing justified and systematic accounts of phenomena, facts, and data; make insightful connections and provide illuminating examples or illustrations.
  2. Can interpret—tell meaningful stories; offer apt translations; provide a revealing historical or personal dimension to ideas and events; make the object of understanding personal or accessible through images, anecdotes, analogies, and models.
  3. Can apply—effectively use and adapt what we know in diverse and real contexts—we can “do” the subject.
  4. Have perspective—see and hear points of view through critical eyes and ears; see the big picture.
  5. Can empathize—find value in what others might find odd, alien, or implausible; perceive sensitively on the basis of prior direct experience.
  6. Have self-knowledge—show metacognitive awareness; perceive the personal style, prejudices, projections, and habits of mind that both shape and impede our own understanding; are aware of what we do not understand; reflect on the meaning of learning and experience.

The various lessons in the unit plan provides computer science students the ability to explore the first five of these six facets.  In particular, the prototyping phase touches the first five facets by having the students work with a customer to understand requirements, define prototypes, and present results.  The last facet – self-knowledge – is obtained by asking the students to reflect on the unit, and suggest ways to improve or enhance any lesson in the unit. Software development is not a strict, universal process.  The goal is for students to find the process that works best for the team and realize that changes to the process are inevitable.

Second, the unit allows students to explore many aspects of the ISTE Student Standard 2 Digital Citizen standard.  Many people assume that computer science students are inherently aware of all aspects of being a digital citizen.  However, I have found that this not to be the case. I have several instances of students including code in their programming project developed by another person, and not providing any references.  Instead, the student puts their name at the top of the file, indicating that they are the sole developer of the code. When I ask the student questions about the code, it quickly becomes apparent that the student did not author the code.  When I ask the student if they would put their name on top of a writing assignment in which they simply copied and pasted content from a web site, they universally answer ‘no’, and recognize this as plagiarism. I then point out that, from a software point of view, that is exactly what they have done in their programming assignment.  This analogy is very useful in having students understand and respect the rights and obligations of using and sharing all intellectual property, including software.

Third, and lastly, the unit allows me to further explore the possibilities of project-based learning, moving my class form a teacher-centered process to a learner-driven experience.  In their series on making learning personal, Bray and McClaskey provide a spectrum that students move through as they reach the ultimate, entrepreneur stage:

  1. Participant – The teacher or a computer program provides a menu of options for learners.  The choices offered provide learners opportunities to showcase what they know from writing a paper to creating a performance.
  2. Co-designer – The teacher provides learning possibilities and then gets out of the way for learners to go on their own journey.
  3. Designer – The learner chooses topics and direction for what they plan to design based on personal interests.
  4. Advocate – The learner chooses a challenge or problem that they are passionate about.
  5. Entrepreneur – The learner self-regulates, adjusts, and determines learning based on what they want to do with their lives.

Students that become entrepreneurs have a world of possibilities open up to them.  Our role as educators is to provide as many opportunities as possible for students to progress through this spectrum, realizing that students will not follow the same path, at the same speed, with the same instruction.

Resources

Appendix

Stage 1 Key – Results classification

  • G – Established Goals
    • What standards or objectives are being addressed?
  • Q – Essential Questions
    • What essential questions will be considered?
  • U – Understandings: Students will understand that…
    • What understandings are desired?
  • K – Knowledge: Students will know that…
  • S – Skills: Students will be able to…
    • What key knowledge and skills will students acquire as a result of this unit? (aka Students will know… and Students will be able to…)

(Wiggins and McTighe, 2005)

Stage 3 key – WHERETO

How will the design…

  • W = Help the students know WHERE the unit is going and WHAT is expected? Help the teacher know WHERE the students are coming from (prior knowledge, interests)?
  • H = HOOK all students and HOLD their interests?
  • E = EQUIP students, help them EXPERIENCE the key ideas and EXPLORE the issues?
  • R = Provide opportunities to RETHINK and REVISE their understandings and work?
  • E = Allow students to EVALUATE their work and its implications?
  • T = Be TAILORED (personalized) to the different needs, interests, and abilities of learners?
  • O = Be ORGANIZED to maximize initial and sustained engagement as well as effective learning.

(Wiggins and McTighe, 2005)

Tools for a flipped computer programming classroom

The traditional method for teaching a computer programming course is to have the instructor present language syntax and semantics in a classroom lecture and have the students work on programming exercises as homework.  In a flipped classroom, the students learn about programming language syntax and semantics at home through online lessons and courses and come to class to work on programming exercises. Students are then able to learn the computer programming language at their own speed – seeking out other sources and media types for any material that is confusing or unclear.  This provides a wonderful opportunity to individualize learning and leverage technology to improve the learning experience.

However, this does beg the question on how best to use classroom time.  Allowing students to work on programming problems at their own pace will mean that students will soon not be working on the same problems.  How does the instructor provide the best support and environment for all students? How does the instructor evaluate and assess the progress that students are making on a class exercise?  Providing a constructive place where all students can learn is a key first step.

The noise of this digital information can be overwhelming. It can create a numbness to the outside world and limit the ability to retain and reflect on essential learning. Because of this, places of learning must be places of listening that allow time and space for the speed of life to be digested in a meaningful way.

(Dillon, 2014)

In addition to providing a productive place for learning, I want my students to be able to share their solutions with other students.  I want my students to become creative communicators, as described in the ISTE Standard for Students.  This includes allowing students to select the programming tool that works best for them and then use technology to present their solution to the classroom.  Students can then explain how they solved the problem and what challenges they faced in building their solution.

My classrooms provide a computer for each student enrolled in a class.  Students have accounts on these machines that allow for customization and personalization.  Although the students cannot install any software on the machines, they are provided several alternatives environments and tools for building their programming solutions.  Students can also customize these tools to fit their needs.

An important piece to make this all come together is the classroom management software used by the instructor to manage the learning environment.  Fortunately, I have found software to help instructors with this problem – the Vision Pro class management software.  

An instructor can use the Vision Pro software to see the screens of all of the student’s computers at the same time.  The instructor can even visit one of the students machines, and provide tutoring and other assistance. The instructor can also display a student’s machine to the classroom, allowing the student to become the teacher, and instruct the class on how to solve a particular programming exercise.  This is a tremendous tool to get each and every student to participate in the learning process – similar to what happens when students use blogs to share opinions.

By creating an online place where people feel comfortable and relaxed, a place that affords communication and interaction at different levels and while using a variety of tools, both tutors and students develop a strong sense of presence that can help participants gain confidence in both their learning and teaching.

(Kop, 2010)

With Vision Pro, instructors can provide a safe, individualized place for students to build and share their programming assignments.  But there are still challenges that remain. The approach described above allows the instructor to keep the class together for small programming exercises (i.e., a few lines of code), but does not provide a solution for medium to large programming exercises.  

Fortunately, there is an approach an instructor can take to leverage the classroom management software for even medium to large class exercises.  By breaking down a larger exercise in to multiple pieces, the instructor can assign the smaller pieces to different students. If one student finishes a piece early, the instructor can have that student work on one of the other pieces.  When all of the pieces have a solution from at least one student, the instructor can have each of these students present to the class their piece of the problem.

In the end, the instructor can pull the solutions for all of the pieces together to show a complete solution to the classroom – or even better – have a student own pulling the pieces together and present to the class.  The last step is to use the Vision Pro software to work with other classrooms around the world to collaborate on solving computer programming exercises together, turning the students into global collaborators!

References


Motivating CS students to test their code

Any software engineer in industry can tell you the importance of software testing in the software development lifecycle.  The quality of the software is ultimately the deciding factor on whether the software is ready to ship. Yet, very little time of a computer science student’s studies involve software testing.  On any one of my programming assignments, there is at least one or more cases of a student’s submission either crashing shortly after startup or producing incorrect results on valid inputs. When I circle back with these students on how this happens, the common response is that they did not think to test the particular scenario.  A group of computer science professors at the University of Texas have found a possible reasons for this result.

Software testing is a subject that can be difficult to teach, perhaps because it relies heavily on experiential learning; at the same time, because it is an activity that most students do not enjoy, students tend to expend minimal effort on testing.

(Smith et al., 2012)

Software professionals are acutely aware of the importance of software testing.  In the days of the waterfall software methodology, software testing was a distinct, end stage of the development process that was often performed by a separate set of software engineers.  Bill Gates made this observation about testing at Microsoft:

Microsoft in terms of this quality stuff — we have as many testers as we have developers.  And testers spend all their time testing, and developers spend half their time testing. We’re more of a testing, a quality software organization than we’re a software organization.

(Foley & Murphy, 2002)

Today, the software industry has moved to an agile software methodology that eliminates the distinct testing stage found in the waterfall model.  Developers are fully responsible for developing, running, and passing all tests on their code before completing a sprint. This model puts much more pressure on software engineers to produce quality test cases – a task that is currently missing in most computer science curricula.

So, how do we get computer science students to think more about software testing?  The start of an answer can be found by applying computational thinking defined by the International Society for Technology in Education (ISTE) standards for students (ISTE, n.d.).  Educators define computational thinking as the process of applying computer science concepts like decomposition, pattern matching, and abstraction to learning disciplines other than computer science.  However, these computational thinking concepts are very relevant to the process of software testing. Computer science students can apply automation to the process of software testing and algorithmic thinking to develop a sequence of steps to create automated test cases.

Professional software engineers use a test harness or framework to manage test cases.  These test frameworks can be complicated to setup and manage. Fortunately, there are tools that are much more approachable for computer science students.  One such tool is Jasmine, an open source test framework for building JavaScript test cases.  There are some terrific Jasmine tutorials that can greatly lower the learning curve for computer science students, and Jasmine is being used with modern JavaScript libraries like React and Angular.

Just making a test framework available to computer students is not sufficient to get students to write useful test cases.  While test frameworks simplify the task of writing and managing test cases, the students still need motivation to write decent test cases.  I researched how other instructors approached this problem – and what techniques were used to motivate students to write better test cases. I wanted my computer science students to foster the same work skills of collaboration, problem solving, and project management that is often found in many robotics classes.

Robotics is also a highly effective way to foster essential work skills like collaboration, problem solving and project management. It does all this while keeping kids so motivated and engaged that getting them to stop working and move on to the rest of the school day can be a challenge — a good problem to have!

(Gura, 2013)

A great article that shows promising results in this area uses peer review or peer testing, a process in which students try to break code written by their peers (Smith et al., 2012).  The study was done by instructors in the Fall quarter of 2011 at the University of Texas at Austin for CS314H, an honors data structures course in computer science. The goals of their approach matched my goals.

Our solution has three main goals. First, we want to make testing fun and competitive so that students will put effort into testing. Second, we want students to learn from each other, so that they can see how others approach the same problem, perhaps with a greater degree of creativity than they have. And third, we wish to illustrate the tangible benefits of good software testing by uncovering latent bugs in their code.

(Smith et al., 2012)

The instructors found that a majority of the CS314H students enjoyed the peer testing exercise and found it worthwhile.  Peer testing did involve more work for students – yet many of the CS314H students expressed interest in doing more peer testing.  This is a wonderful result, and something I hope to replicate in my computer science courses!

References

Engaging CS Students in Design

Many group assignments in computer science courses expose students to only a portion of the software development process.  In particular, the first stages in most software development processes are rarely covered. These are the stages in which requirements are gathered, prototypes are built, and the customer is engaged in an iterative design process.  The start of many group assignments in computer science courses begin with a screenshot of a fully design application in which the student is asked to implement. While this approach is useful for developing skills needed for the later stages of the software development process, it completely misses the opportunity to engage students as innovative designers (ISTE Standard for Students).

The design and prototyping stages of the software development process engage students in so many of the skills critical for their success.  The obvious skills are innovation and creativity. Students can also develop their empathetic and analytical skills. The design and prototyping phases require a large amount of patience from students and educators.  However, the benefits of the time spent in this stage are recognizable when a student begins to engage in the latter stages of the software development process. Design thinking is not something unique to the software development process and is found in related fields such as graphics design.

Design Thinking Process (Humphrey, 2015)

It is somewhat understandable why many computer science instructors avoid the design and prototyping stages in the software development process.  There are many possible landmines and things can get out of control in many ways. And this is not just on the software designer side. I have participated in requirements and design sessions with very technical customers.  Many times, these technical customers quickly slip into talking about solutions rather than describing problems and requirements. Of course, the flip of this problem – and many would argue the more common problem – is when software designers lack the proper empathy to engage properly with customers, particularly less technical customers.  This leads to a design session in which the customer is never able to describe the real requirements, as the software designer has already jumped to a design that the customer “needs”, even though the customer did not state the “need”. This problem is very prevalent in many industries – from software deign to automotive design – and has led designers to constantly repeat the phrase “keep the customer first”.

The Empathize mode is the work you do to understand people, within the context of your design challenge. It is your effort to understand the way they do things and why, their physical and emotional needs, how they think about world, and what is meaningful to them.

(Institute of Design at Stanford, n.d., An introduction to the design thinking process)

So, how do we get students to use their empathy to engage with customers?  One great way is by using an iterative prototyping process. That is, have the students build quick and simple prototypes that are shown to the customer.  The first prototypes will likely not be successful with the customer. Given a proper tool, the students should be able to use the customer’s feedback to iterate on the next prototype.  This iterative prototyping process is nicely captured in the human-centered design process.

What is human-centered design video
DesignKit.org, What is Human-Centered Design?

All of this hinges on giving students a prototyping tool that is simple to use, but powerful enough to dmonstrate a rich design.  Fortunately, I came across a fantastic prototyping tool that has all of these features – Mockups by Balsamiq.  There is no coding needed to use the Balsamiq mockup tool, as the tool uses the same drag and drop metaphor used in Microsoft Powerpoint and other presentation software.  One can even build a functioning prototype – with active links and buttons – that demonstrates the flow of an application with no coding. The Balsamiq software can be used to design web sites, mobile applications, and desktop applications.  The Balsamiq video given below starts off with the intriguing catch-line “… would you build a house before making a plans for it?”.

Video demonstrating the Balsamiq mockup tool
Mockups by Balsamiq

I have used wire-framing tools for commercial products in industry.  All of those tools were much more difficult to use than Balsamiq and very expensive.  What gets me excited about Balsamiq is that it is not only far simpler to use than other tools, but that Balsamiq also has a ‘Giving Back’ program that makes their mockup tool free to educators and students.  The tool is very contagious – once students get proficient, they are likely to use tool for all of their group assignments, whether requested by the instructor or not.  In addition, students can use Balsamiq to create incredible artifacts of their design work. Those are both fantastic outcomes!

The task of getting students to spend more time in the design and prototyping phase is not a simple one.  Technology can definitely help, but there is a learning curve even for design and prototyping tools like Balsamiq.  However, these skills are critical to computer science students if they want to be successful in the digital age.

As a result, the demands on those responsible for teaching and instruction have increased, but above all, these new demands of teachers in a digital age mean that their own skills level needs to be increased to cope with these demands.

(Bates, A. n.d., Chapter 2.7.6 – Is the nature of knowledge changing?)

References

Students as Knowledge Constructors

In computer science courses, students are asked to form groups to solve a particular problem.   Such group projects give students the opportunity to address real-world issues and problems, allowing students to make meaningful learning exercises for themselves and others.  Such projects turn students into knowledge constructors, asking students to take on an open-ended inquiry using recently gained programming skills. These experiences, as well as all of the knowledge constructor indicators listed in the ISTE Standard for Students, empower student voice and ensure that learning is a student-driven process.

The practice of using real-world problems in the classroom is referred to as project-based (or problem-based) learning (PBL).  PBL is used in a experiential learning frameworks:

Problem-based learning (PBL) is integrated at Two Rivers Public Charter School in Washington, DC, at every grade level—pre-K through eighth grade. Students are presented with a real-world problem, undertake a series of investigations, and create a product that they present to an authentic audience as part of the Expeditionary Learning (EL) Education framework.

(Edutopia, 2016)

The group projects used in computer science courses require students to understand the problem, build requirements, and research resources required to build a solution. In addition, the students must work together to divide up the problem, research ways to solve the problem, and divide the problem up among group members in a reasonable and fair way.  While giving students a great experience in digital literacy, all of these activities put together satisfy the four fundamental competencies described in Kingsley & Tancock:

Past research, including statistically significant outcomes from our research study, has revealed the following four fundamental competencies students must possess and attain to successfully complete Internet-based tasks:

    1. Generate high-quality inquiry topics

    2. Effectively and efficiently search for information

    3. Critically evaluate Internet resources

    4. Connect ideas across Internet texts

(Kingsley & Tancook, 2014)

Unfortunately, the results of group programming assignments are not often used as learning artifacts.  Students work for weeks on a group project, turn in the final results to the instructor, and never look at the project again.  Over a typical computer science curriculum, a student may implement 5 or 6 group projects. This represents a considerable portfolio of work for any student.

I wanted to find a simple way for students to display the results of the hard work put into group projects, for themselves and for future educators and/or employers.  My first approach had the students build a website that highlighted the project with screenshots or other project results. However, this involved a bunch of work around obtaining an Internet domain, selecting a web hosting service, and learning how to launch and maintain a website.  This quickly became overwhelming, even to computer science students. Luckily, I discovered a simpler approach that leverages skills that students likely already have – GitHub Pages.

The GitHub Pages tool takes a bit of explaining.  In software projects involving multiple developers, there is a need to use source control to track what changes are made by which developer as well as to control what happens when two developers change the same source code file.  This is similar to revision control in a word processor – such as Microsoft Word – in which two or more people are authoring the same document. One of the most popular software source control packages used today is Git. By itself, Git is just the software that allows one to checkin and checkout files containing computer source code from a central repository.  A software repository is the collection of computer source code files that make up a software project. Git does not provide the repository in itself – it is just the software used for source control. However, GitHub.com is a website that offers free accounts where users can use the Git source control software to create and manage any number of software repositories.

Students working on a group project often create a repository on GitHub for source control purposes.  This allows individual members of the project to share their work with other students in their group as well as control access to shared files.  GitHub Pages is a free website for students with a GitHub account. Students that use GitHub Pages do not have to set up any databases or web servers.  Students can use GitHub Pages to highlight the projects they have created on GitHub as well as other skills. In essence, GitHub Pages provides computer science students a digital portfolio of their software projects.  In addition, by using GitHub Pages to build a software portfolio in which that other developers can share and contribute, students develop their digital literacy skills using the functional, social, and transformative models described in McLoughlin:

In viewing literacy within the context of a digital society as, at one level functional, at another engaged with the social context, and at a third as transformative, we can see it as a powerful tool for the individual and the group to understand their own relationships to affordances of digital tools that enable these skills and competencies to develop.

(McLoughlin, 2011)

References


Empowered Learner

Tablet showing Computer Science and related topics such as programming, computation, theory, etc.
Computer Science by Nick Youngson CC BY-SA 3.0 Alpha Stock Images

The International Society for Technology in Education (ISTE) is passionate about the power of technology to transform teaching and learning.  The ISTE Standards provide a framework that allows students and computer science educators (as well as other educators) to create innovative learning environments.  In particular, the ISTE Standard for Students are designed to empower students and to ensure that learning is a student-driven process.  I want to focus on the empowered learner, and how computer science students can use technology to inform and improve their computer programming skills and demonstrate their learning in a variety of ways.

Like many subject areas, software engineering is witnessing rapid change. As stated in [Bates, n.d.], “… it is difficult to predict with any accuracy what many graduates will actually be doing ten or so years after graduation, except in very broad terms.”  However, one aspect of computer programming that has remained the same, even as new development environments, programming languages and other tools have changed and evolved, is the need to comment code. Students must realize that comments in the code they write serve multiple audiences.  The first audience is their future self, when they come back to their own code to make improvements or fix bugs. The second audience is the future developer that will take over responsibility for fixing bugs and adding new features to the code. Finally, the third audience is the developer that will invoke the code from other code.

The challenge with getting computer science students to write good comments is having students empathize with these three audiences.  Typically, computer science students spend very little time commenting their code, leaving it to the last thing done before submitting their assignment.  The students are only thinking about the bar set by the instructor for acceptable amount of comments that will not impact their assignment grade. Many of my fellow computer science instructors have no commenting component in their grading rubric for coding assignments.

Even when students put comments in their code, the comments often fall into the bad and ugly traps described in the article ‘Putting comments in code: the good, the bad, and the ugly’ by [Sourour, 2017].  One creative solution to this problem leverages the set of tools described at the beginning of the [Sourour, 2017] article. Specifically, students can benefit from the code documentation tools such as JSDoc and JavaDoc for adding comments to JavaScript and Java code, respectively.  Even though these tools were built for documenting Application Programming Interfaces (APIs), both tools require the programmer to follow strict commenting conventions and make comments presentable to an outside reader.

A billboard of the Clint Eastwood movie 'The Good, the Bad, and the Ugly' used to highlight the good, bad, and ugly in computer commenting.
Putting comments in code: the good, the bad, and the ugly

The full solution to the code commenting problem requires one more step.  As mentioned, students typically only write comments with the target audience of the instructor and the goal of passing grading requirements.  However, by asking another student to read the comments generated by their classmate, students now have to consider another audience. Furthermore, you can ask the other student to put themselves in the shoes of the developer that has to maintain their classmate’s code as well as the shoes of a developer that has to call or re-use their classmate’s code.  The students reading their classmate’s comments would use the output from the JSDoc or JavaDoc tools, and give feedback to the student who authored the comments, as well as present their understanding of the reviewed code to the entire class.

My role as a computer science educator is to constantly be on the lookout for new and better tools to improve computer science education.  In the article ‘Emerging technologies for education’, [Mecklenburger, 1986] tells us the importance of this role:

The challenge to educators and to educational policy is to exploit what has become available. If we do not, others will. We cannot tread water any longer, or the social and financial base for public education institutions will continue to erode compared to other educational investment.

References

  1. Bates, A. W. (n.d.). Fundamental change in education. Teaching in a digital age. Retrieved from https://opentextbc.ca/teachinginadigitalage/part/chapter-1-fundamental-change-in-education/
  2. Guzel, Burak. (2011). Top 15+ Best Practices for Writing Super Readable Code. https://code.tutsplus.com/tutorials/top-15-best-practices-for-writing-super-readable-code–net-8118
  3. ISTE, International Society for Technology in Education, http://www.iste.org
  4. Mecklenburger, J. A. (1986). “Emerging” technologies for education. Peabody Journal of Education, 64(1), 183-187.
  5. Sourour, Bill. (2017). Putting comments in code: the good, the bad, and the ugly. https://medium.freecodecamp.org/code-comments-the-good-the-bad-and-the-ugly-be9cc65fbf83

Studying Stonehenge & Preparing Students for the Future

For SPU’s Digital Ed Leadership Program elective course, EDCT 5605 Inquiry-based Learning, the module 1 investigation question is: What is inquiry-based learning? Why should you do it? Using the ISTE Student Standards as a framework for further inquiry, my guiding question is: How can inquiry-based learning prepare students for the future? When my son was […]

Backwards design: Antiderivatives (Individual project)

For our individual projects this quarter, we each re/designed a lesson plan using Backwards Design (BD) (Wiggins & McTighe, 2005). I have yet to teach a college math class, so unsurprisingly, I have never designed a lesson plan for a college math class before. Though I do frequently daydream about it… And for some reason I usually imagine teaching Calculus II. Possibly because the topic is so…integral to STEM fields? So for my lesson plan, I chose the first day (or two) of Calculus II.

I thought really hard about what I want students to experience on their first day of Calculus II and what class culture I want to establish. Since all I can do is simply imagine what I want to teach, I wasn’t going to limit myself to the topic that is typically taught on the first day. Instead, I wanted to allow myself to reimagine what should be taught on the first day so that they leave with a solid sense of how Calculus II is related to what they have done in Calculus I. After following a few different paths, I decided that the topic I wanted to talk about was antidifferentiation, which is a nifty section that simultaneously reviews Calculus I while setting the stage for Calculus II; antiderivatives introduce you to the whole idea of “undoing” the process of differentiation – i.e., integration. Perhaps unsurprisingly, this is indeed one topic that you might see on the first day of Calculus II (or maybe the last day of Calculus I).

For class culture, the elements of communication, collaboration, and conceptual understanding are very important to me. And if these elements are to be included in the culture, Mazur (1997) emphasizes the need to establish these class norms on day one (and consistently throughout the whole course). Therefore, alongside my Relationship to Calculus I BD, I wrote a Class Culture BD.

In support of the class culture goals, I have a Digital Citizenship BD that allows me to separately track the incorporation of ISTE Student Standard 2: Digital Citizenship – “students recognize the rights, responsibilities and opportunities of living, learning and working in an interconnected digital world, and they act and model in ways that are safe, legal and ethical.” I’ve thought about it a lot, and so far the only way I see to authentically tie Digital Citizenship standards into your typical college math course, is to weave a digital environment into the fabric of the course. Otherwise, it feels like a box to check – “Okay, we did an assignment with Digital Citizenship and talked about it for 10 minutes.” But I think a digital environment gives you two things simultaneously: a way to tie in Digital Citizenship and another set of pathways for students to collaborate and communication, and develop their class culture.

So for my imaginary class, I chose slack.com as our digital environment to use throughout the course (see my previous post on Slack for more about what it is and why I like it). Using Slack will give us a context in which to talk about Digital Citizenship Indicator 2b throughout the quarter – “students engage in positive, safe, legal and ethical behavior when using technology, including social interactions online or when using networked devices,” and Digital Citizenship Indicator 2d – “students manage their personal data to maintain digital privacy and security and are aware of data-collection technology used to track their navigation online.”

My Backwards Design(s)

Here is a link to my Backwards Designed lesson plan. I wanted to share my whole design, even though it’s a practice lesson plan, because I had a hard time finding Backwards Designed math lessons. Sharing my final product for this project (which I still consider a draft in the grand scheme of things) could be valuable to other math teachers trying to use BD to write a math lesson – even if that value is seeing that you disagree with something in my lesson.

Admittedly, there’s a lot going on in my BD since I have three components: Relationship to Calculus I, Class Culture, and Digital Citizenship. But I do think they make sense together, and I felt like it was really helpful for me to do these things in parallel if what I truly want (in my hypothetical class) is a specific class culture. In fact, I felt that writing these BDs in parallel helped me see how I could possibly accomplish this vision I have for my math classes, where students communicate and collaborate, and where conceptual understanding is a priority. That said, I will only talk about some of the elements of my BD in this blog post – feel free to send me questions about anything I do or don’t address here. I will go into the most detail about the Relationship to Calculus I BD elements, since that was the most challenging to wrap my head around.

Relationship to Calculus I Standards: While there are calculus Common Core standards since calculus is taught in high school, they did not resonate with me as “the standards that need to be met” for college classes. It could probably be argued that colleges should adopt something like Common Core standards, but presently, the standards used to compare college courses really are the textbook topics. To see if two courses are equivalent (like when transferring credits), colleges compare the syllabi of the courses – i.e., they compare the topics covered in the courses. So after some deliberation, I decided that the standards which made the most sense really were the theorems, definitions, etc. from a given chapter.

Relationship to Calculus I Essential Questions: My essential questions most closely resemble the third connotation of essential questions discussed by Wiggins et at. (2005): “we can consider a question essential if it helps the students effectively inquire and make sense of important but complicated ideas, knowledge, and know-how—a bridge to findings that experts may believe are settled but learners do not yet grasp or see as valuable” [emphasis in the original] (p. 109).

I could possibly be convinced that my essential questions “What function, when you take the derivative, gives you this function? What is this function the derivative of?” do not fit the definition of an essential question, but I included it because it is the fundamental question guiding the lesson. My other essential questions, “What is an example of two functions that have identical outputs only sometimes? What is a real life situation that could be represented by a piecewise function?,” fit the definition better. Both of these questions are getting at why the interval I is mentioned in the definition of antiderivative. Mathematicians have decided that it’s “settled” that this tidbit of information is required for the definition, but it’s a tidbit that students could have a hard time seeing the value in. So these questions will hopefully be entry points to making sense of “the I” in the definition of the antiderivative.

Relationship to Calculus I Academic Prompts: I would enjoy a discussion on what performance tasks look like in math. I tried to come up with performance tasks by looking at the examples Wiggins et al. (2005) give for geometry (p. 266) and their descriptions of the types of evidence (p. 153), but instead I think I came up with a type of academic prompt. I did write these questions myself and I think they are influenced by my background with University of Washington’s Physics Tutorials (McDermott & Shaffer, 2002).

Class Culture Assessment Evidence: For this, I kind of metaphorically “threw paint at the canvas” where the paint represents things that could indicate the development of the culture I am hoping for, and the canvas represents the BD Assessment Evidence box. It’s hard to assess class culture, and I imagine doing it informally. I wasn’t necessarily imagining that I would tell the students “I will be assessing our class culture and here is how,” but it would be a good next step to consider which assessment items I would want to share with the students and how to word those items or frame the discussion.

Digital Citizenship Assessment Evidence: I am not sure the best way to meaningfully assess, in the context of a math class, if they are thinking deeply about what information they share in their Slack profile (as per Digital Citizenship Indicator 2d). I think you can assume they put some level of thought into it if they update their Slack information, but you can’t really make any judgment what level of thought. And what if they thoughtfully decided that the default information shared on Slack is actually the information they want to share? That wouldn’t be visible by looking at their profile. I considered giving them a ranking question like “I thoughtfully considered what information I want available on Slack: 5 4 3 2 1” but I’m not convinced that giving them that assessment would add any value to the process. So for now, the only assessment I have is informally observing them participate in the class discussion or updating their information in Slack, which can only maybe indicate that they are thinking deeply, and cannot indicate that they are not thinking deeply.

Six Facets of Understanding

Wiggins et al.’s (2005) say that “to understand is to make sense of what one knows, to be able to know why it’s so, and to have the ability to use it in various situations and contexts” [emphasis added] (p. 353). The issue with “teaching for understanding” is that understanding is an ambiguous term (p. 35). There are many meanings to the word understanding, and Wiggins et al. claim that “complete and mature understanding ideally involves the full development of all six kinds of understanding” (p. 85) where the six facets of understanding are defined as:

  • “Can explain—via generalizations or principles, providing justified and systematic accounts of phenomena, facts, and data; make insightful connections and provide illuminating examples or illustrations.
  • Can interpret—tell meaningful stories; offer apt translations; provide a revealing historical or personal dimension to ideas and events; make the object of understanding personal or accessible through images, anecdotes, analogies, and models.
  • Can apply—effectively use and adapt what we know in diverse and real contexts—we can “do” the subject.
  • Have perspective—see and hear points of view through critical eyes and ears; see the big picture.
  • Can empathize—find value in what others might find odd, alien, or implausible; perceive sensitively on the basis of prior direct experience.
  • Have self-knowledge—show metacognitive awareness; perceive the personal style, prejudices, projections, and habits of mind that both shape and impede our own understanding; are aware of what we do not understand; reflect on the meaning of learning and experience” (p. 84).

On paper, I think my hypothetical lesson did a fairly decent job including these facets – the only one I don’t feel like I can see in my lesson is the facet “apply“. However, in practice I might feel entirely differently about how my lesson holds up to these facets. But for now, here’s how I see the facets showing up in my lesson:

The Relationship to Calculus I DB elements get at the facets of explaining and interpreting. Explaining will hopefully emerge when the students work to develop the idea of adding a “+ C” to the end of the most general antiderivative. Then the assignment where they start off by drawing their own graphs, but ultimately explain the features of their partner’s graph should also encourage explanation. Interpretation comes up when they work in groups to come up with a real life situation that could be diagramed by a piecewise function; they will need to understand what is graphed and be able to interpret how a graph matches their thought-up scenario.

The Class Culture BD element gets at the facets of empathy and perspective. I found these two elements somewhat difficult to disentangle, but there’s an image in my mind that helps me understand them separately. I’m imagining this in a math context, but really it’s suitable for many contexts. I’m imagining a scenario where, for some reason, you don’t feel like listening to someone’s idea. Maybe you feel rushed, you really want to talk to someone you know is always one step ahead, and you feel this is not that person. Empathy encourages you to listen to them anyway. Perspective is what you stand to gain by listening to their idea – a new perspective on the problem or idea, a new way to see the math. A class culture of taking other people’s ideas seriously encourages the habit of listening, which I think can help teach empathy and perspective.

Self-knowledge should come out through self-assessment by using the Clear and Unclear Windows (Ellis, 2001). This is a reflection technique where, at the very end of class, you have the students write down what they felt was clear during the class period on one half of the page, and what they felt was unclear on the other half of the page. Then they turn it in to you before leaving class. This helps them reflect and helps the teacher get a sense for where the students are at. I also hope that through learning to understand their peers’ ideas, they will find opportunities to reflect on their own habits of mind and thus develop their self-knowledge.

I didn’t feel like application truly made its way into my day-one lesson. This is unsurprising since my performance tasks turned out to be academic prompts. Recall the description of application – “effectively use and adapt what we know in diverse and real contexts—we can ‘do’ the subject” (Wiggins et al. 2005, p. 84). This description seems to link “real contexts” with “doing” the subject and I’m currently struggling with the pairing of those two things in math. While mathematical relationships can hold true in the real world, math is a construct in the mind. And what I think of as doing the subject may or may not involve what I think other people call real contexts. At this point in my life, what it feels like to do math, even in my real contexts, feels very similar to the academic context. So while I feel like my lesson does including “doing” the subject, I’m not sure it involves real contexts in the way that Wiggins et al. (2005) means.

Final Thoughts

I thought the BD process was really valuable, and it helped me break up my different goals into individual tracks that I could think through separately before bringing them together. But the ideas in BD are complex, and I think it’s easy to think you know what something means and then realize you’re off base. I don’t expect to turn out a whole, perfect lesson that any Calculus II teacher could pick up and use, but I hope that my lesson can contribute in some way to the discussion of how to create a BD math lesson for a college class.


 

References

Ellis, A. K. (2001). Teaching, learning, and assessment together: The reflective classroom. Larchmont, NY: Eye on Education.

ISTE: International Society for Technology in Education. (2016). ISTE standards for students. Retrieved from https://www.iste.org/standards/standards/for-students-2016

Mazur, E. (1997). Peer instruction: A user’s manual. New Jersey: Prentice Hall, Inc.

McDermott L. C., Shaffer P. S. (2002). Tutorials in Introductory Physics. Retrieved from https://depts.washington.edu/uwpeg/tutorial

Stewart, J. (2008). Chapter 4.9: Antiderivatives. In Calculus early transcendentals 6th edition (pp. 340-354). Belmont, CA: Thomson Higher Education.

Wiggins, G. P., & McTighe, J. (2005). Understanding by design. Alexandria, VA: Association for Supervision and Curriculum Development.

Collapse Project: Integrating Jared Diamond’s Five Point Framework AND Technology Into the Classroom

Jared Diamond’s treatise on environmental damage and societal collapse is a landmark work on societal issues facing the world today. As such, it makes a fantastic teaching tool for my 12th grade current world problems class, and I’ve been using the book as a text for several years now.  For my digital education leadership class, … Continue reading "Collapse Project: Integrating Jared Diamond’s Five Point Framework AND Technology Into the Classroom"

Spreading the News: New Computer Science Framework and ISTE Students Standards

Administrators at the district and school level are instrumental in the successful pursuit and implementation of educational technology initiatives. As an instructional technology specialist demonstrating and applying the ISTE Coaching Standards, it’s a responsibility to help bridge all stakeholders to create a technology rich professional learning program. Exploring ISTE Coaching Standard 4: Professional Development and […]