Basic Coding Class Curriculum
This foundational curriculum is engineered to transition students from logical thinking to functional programming. By starting with visual blocks and moving to text-based syntax, learners build the cognitive scaffolds necessary for modern software engineering.
- Understand fundamental programming concepts like sequences, variables, loops, and conditional statements.
- Develop logical thinking and problem-solving skills through coding exercises.
- Create simple interactive programs and games.
- Understand the basic syntax and structure of a visual programming language (like Scratch) and a text-based language (like Python).
- Appreciate the role of coding in everyday technology and its innovation potential.
- Develop foundational skills for further exploration in computer science.
- Hands-on Learning: Emphasis on practical coding activities and projects.
- Visual and Interactive Tools: Starting with visual programming to grasp concepts easily.
- Gamified Learning: Incorporating game development and interactive exercises to maintain engagement.
- Collaborative Activities: Encouraging teamwork and peer learning.
- Real-world Connections: Relating coding concepts to everyday technology and applications.
- Age-Appropriate Content: Using examples and scenarios relevant to students.
Unit 1: Getting Started with Scratch (Weeks 1-3)
Goals: Understand the Scratch interface, sprite manipulation, events, basic motion.
Activities: Interface exploration, moving sprite, responding to events, changing appearance, simple animation.
Assessment: Observation of student interaction, animation task completion, basic motion quiz.
Unit 2: Sequences and Basic Interactions (Weeks 4-7)
Goals: Understand instruction sequence, basic control blocks (wait, repeat), introduce sound, basic sensing blocks, simple interactive stories.
Activities: Dialogue story, repeating actions, adding sound, sprite interaction, simple interactive game.
Assessment: Interactive story/game evaluation, sequence/control flow understanding, sound/sensing exercises.
Unit 3: Controlling the Flow: Introducing Decisions (Weeks 8-10)
Goals: Understand conditional statements (if), make decisions in programs, use comparison operators, complex interactive stories/games.
Activities: Simple quiz, sprite reaction based on conditions, choose-your-own-adventure story, improving simple game.
Assessment: Interactive project logic, conditional statement understanding, conditional logic problem-solving.
Unit 4: Remembering Information: Introducing Variables (Weeks 11-14)
Goals: Understand variables as containers, learn to create/set/change/use variables, apply variables for score, lives, game elements.
Activities: Score counter, tracking lives, controlling sprite movement with variables, simple calculator.
Assessment: Projects using variables effectively, explanation of variable use, exercises on variable manipulation.
Unit 5: Doing Things Repeatedly: Introducing Loops (Weeks 15-18)
Goals: Understand loops (repeat, forever, repeat until), automate repetitive tasks, create patterns, combine loops with other blocks.
Activities: Repeating animations, drawing patterns, games with continuous actions, simple looping games.
Assessment: Projects using different loop types, explanation of loop use, coding challenges with loops.
Unit 6: Sensing and Controlling More Intricately (Weeks 19-21)
Goals: Explore advanced sensing blocks (ask, timer), learn advanced control blocks (if-else, wait until), create more interactive programs.
Activities: Program asking for input, implementing timers, using if-else for complex decisions, developing a more complex game.
Assessment: Evaluation of project complexity/interactivity, understanding of advanced blocks, problem-solving using these blocks.
Unit 7: Getting Started with Python (Weeks 22-25)
Goals: Understand visual vs. text-based programming, set up Python environment, write/execute simple commands, understand basic data types (int, float, string), use print() function.
Activities: Exploring Python interpreters, "Hello, World!", exploring data types, using print(), simple calculations.
Assessment: Python environment interaction observation, simple coding exercises, basic syntax/data type quiz.
Unit 8: Making Decisions in Python (Weeks 26-29)
Goals: Understand conditional statements (if, elif, else) in Python, use comparison operators, write programs making decisions.
Activities: Simple number guessing game, basic calculator with operations, checking even/odd, simple decision-based story.
Assessment: Evaluation of Python programs with conditionals, understanding of if/elif/else, conditional logic problem-solving.
Unit 9: Repeating Actions in Python (Weeks 30-32)
Goals: Understand loops (for, while) in Python, automate repetition, process data sequences, create simple patterns, iterate through strings.
Activities: Printing numbers in a range, creating patterns, iterating through strings, simple looping games, (optional) introduction to lists.
Assessment: Evaluation of Python programs with loops, explanation of for vs. while, coding challenges with loops.
Resources: Scratch (online/desktop), Python (repl.it/local), Code.org, Khan Academy, W3Schools, Worksheets, Project Guidelines.
Assessment: Formative (observation, quizzes), Summative (project evaluation, tests), Portfolio.
Differentiation: Extension for advanced, scaffolding for struggling, peer tutoring.
Advanced Coding Curriculum
The Advanced track shifts focus toward software architecture, object-oriented principles, and collaborative development. Students will build dynamic web applications and learn to manage code professionally.
- Solidify understanding of Python fundamentals, including data structures and functions.
- Learn object-oriented programming (OOP) concepts and apply them in projects.
- Be introduced to fundamental algorithms and data structures.
- Gain basic knowledge of web development using HTML, CSS, and a lightweight Python framework (like Flask).
- Develop problem-solving and computational thinking skills through more complex coding challenges.
- Work collaboratively on coding projects using version control (Git).
- Understand ethical considerations and the impact of technology.
- Project-Based Learning: Students will work on more extended projects that integrate multiple concepts.
- Inquiry-Based Learning: Encouraging students to explore and experiment with new concepts.
- Collaborative Coding: Emphasizing teamwork and code sharing using Git.
- Real-World Applications: Focusing on how coding is used in various fields relevant globally.
- Code Reviews: Introducing the practice of reviewing and providing feedback on each other's code.
- Guest Speakers (Optional): Inviting professionals from the tech industry to share their experiences.
Unit 1: Revisiting Python Basics and Functions (Weeks 1-3)
Goals: Review fundamental Python concepts, understand function importance, define and call functions, explore scope, introduce docstrings.
Activities: Review exercises, function creation for tasks, modularizing code, debugging exercises.
Assessment: Function creation assignments, function concept quiz, code review of functions.
Unit 2: Organizing Data: Lists and Tuples (Weeks 4-7)
Goals: Understand lists and tuples, create/access/manipulate elements, explore list operations, understand tuple immutability, implement programs using lists/tuples.
Activities: List manipulation exercises, data analysis with lists, working with tuples, simple games using lists.
Assessment: Projects using lists/tuples, practical exercises, explanation of list/tuple differences.
Unit 3: Key-Value Pairs: Dictionaries and Sets (Weeks 8-10)
Goals: Understand dictionaries (key-value), create/access/modify items, understand sets (unique elements), learn set operations, apply dictionaries/sets for data organization/uniqueness.
Activities: Simple dictionary creation, data lookup, text analysis with dictionaries, working with sets, simple address book.
Assessment: Assignments using dictionaries/sets, problem-solving with these structures, explanation of their advantages.
Unit 4: The World of Objects: Introduction to OOP (Weeks 11-14)
Goals: Understand OOP concepts (classes, objects, attributes, methods), define classes, create objects, understand encapsulation, basic introduction to inheritance/polymorphism.
Activities: Creating simple classes (Car, Student, Animal), working with objects, implementing encapsulation, simple inheritance examples.
Assessment: Projects using classes/objects, explanation of OOP principles, designing simple class diagrams.
Unit 5: Organizing Code with Modules and Packages (Weeks 15-17)
Goals: Understand benefits of modules/packages, create/import modules, understand namespaces, introduce standard libraries (math, random), learn to install/use third-party packages (pip).
Activities: Creating/importing modules, using standard library functions, installing/using a simple package, structuring larger projects.
Assessment: Projects that demonstrate the use of modules and packages, understanding of how to import and use external code.
Unit 6: The Logic of Efficiency: Introduction to Algorithms (Weeks 18-21)
Goals: Understand algorithms, describe/analyze simple algorithms (linear, binary search - basic), introduce time complexity (Big O - intro), implement basic sorting (bubble, selection sort - basic).
Activities: Designing algorithms (pseudocode), implementing search algorithms, comparing search efficiency, implementing sorting algorithms, analyzing algorithm steps.
Assessment: Explaining the steps of basic algorithms, implementing search/sort, comparing efficiency.
Unit 7: Building the Structure: Introduction to HTML (Weeks 22-25)
Goals: Understand HTML structure, learn common tags (headings, paragraphs, lists, images, links), understand elements/attributes, create simple static web pages.
Activities: Creating basic HTML pages, experimenting with tags, structuring content semantically, basic personal portfolio page.
Assessment: Creation of functional static web pages, understanding of HTML structure/tags.
Unit 8: Styling the Web: Introduction to CSS (Weeks 26-29)
Goals: Understand CSS purpose, learn basic selectors (element, class, ID), understand fundamental CSS properties, link CSS to HTML, style previous HTML pages.
Activities: Applying CSS (inline, internal, external), styling text/backgrounds, basic layout with CSS, improving personal portfolio page.
Assessment: Styling HTML pages using CSS effectively, understanding of CSS selectors/properties.
Unit 9: Dynamic Web (Flask) and Collaborative Coding with Git (Weeks 30-32)
Goals: Understand web framework concept, basic Flask introduction, create simple web apps with routes/dynamic content, understand Git basics (commit, push, pull), collaborate on a simple project using Git.
Activities: Setting up basic Flask app, creating routes/handling requests, basic data passing to templates, introduction to Git commands, collaborative project using Git.
Assessment: Creation of basic dynamic web app (Flask), demonstration of basic Git commands, participation in collaborative project.
Resources: Python, VS Code, Git, GitHub/GitLab, Flask documentation, Official Python Docs.
Assessment: Code reviews, significant projects, written exams, Git repositories, presentations.
Differentiation: Challenging projects, advanced topics, additional support, peer teaching.
This curriculum aligns with 21st-century technological standards. Created for academic excellence and professional readiness.