Students work through an online tutorial on MIT's App Inventor to learn how to create Android applications. Using those skills, they create their own applications and use them to collect data from an Android device accelerometer and store that data to databases. NOTE: Teachers and students must have a working knowledge of basic programming and App Inventor to complete this lesson. This lesson is not an introduction to MIT's App Inventor and is not recommended for use without prior knowledge of App Inventor to produce an end product. This lesson is an application for App Inventor that allows for the storage of persistent data (data that remains in memory even if an app is closed). This required prior knowledge can come from other experiences with the App Inventor. Also, many additional resources are available, such as tutorials from MIT. This lesson could also be used as an enrichment project for students who are self-motivated to learn the App Inventor software.

The Teach Computing Curriculum is broken down into 4 key stages: Ages 5-7, Ages 7-11, Ages 11-14, and Ages 14-16.

Curriculum Information:
- Resources include lesson plans, slides, activity sheets, homework, and assessments
- Each key stage has a teacher guide and curriculum map to help you get started
- Built around an innovative progression framework where computing content has been organized into interconnected networks we call learning graphs
- Created by subject experts, using the latest pedagogical research and teacher feedback
All of the content is free for you to use, and in formats that make it easy for you to adapt it to meet the needs of your learners

This book is about complexity science, data structures and algorithms, intermediate programming in Python, and the philosophy of science. This book focuses on discrete models, which include graphs, cellular automata, and agent-based models. They are often characterized by structure, rules and transitions rather than by equations. They tend to be more abstract than continuous models; in some cases there is no direct correspondence between the model and a physical system.

Think Java is an introduction to Java programming for beginners. It is tailored for students preparing for the Computer Science Advanced Placement (AP) Exam, but it is for anyone who wants to learn Java.

Think OS is an introduction to Operating Systems for programmers. In many computer science programs, Operating Systems is an advanced topic. By the time students take it, they usually know how to program in C, and they have probably taken a class in Computer Architecture. Usually the goal of the class is to expose students to the design and implementation of operating systems, with the implied assumption that some of them will do research in this area, or write part of an OS.

The basic objective of Unified is to give a solid understanding of the fundamental disciplines of aerospace engineering, as well as their interrelationships and applications. These disciplines are Materials and Structures (M); Computers and Programming (C); Fluid Mechanics (F); Thermodynamics and Propulsion (T); and Signals and Systems (S). In choosing to teach these subjects in a unified manner, we seek to explain the common intellectual threads in these disciplines, as well as their combined application to solve engineering Systems Problems (SP). Throughout the year we will endeavor to point out the connections among the disciplines.

This is an introductory unit on coding for students. Students will gain knowledge on how to create a culturally responsive arcade/video game using coding. They will increase their understanding in project building through technology. This unit will involve community and/or Elder connections.
NOTE - As long as the 'Acknowledgement Protocol' is followed to honor the Land and the People where a lesson plan originates, lesson plans appearing on NCCIE.CA may be adapted to different places and different ages of learners.

Most Haskell tutorials on the web use a style of teaching akin to language reference manuals. They show you the syntax of the language, a few language constructs, then tell you to create a few simple functions at the interactive prompt. The "hard stuff" of how to write a functioning, useful program is left to the end, or omitted entirely. This tutorial takes a different approach. You'll start off using and parsing the command-line, then progress to writing a fully-functional Scheme interpreter that implements a decent subset of R5RS Scheme. Along the way, you'll learn Haskell's I/O, mutable state, dynamic typing, error handling, and parsing features. By the time you finish, you should become fairly fluent in Haskell and Scheme.