About Course

This summer camp is designed to introduce students to the world of programming through two popular languages: Scratch and Python. Over the course of four weeks, students will learn the fundamentals of programming concepts such as loops, variables, conditionals, and functions while transitioning from Scratch to Python. By the end of the camp, students will have the skills to create animations, games, and solve basic programming problems.

Day 1: Introduction to Scratch & AI Concepts

• Understanding Scratch: Overview of the Scratch interface, sprites, and blocks.
• Introduction to AI & Machine Learning: Simple explanation of AI with examples.
• Project 1: Create Your Own Emoji – Drawing tools, expressions, and user interaction.

Day 2: Voice Assistants & Chatbots

• Understanding AI-powered assistants like Alexa & Siri.
• Project 2: Create Your Own Alexa – Text-to-speech and speech recognition.
• Project 3: Create Your Own Chatbot – Responses using variables and conditionals.

Day 3: Image Processing & Sorting with AI

• How AI categorizes images and recognizes content.
• Project 4: Sorting the Pictures – Using AI-based extensions to classify images.
• Project 5: Automatic Image Sorter System – Building an advanced classifier.

Day 4: Games with AI & Decision-Making

• Understanding AI decision-making in interactive scenarios.
• Project 6: Is the Glass Half Empty or Half Full? – Perception and choices.
• Project 7: Detective for Investigating Genre – AI-powered genre prediction.

Day 5: Classic Game Development

• Introduction to Scratch game mechanics.
• Project 8: Pac-Man Game – Maze design and enemy AI.
• Project 9: Bug Shooter Game – Target shooting with AI-driven patterns.

Day 6: AI-Driven Navigation & Smart Systems

• Exploring AI in real-world navigation and logistics.
• Project 10: School Journey – AI-based decision mapping.
• Project 11: Easy Travel with Your Own Chatbot – Route planning assistant.

Day 7: Advanced AI & Game Mechanics

• Diving into AI-driven automation and gameplay dynamics.
• Project 12: Postal Sorting Office – AI-powered mail sorting system.
• Project 13: Escape from Zombie – Survival game with AI-controlled enemies.

Day 8: Secret Codes, Spy Missions & Final Showcase

• Project 14: Create Your Own Spy – Message decoding and concealment.
• Project 15: Control an Alien by Your Secretive Language – AI-based text recognition.
• Final Showcase: Students present their AI projects and reflect on what they’ve learned.

What Will You Learn?

• Understand Scratch’s interface and use it to create interactive projects.
• Integrate beginner-friendly AI tools within Scratch for hands-on learning.
• Build fun projects like chatbots, voice assistants, and image classifiers.
• Control sprite movement, animations, and respond to user interactions.
• Learn core machine learning concepts like decision-making and classification.
• Practice debugging and refining code for smoother project performance.
• Enhance creativity by customizing visuals, sounds, and logic flows.
• Apply logical thinking and problem-solving strategies in every project.
• Work collaboratively and share feedback during development.
• Present a final AI-powered project with a personal, creative twist.

About Course

This course provides an engaging introduction to programming, data science, and AI through Python and PyTorch. Students will explore fundamental programming concepts, visualize data, work on real-world mini projects, and delve into object detection and chatbot development using industry-standard tools. The hands-on nature of the course encourages creativity, experimentation, and collaboration, preparing students for deeper learning in AI and machine learning.

Class 1: Python Basics & Introduction to PyTorch

• Variables, data types, and simple operations
• Conditional statements (if, else)
• Loops (for, while)
• Functions (definition, parameters, return)
• Lists and basic data structures
• Introduction to PyTorch tensors
• Creating and manipulating tensors
• Playground setup: Google Colab or Jupyter Notebooks

Class 2: Practicing with Loops, Functions + Mini Project Prep

• Recap and deeper practice with loops and functions
• Using PyTorch to generate random tensors and apply basic operations
• Mini Project: Simulate a Dice Rolling Game
• Track stats (e.g., average rolls, frequency)
• Create a modular structure using functions
• Encourage creative extensions (e.g., multi-dice simulation)

Class 3: Data Visualization Basics

• Introduction to Matplotlib and Seaborn
• Types of graphs: Line plot, Bar chart, Histogram, Pie chart
• Plotting datasets (e.g., temperature, test scores)
• Aesthetic customization (titles, labels, legends, colors)

Class 4: Real-World Visualizations + Final Project Discussion

• Applications: COVID-19 daily cases, students’ performance, expenses
• Brief intro to interactivity using Plotly
• Project: Create a Dashboard of Your Day
• Collect 1-day time usage data (sleep, study, screen time, etc.)
• Visualize it with pie charts, bar graphs
• Optional: Compare multiple days, integrate basic PyTorch stats

Class 5: Concept of Object Detection + MMDetection Setup

• What is object detection?
• Introduction to MMDetection framework
• Using pretrained models (YOLO, Faster R-CNN)
• Installation and setup (Colab/Runtime notes)
• Loading an image and detecting objects
• Visualizing detection results with bounding boxes

Class 6: Real-World Applications of Object Detection

• Applications: Security, traffic signs, custom use cases
• Project: Object Detector for Everyday Items
• Upload your own room image
• Detect known objects and present findings
• Discuss limitations (e.g., model size, accuracy)

Class 7: Chatbots & Conversational AI

• Introduction to Chatbots: Rule-based vs AI-powered
• Using transformer-based models (e.g., DialoGPT or GPT-2)
• Build a chatbot for basic queries
• Explore model inference using Hugging Face Transformers
• Limitations and ethical considerations

Class 8: Project + RAG Discussion

• Project: Build Your Own Chatbot
• Answer FAQ-style questions using trained context
• Introduction to Retrieval-Augmented Generation (RAG)
• Understand how RAG uses external data to enhance responses
• Real-world examples (e.g., chatbots with document support)

What Will You Learn?

• Writing Python programs using variables, conditionals, loops, and functions
• Creating and manipulating tensors with PyTorch
• Building simulations like dice games using randomness
• Visualizing data with Matplotlib and Seaborn
• Understanding object detection and applying pretrained models
• Using AI in everyday scenarios like book or traffic sign detection
• Building and customizing chatbots with GPT-2
• Understanding Retrieval-Augmented Generation (RAG)
• Developing a solid foundation in programming, data visualization, AI, and ethical tech

About Course

This course introduces fundamental concepts in logic, mathematics, and simulations using tools like GeoGebra and graph theory. Students will engage in visual learning and proof-building activities that connect mathematical reasoning with real-world applications. Each class is designed to blend theoretical concepts with interactive tools and experiments, culminating in a final project that demonstrates students’ understanding of logical and motion-based systems.

Day 1: Class 1 – Propositional Logic & Visual Proofs

• Propositions, Connectors, Truth Tables
• Quantifiers (Universal, Existential)
• Visual Proofs (Summations, Algebraic & Geometric Proofs)
• Expansion Formulas: (a+b)², (a−b)²
• Assignment 1: Propositional Logic & Truth Tables

Day 2: Class 2 – Implications & Proof by Contraposition

• Propositional Functions, Implications, Truth Tables
• Proofs (Evens, Odds, Contraposition)
• Visual Proofs (Summations of Series)
• Assignment 2: Proofs with Contraposition & Implications

Day 3: Class 3 – GeoGebra & Proof by Contradiction

• Intro to GeoGebra (Shapes, Graphs, Equations)
• Visual Proofs with GeoGebra
• Proof by Contradiction (Primes are Infinite)
• Assignment 3: Visual Proofs in GeoGebra

Day 4: Class 4 – Counting, Combinations & Pigeonhole Principle

• Konigsberg Bridge Problem
• Counting Rules (Product, Sum, Division, Subtraction)
• Pigeonhole Principle (Cake Slice Problem)
• Biology of Fingerprints & DNA
• Assignment 4: Applications of Counting Rules

Day 5: Class 5 – Graphs & Adjacency Matrices

• Euler’s Graphs, Edges, Vertices, Degree
• Adjacency Matrix/List, Social Networks as Graphs
• Unidirectional & Directional Graphs (Facebook/Twitter)
• Assignment 5: Graph Representation

Day 6: Class 6 – GeoGebra: Graphing & Transformations

• Graphing Functions & Shapes
• Graph Transformations (Shifts, Scaling)
• 1D & 2D Motion, Translating Curves
• Assignment 6: Graphing in GeoGebra

Day 7: Class 7 – Circular, Elliptical & Free-Fall Motion

• Vectors, Velocity, Acceleration
• Free Fall, Circular & Elliptical Motion
• Assignment 7: Simulating Motion in GeoGebra

Day 8: Class 8 – Newton’s Cannonball Experiment & Final Project

• Planetary Motion, Newton’s Cannonball
• Simulating Free Fall, Centripetal Force
• Final Project: Mathematical Proof or Motion Simulation in GeoGebra

What Will You Learn?

• Understanding basic principles of motion, including horizontal and vertical movement.
• Simulating simple motion scenarios using GeoGebra to visualize speed and trajectory.
• Exploring the effects of gravity on falling objects and dispelling common misconceptions.
• Analyzing free fall motion and graphing velocity and displacement over time.
• Mastering depth-first search (DFS) and breadth-first search (BFS) algorithms for pathfinding and problem solving.
• Simulating and optimizing projectile motion, exploring how velocity affects flight time and path.
• Studying Newton’s cannonball experiment and the concept of orbital motion around a spherical Earth.
• Learning logical reasoning and proof techniques, including direct proof and proof by contradiction.
• Understanding graph theory concepts, including vertices, edges, and directed acyclic graphs (DAGs).
• Combining horizontal and vertical motion to understand projectile trajectories.

About Course

This beginner-friendly course offers an exciting journey into Unity game development, combining theoretical concepts and hands-on projects. Starting with a gentle introduction to programming through Scratch, learners will transition and deep-dive into object-oriented programming (OOP) concepts in Unity. The course then progresses to creating increasingly sophisticated games, including a 2D platformer hack-and-slash, a 3D ball runner, and a 3D kart racing game.

Week 1: Game Development Basics with Scratch

• Introduction to Scratch Programming
• Understanding the Scratch interface.
• Creating simple animations and interactive stories.
• Introduction to logic: loops, conditions, and events.
• Game Mechanics in Scratch
• Designing player-controlled characters.
• Implementing basic enemy behaviors and scoring systems.
• Creating a complete mini-game.
• Transitioning to Unity
• Comparing Scratch blocks with C# code.
• Introduction to game design paradigms.

Week 2: Developing a 2D Platformer Hack-and-Slash Game

• 2D Level Design
• Designing platforms and obstacles.
• Building a cohesive game environment.
• Player and Enemy Mechanics
• Implementing player movement and attack combos.
• Designing enemy AI with health and attack patterns.
• Animation and Visual Effects
• Sprites animation (combat, jumping, running).
• Adding visual effects for attacks and damage.

Week 3: Developing a 3D Ball Runner in Unity

• 3D Environment Creation
• Designing a game level with planes and obstacles.
• Integrating 3D assets and materials.
• Game Mechanics
• Applying Rigidbody, colliders, and forces.
• Implementing collision detection and dynamic obstacles.
• Level Progression
• Level design strategies.
• Scaling difficulty as the player progresses.

Week 4: Developing a 3D Kart Racing Game

• Kart Mechanics and Controls
• Programming acceleration, braking, turning, and drifting.
• Tuning physics for responsive and fun gameplay.
• Environment and Track Design
• Creating a racetrack with checkpoints and obstacles.
• Applying 3D assets, lighting, and materials for visual appeal.
• Gameplay Features
• Adding power-ups (e.g. speed boosts, traps).
• Developing AI opponents for single-player racing.
• Implementing lap tracking and race timers.
• Final Polish and Presentation
• UI enhancements and camera work.
• Playtesting, debugging, and balancing.
• Presenting and showcasing the completed game.

What Will You Learn?

• Implementing classic games like Space Invader, Pac-Man, and Angry Bird in Scratch and Unity.
• Understanding the fundamentals of game development from beginner to intermediate levels.
• Exploring the Scratch interface, including sprites, instructions, and attributes.
• Learning Scratch blocks and adding scripts for motion, sensing, events, controls, and variables.
• Demonstrating motion patterns on sprites, such as circular, spiral, square, and triangular motion.
• Planning and developing a Space Shooter game with custom sprites and controls.
• Creating bullet sprites, implementing firing methods, and managing bullet positions and motion.
• Implementing enemy spaceship sprites with motion behavior, hiding, and scoring systems.
• Designing and creating custom backdrops for game scenes and transitions.
• Generalizing game mechanics through cloning and enhancing features like firing multiple bullets and animating enemy sprites.
• Managing bullet and enemy sprite interactions, including hiding, delaying, and deleting clones.
• Adding sound effects, creating a controller sprite for game management, and handling lives and game over features.
• Implementing moving background sprites with scrolling effects and continuity management.
• Introducing Pac-Man in Scratch, including game rules, sprites, and maze backdrop.
• Creating start screens, generating coins, and managing Pac-Man character sprite movement.
• Implementing ghost character movements, variable usage in blocks, and scripting level controllers.
• Introduction to Unity game engine, player ball management, and script implementation for gravity and velocity.
• Building player rotation and movement scripts, scene management, and reloading scenes.
• Creating generalized games using prefabs for object management, upgrades, and investments.
• Making Angry Bird in Unity, including player setup, spring addition, scripting, and enemy creation.
• Designing 3D environments for FPS shooter games using ProBuilder, including ground, walls, and stairs.
• Adding player movement and gravity management, along with jump factors and ground checks.
• Integrating assets, like guns and targets, into Unity scenes, and implementing firing and damage mechanics.
• Developing 3D hypercasual games, including player character animation, clone creation, particle systems, and bonus implementation.