Source-linked AI summary
Learnable Programming: Blocks and Beyond
David Bau, Jeff Gray, Caitlin Kelleher, Josh Sheldon, Franklyn Turbak
TL;DR
Introductory programming still faces barriers in vocabulary, syntax, cognitive load, and error-prone code assembly, motivating better learnability for novices. The paper reviews evidence and design mechanisms for blocks-based programming, finding that blocks support learning and have become widely useful across introductory contexts. It also identifies boundaries involving reuse robustness, mode switching, editing constraints, and the need for further empirical design work.
Problem
Novices face barriers from programming vocabulary, syntax, cognitive load, and assembling code, while research continues to examine how blocks affect learnability and transition to text.
Method
The paper synthesizes studies of blocks-based learning and analyzes interface features, applications, and tools that shape learnability.
Results
Blocks address major learnability problems by favoring recognition, chunking code, and preventing basic assembly errors, and research indicates they can improve later textual-language learning.
Takeaways & Limitations
Blocks-based programming has broad introductory adoption and can support novice learning across programming contexts, while continued work targets further barriers, transitions, and domains.
Takeaways & Limitations
Further empirical work is needed to design languages and libraries for learnability, and blocks approaches face tradeoffs in reuse robustness and editing constraints.
Abstract
from arXiv · showhide
Blocks-based programming has become the lingua franca for introductory coding. Studies have found that experience with blocks-based programming can help beginners learn more traditional text-based languages. We explore how blocks environments improve learnability for novices by 1) favoring recognition over recall, 2) reducing cognitive load, and 3) preventing errors. Increased usability of blocks programming has led to widespread adoption within introductory programming contexts across a range of ages. Ongoing work explores further reducing barriers to programming, supporting novice programmers in expanding their programming skills, and transitioning to textual programming. New blocks frameworks are making it easier to access a variety of APIs through blocks environments, opening the doors to a greater diversity of programming domains and supporting greater experimentation for novices and professionals alike.
1. INTRODUCTION
Blocks-based programming has rapidly expanded as an introductory programming medium. The article examines how blocks affect learnability, reviews evidence, discusses design features, and considers new domains and block-language tools.
- Millions of students encounter programming first through blocks-based tools used in courses and activities such as Code.org’s Hour of Code.Blocks let beginners compose programs without struggling with syntax.
- Blocks and Beyond grew from a small VL/HCC 2015 workshop into an event with 51 submissions and 36 presenters.Presentations covered new blocks languages, interface innovations, domain-specific applications, and accessibility.
- The article reviews studies of blocks-language effectiveness, explains how blocks support learning, and examines applications and tools for creating blocks languages.
2. DO BLOCKS LANGUAGES WORK?
Studies report that blocks-based introductions can support later learning of textual programming, while transitions and outcomes depend on instructional design and context. The paper also frames programming education as serving both professional expertise and broader creative goals.
- Blocks-based programming may support either professional programming expertise or accomplishing other goals through programming, and those endpoints are not necessarily the same.Scratch is described as sufficient for users who treat programming as a medium for expression rather than a career path.
- Blocks-based programming can help novices learn traditional textual languages, with reported gains in learning speed, loop understanding, engagement, confidence, grades, and continued study.One college study reported a GPA of 3.0 versus 1.2 and further-course participation of 88% versus 47% after Alice.
- Students who used Alice before Java averaged 10% or more better performance on every section of the same Java final exam.The sections included expression evaluation, control structures, arrays, and class definitions.
- The Alice-to-Java transfer study used Java-generating Alice blocks and pedagogy that explicitly connected concepts across the two languages.
- Switching from blocks to text can create learning challenges because it involves changes in both syntax and semantics.Some proposed instruction teaches syntax before generalizing semantics.
- Many introductory courses now use a blocks-before-text progression, including transitions from Scratch, Snap!, App Inventor, or Droplet to textual languages.
3. WHY BLOCKS ARE LEARNABLE
Blocks support learnability by addressing vocabulary, cognitive-load, and assembly barriers. Their interfaces favor recognition, chunk code into meaningful structures, and constrain construction to prevent basic errors.
- Blocks address three barriers to assembling programs: selecting concepts, using code under high cognitive load, and coordinating code without basic errors.
- 3.1 Recognition versus Recall: Palettes favor recognition over recall by organizing programming concepts by function and keeping them available for discovery and exploration.Unlike autocomplete menus, palettes persist and organize concepts by topic rather than name.
- Constrained direct manipulation prevents basic assembly errors because incompatible concepts do not have connecting parts.
- 3.1 Recognition versus Recall: Blocks reduce vocabulary and operand-selection difficulty through palettes, default values, drop-down menus, specialized editors, and explanatory words.Scratch has about 130 blocks, while simple languages or libraries often involve roughly 100-200 words.
- 3.2 Chunking Information with Blocks: Textual syntax can overwhelm beginners because a JavaScript for loop contains 17 separate information units, exceeding the roughly seven chunks associated with working memory.
- 3.2 Chunking Information with Blocks: Blocks teach novices to read common code patterns as larger chunks, such as a for loop’s conventional pattern plus its upper bound.Code.org initially presents the loop as two chunks and later reveals finer-grained structure.
- 3.2 Chunking Information with Blocks: Blocks improve readability by replacing punctuation and delimiter-dependent notation with visible structure and plain explanatory words.This helps beginners concentrate on code meaning rather than the notation used to write it.
3.3 Direct Manipulation of Visible Structure
Blocks make program structure visible while constraining how code fragments can be assembled. Their shapes expose grammatical distinctions and support experimentation with isolated code fragments.
- Direct manipulation: Visual constraints make the grammar of a program visible during direct manipulation.Blocks function as syntax-directed editing rather than unconstrained text entry.
- Direct manipulation: Scratch uses vertical connections for commands and matching holes for expressions, preventing incompatible structures from connecting.Commands use nubs and notches, while expressions fit into smooth holes; a Boolean expression can fill a loop condition.
- Direct manipulation: Students report that puzzle-like block shapes help them assemble programs.
- Direct manipulation: Richer type systems can be represented through distinct connector shapes, including 14 shapes in OpenBlocks.
- Direct manipulation: Blocks support bottom-up tinkering by letting programmers build isolated code fragments and execute them interactively in live environments.These fragments can be connected into islands of code separate from the main program and run by pointing and clicking.
3.4 Learnability Beyond Blocks
Learnability depends on more than block construction: novices also face practical, conceptual, semantic, and pattern-learning hurdles. Environments can address these barriers through online access, discoverable vocabulary, visible state, examples, and evidence-based language design.
- Learnability beyond blocks: Blocks alone do not make a programming language learnable; novices must also manage tools, vocabulary, runtime semantics, and common usage patterns.
- Practical support: Online environments simplify installation and provide a more complete, consistent programming setup with fewer potential problems.
- Words and concepts: Familiar words such as “repeat” and “unequal” are more learnable than jargon such as “for” and “!=” in empirical studies.
- Words and concepts: Designing intuitive abstractions, such as Alice’s object-relative motions, can make domain-specific programming concepts easier to use.
- Open research: Evidence-based design of learnable languages and libraries remains a major area for future work.
- Runtime understanding: Visible program state and live updates help learners connect code, actions, and changes over time.Code.org highlights the active block, while App Inventor, Scratch, and Snap! apply many edits immediately.
- Examples and reuse: Shared examples support novice learning, but simple reuse can reduce robustness when reused code is not guaranteed to work in a new project.Scratch’s backpack simplifies collecting and dragging snippets, whereas Looking Glass uses execution history to help ensure contextual functionality.
4. SCALING BLOCKS CODE
Blocks improve learnability but introduce efficiency and scalability challenges as programs grow. New editors combine text-like editing with block structure or switch between linked text and block views, each with distinct tradeoffs.
- Scaling blocks code: Direct manipulation makes small expression edits slower because programmers must find, drag, and rearrange multiple blocks.This higher viscosity is a usability disadvantage compared with editing equivalent text.
- Scaling blocks code: Blocks environments can suffer from low screen density, difficult navigation, and weak support for source control.
- Scaling blocks code: New tools address the tension between blocks and text through text-style entry or bidirectional mode switching.
- Text-style entry: Stride and GP provide inline autocomplete so experienced users can insert blocks by typing instead of searching palettes.
- Text-style entry: Stride combines text editing for expression-level code with visible block structure for higher-level control flow and declarations.
- Bidirectional mode switching: Bidirectional editors link traditional text languages and block representations so users can learn syntax in blocks and gain text-editing efficiency.Examples include Pencil Code, App Lab, BlockEditor, and Tiled Grace.
- Bidirectional mode switching: Because text is the primary representation in dual-mode editors, syntax errors can appear and complex errors may prevent switching back to blocks.Error-recovery heuristics handle simple errors by converting them into special error blocks.
- Comparing approaches: Dual-mode editors support learning traditional syntax but add cognitive overhead from syntax errors and switching between views.Single-mode structured editors avoid syntax errors but can raise editing viscosity by restricting textual edits.
5. APPLYING BLOCKS: TWO EXAMPLES
Blocks-based languages extend programming into unfamiliar domains by simplifying 3D modeling and RDF querying. Their shallow learning curve, live feedback, and draggable query results support exploration and iterative refinement.
- 3D Printing: BeetleBlocks and Madeup bring 3D-printing programming to novices through web-based interfaces, live 3D rendering, and blocks languages.Both systems simplify learning while supporting custom 3D modeling code.
- 3D Printing: Both 3D-printing languages have a very shallow learning curve, making it easy for users to try either system.
- Querying the Semantic Web: SPARQL users must learn specialized vocabulary and syntax while also understanding RDF instance and schema data.These two hurdles make querying large semantic-web datasets a learnability challenge.
- Querying the Semantic Web: The SPARQL Playground uses blocks for selecting, filtering, and joining data with SPARQL primitives.
- Querying the Semantic Web: The Playground returns query results as draggable blocks, allowing users to save discovered instance data and refine queries iteratively.Users can begin with general queries, inspect available data, and incorporate discoveries into new queries.
6. MAKING NEW BLOCKS LANGUAGES
Several toolkits support creating domain-specific blocks environments, each with different implementation trade-offs. OpenBlocks offers geometric customization, Blockly removes installation barriers, and Droplet supports block–text transformation.
- Toolkit Options: Blockly, Droplet, and OpenBlocks are toolkits for creating domain-specific blocks environments.
- OpenBlocks: OpenBlocks provides substantial geometric customization but requires users to download and install the Java JDK.
- Blockly: Blockly addresses installation challenges through an HTML-based toolkit and powers applications including App Inventor, the SPARQL Playground, MadeUp, and Code.org puzzles.
- Droplet: Droplet is a newer, less mature toolkit whose distinctive approach enables seamless bidirectional transformation between blocks and textual code.
7. SUMMARY
Learnable programming environments should reduce barriers for novice and casual programmers through recognition, lower cognitive load, visible structure, direct manipulation, and accessible tooling. Blocks demonstrate progress toward these goals, while programming usability remains an unresolved challenge.
- Design Goals: Programming tools for novice users should make examples easy to find and apply while focusing their design on learnability.
- Design Goals: Blocks support recognition over recall by presenting vocabulary through selectable blocks rather than requiring users to remember words.
- Design Goals: Blocks lower cognitive load by chunking code into meaningful elements.
- Design Goals: Visible grammar and types, directly manipulable program chunks, and low-viscosity editing make program structure easier to work with.
- Design Goals: Learnable tools should avoid installation requirements, use clear high-level abstractions, and expose runtime state and behavior.
- Conclusion: Blocks have addressed many usability problems and made programming more learnable, but programming remains an unsolved usability challenge.
Blocks-Based Educational Tools
Blocks-based educational tools span animation, games, simulations, mobile creation, Android apps, and web applications. The examples include both pioneering environments and newer platforms aimed at different ages and devices.
- Desktop and Web Tools: Scratch, Code.org, Snap!, App Inventor, and Pencil Code provide blocks-based tools for animation, games, puzzles, Android apps, and web applications.
- Games and Simulations: AgentSheets, AgentCubes, Alice, Looking Glass, and Kodu support rule-based games, simulations, 3D virtual worlds, animated stories, and game programming.
- Mobile Tools: Scratch Jr, Pocket Code, Tynker, and Hopscotch extend blocks programming to preliterate children, mobile devices, and game or animation creation.