How far can we push ScratchJr? #codingchallenge

ScratchJr Background & Positioning (2014)

The speaker argues that ScratchJr, originally created for ages ~5–7, ends up being far more powerful than its initial goal. They claim it can function as a replacement for common productivity tools—referenced via subtitles including Word, PowerPoint, Excel, Photoshop, and more—and suggest that schools/companies using Microsoft Office should switch to it (as the speaker’s opinion).

“How far can we push ScratchJr?” Premise

ScratchJr is treated as a constrained programming environment where key features from full programming languages were “dropped.” The language core is essentially reduced to:

• Movement, plus hide/show, and shrink/grow
• Speech (e.g., “say stuff”)
• A repeat command (treated as non-fundamental because it can be emulated)
• Triggers/events that control when code runs:
  • on flag
  • on touch
  • on click
  • on message
  • message blocks to route execution

Core Insight: Events as Control Flow / Conditionals

The speaker’s key realization is that on touch (collision) events can behave like conditionals:

• If a collision occurs with another sprite → one message is triggered
• If time passes with no collisions → another message is triggered

From this, they brainstorm how to emulate a Turing machine using ScratchJr’s message passing and sprite interactions.

Turing Machine / “Infinite Abacus” Emulation Attempt

What a Turing machine is (as described)

A Turing machine is a computational model where:

• a tape holds values,
• and instructions update those values over time.

The speaker argues that if ScratchJr can emulate a Turing machine, then it can compute anything.

Simplifying to a two-instruction model

They pivot from a more complex idea (a tape of variables plus a moving pointer) to a simpler concept: a two-instruction “infinite abacus” model attributed to Minsky and another collaborator (unclear in the subtitles). The core instructions are:

• Increment a cell
• Decrement a cell if > 0, otherwise jump to another instruction

Implementation Strategy in ScratchJr

System architecture

The implementation uses:

• One “control” sprite
• Multiple variable sprites (each representing a “cell”)

How execution control works

Control is transferred through message blocks. The approach is roughly:

• Sprite movement tied to collisions causes variables to effectively decrement.
• When a value goes below zero, the program:
  • resets positions, and
  • “routes” execution to different message blocks

This creates a minimal control-flow system. The speaker notes it can be done “by hand,” but becomes impractical as complexity grows.

Tooling: Python Wrapper That Outputs ScratchJr JSON

To automate creation, the speaker builds a Python 3 project that generates ScratchJr programs automatically.

They explain that ScratchJr files are JSON stored in a local SQL database, so rather than editing files directly, the wrapper generates the correct JSON.

Object model (from subtitles)

• Project class: container for pages
• Page class: contains sprites
• Sprite class: supports coordinates, texture, size, and custom parameters
• Scripts: represented as a list of script elements created by name + parameters

Demo project behavior

A demo generator asks for:

• Project name
• Sprite name + what it should say
• How many times it should say it

Then it prints and compiles the final JSON for ScratchJr.

Compiler for the “Infinite Abacus” Language

The speaker adds an “actual compiler” that translates a custom program into ScratchJr sprite scripts.

The custom instruction set supports:

• Increment cells by arbitrary integers
• Conditionally decrement
• Go to / jump
• Reset cells
• Print predefined text
• Get input
• Halt when the file ends

Parsing is described as being done via matched case statements, which then instantiate sprites and scripts to execute the program.

Demo Programs Shown

1. “Hello World” repetition

   • The user inputs a number.
   • ScratchJr repeats “hello world” that many times.

2. Square numbers generator

   • Outputs square numbers in order.
   • The subtitles note a cap on sprite movement speed, so the video is sped up for viewing.

How the Square-Number Program Works (High-Level Reasoning)

The program avoids explicit math by using a property of odd numbers:

• Square numbers can be generated by repeatedly adding consecutive odd numbers.

The speaker describes a manual “multi-digit” method:

• Maintain the square number across digits, stored as separate registers/digits
• Handle rollover/carry when digit sums overflow

They also describe the design as using function-like control flow:

• A “print digit” routine is controlled by a register variable that indicates where to return
• Execution jumps between routines using this register-driven routing

A flowchart is referenced, and the accompanying material provides variable names.

Conclusion / Meta

The speaker frames the project as mostly a “cool / useless” programming challenge (taking three months), but the main takeaway is that ScratchJr can perform surprisingly complex computation.

They mention:

• a Discord link
• and that the code is provided.

Main Speakers / Sources (as Implied)

• The video creator/speaker who built the Python wrapper and Infinite Abacus compiler, and demonstrated the ScratchJr projects.
• Historical references: Marvin Minsky and an additional collaborator (unclear in the subtitles) connected to the two-instruction infinite abacus concept.