A module in which knowledge becomes a published product: a web application with a database and a backend, one’s own game, and the working practices without which a serious project does not hold together: managing code in Git, debugging, testing and documenting. The Association works on software development through project-based and team work, with public presentation of finished work.
Key facts
- Age:
- Web/databases/backend: older primary-school pupils and secondary-school pupils
- Development practices: older primary-school pupils and secondary-school pupils
- Games: For younger and older primary-school pupils, and secondary-school pupils
- Focus:
- Web/databases/backend: web front-end, SQL, relational database, API, deploy
- Development practices: Git/GitHub, debugging, testing, documenting, accessibility, collaboration
- Games: game loop, physics, states, publishing a game
- Prerequisite:
- Web/databases/backend: basic programming; Development practices (Git)
- Development practices: basic programming or work on a project
- Games: none (younger pupils); basic programming (Godot)
- Ministry of Science and Education (MZO) domain: B, C
- Infokup: Software development (methodology)
- Scope: 3 sets of learning outcomes from the curriculum, 63 topics
- Progression: groups by level of knowledge, not by age
Module aims
Web, databases and backend (full-stack)
- build a web interface (HTML/CSS/JS)
- ask a question of the data (SQL)
- model a relational database
- set up a secure API and publish a full-stack service
Development practices and tools
- manage code in Git and collaborate
- debug and test systematically
- document the work for others
- work accessibly and as a team
Game development
- make a game that is playable in the browser
- use states, physics and UI
- publish a game on the web
Learning outcomes
Web, databases and backend (full-stack). The participant builds a web interface, models data in a relational database, sets up a secure API and publishes a full-stack service at a public address.
Development practices and tools. The participant manages code in a version-control system, collaborates through a pull request, and tests and documents their work.
Game development. The participant builds and publishes a playable game on the web, with a menu, a score and win/loss states.
MZO outcomes (NN 22/2018)
Outcomes are mapped to the Informatics curriculum from the Official Gazette (Narodne novine) 22/2018. Codes are unique only within a track, so the track is stated with each code (OŠ – primary school, gimn – grammar school, PMG – science and mathematics grammar school).
- Web, databases and backend (full-stack): C.7.2 (OŠ); A.3.1, A.4.1 (gimn); B.4.2.b (PMG – GUI application)
- Development practices and tools: B.8.1 (OŠ); B.2.4 (gimn); D.1.3 (gimn – accessibility)
- Game development: B.8.1 (OŠ); B.3.1, B.4.2.b (PMG)
Levels of mastery
Four levels describe what mastering the module means in practice. A participant progresses by level, not by age.
Web, databases and backend (full-stack)
- satisfactory: builds a simple page or asks an SQL question
- good: connects the front end to a database (JOIN, schema)
- very good: sets up a secure API over a database
- exceptional: publishes a full-stack service with sign-in and persistent data
Development practices and tools
- satisfactory: saves changes in Git with help
- good: manages a branch on their own and opens a pull request
- very good: debugs and writes a test for their code
- exceptional: runs a project with history, tests, documentation and accessibility
Game development
- satisfactory: makes a playable scene in Scratch/GDevelop
- good: uses a game loop, physics and states
- very good: builds a game with a menu and saving
- exceptional: publishes a polished game on the web (itch.io) + devlog
Breakdown
The breakdown is organised by sets of learning outcomes and levels of knowledge. A participant enrols at the level they have reached, regardless of age. Click a topic for an explanation of what it covers.
Web, databases and backend (full-stack)
28 topics · older primary-school pupils and secondary-school pupils
Foundation level - web front-end
HTML
the structure of a web page
CSS
the look and layout of a page
JavaScript
interactivity in the browser
the DOM and events
changing the page with code and responses to a click
responsive design
a page that works on a phone and a computer
the browser and dev tools
development tools in the browser (inspector, network)
Foundation level - databases
what data are
a datum, a record, a table – basic concepts
tables, rows, keys
how data are organised and uniquely labelled
SQLite
a small database in a single file, for practice
10 SQL questions on one’s own database
first SQL queries on one’s own data
Intermediate level - databases
SELECT/JOIN/GROUP BY
retrieval, joining tables and grouping
schema design
how to arrange tables sensibly
foreign key
a link between tables (foreign key)
normalisation
removing redundancy in a database schema
PostgreSQL
a real relational database for more serious work
a first HTTP endpoint (Express/Flask)
a first web route that returns data
Advanced level - backend
indexes
speeding up queries with indexes
transactions and ACID
reliable changes to a database (ACID)
caching
speeding up with a cache (Redis/CDN)
REST vs GraphQL
two styles of API and when to use which
authentication (JWT/sessions/OAuth)
user sign-in: tokens, sessions, OAuth
ORM
working with a database through objects in code
migrations
versioning changes to the database schema
API security
protection against misuse (SQLi, authorisation)
environment and secrets
configuration and keeping secrets (env/secrets)
testing
automated tests for the backend
CI/CD
automatic testing and publishing on every change
deploy
publishing a service at a public address
Development practices and tools
14 topics · older primary-school pupils and secondary-school pupils
Foundation level - version control
Git: init/clone
creating and cloning a code repository
commit and history
snapshots of code: add, commit, status, log
remote (push/pull)
synchronising code with GitHub (push/pull)
.gitignore
what not to save in the repository
Intermediate level - collaboration
branches and merging
parallel work with branches and merging (merge)
pull request and code review
submitting changes and reviewing someone else’s code
Git LFS (for assets)
versioning large files (images, sound, models)
resolving conflicts
merging when changes collide
Advanced level - quality
debugging (reading the error, tracing)
systematically finding the cause of an error
edge cases
boundaries and unusual inputs that break code
unit tests
automated tests of a small unit of code
TDD basics
test first, then code (test-driven development)
documenting (README)
briefly explaining to others how to use it
accessibility (a11y)
work usable by everyone (contrast, keyboard, ARIA)
Game development
21 topics · For younger and older primary-school pupils, and secondary-school pupils
Foundation level
game loop
the game loop – update, then draw, continuously
sprites and events
characters/images and responses to keys
collision
detecting collisions between objects
block logic (Scratch)
programming by snapping blocks together
GDevelop (no-code)
making a game without writing code
Intermediate level
delta-time loop
smooth movement independent of the computer’s speed
animation
animating characters (frames, transitions)
2D physics
gravity, collisions, bouncing
tilemaps
building 2D levels from tiles (tilemap)
states (state machine)
states of the game or character (idle, running, jumping)
HUD and UI
displaying points, lives and a menu
‘juice’ (the feel of a game)
screen shake, particles, tweens – a game that ‘feels’ right
sound
sound effects and music in the game
scripting (Godot/GDScript)
game logic in code in Godot
Advanced level
architecture and scenes
organising the game into scenes and components
introduction to shaders
GPU effects: vertex and fragment shaders (basics)
saving a game (persistence)
saving and loading progress and state
simple multiplayer
client/server and synchronisation (basics)
UX and polish
the player’s experience and fine finishing
publishing a game
making a build and publishing the game
itch.io / web build
publishing a game on the web (itch.io)