Back Matter — Complete Reference

Supplementary reference material for Accessible 3D Printing with OpenSCAD and 3dMake. These sections are designed for lookup rather than linear reading — consult them as needed throughout the curriculum.

Section	Title	Purpose
Technical Reference and Troubleshooting	Systems architecture, CLI reference, and fault-by-fault troubleshooting compendium	Diagnose and resolve errors in OpenSCAD, 3dMake, CMD, PowerShell, Git Bash, slicers, and printers
Student Glossary	Terms, definitions, and code examples across all curriculum systems	Look up any term encountered in lessons, with syntax examples for each shell
Teacher Glossary	Pedagogical frameworks, instructional strategies, and assessment rubrics	Instructors: curriculum design, scaffolding, computational thinking, and cross-curricular connections
Further Reading and References	Scholarly works, official documentation, industry resources, and community links	Continue learning; cite sources; find community support

Technical Reference and Troubleshooting Guide

PART I — SYSTEMS ARCHITECTURE

1.1 Digital Fabrication Pipeline

Source (.scad)
    ↓
OpenSCAD Engine
    ↓
STL (Mesh Geometry)
    ↓
Slicer
    ↓
G-code
    ↓
FDM Printer Firmware
    ↓
Physical Object

Automation Overlay:

CLI -> Script -> Build Directory -> Version Control -> Reproducible Artifact

PART II — OPENSCAD PROFESSIONAL MODELING REFERENCE

2.1 Language Architecture

OpenSCAD is:

Declarative
CSG-based
Deterministic
Single-pass evaluation
Non-interactive

Implication: Models must be architected intentionally.

2.2 Advanced Geometry Techniques

2.2.1 Transform Stack Order

Transformations apply from inside outward.

translate([10,0,0])
    rotate([0,0,45])
        cube(10);

Order matters.

2.2.2 Hull()

Creates convex hull of objects.

hull() {
    translate([0,0,0]) sphere(5);
    translate([20,0,0]) sphere(5);
}

2.2.3 Minkowski()

Expands object by shape kernel.

minkowski() {
    cube([10,10,10]);
    sphere(1);
}

Warning: Computationally expensive.

2.2.4 Linear and Rotational Extrusion

linear_extrude(height=10)
    square(5);

rotate_extrude()
    translate([10,0,0])
        circle(5);

2.2.5 Projection

projection(cut=true)
    sphere(10);

2.3 CLI Operation of OpenSCAD

Render STL (All shells)

openscad -o output.stl input.scad

Specify Variables via CLI

openscad -D width=50 -o model.stl model.scad

PART III — 3DMAKE PROFESSIONAL USAGE

3.1 3dMake Overview

3dMake automates model generation and batch workflows.

Core capabilities:

Batch STL generation
File processing pipelines
Integration with OpenSCAD CLI
Script-driven builds

Repository: https://github.com/tdeck/3dmake

3.2 Example Automated Pipeline (PowerShell)

New-Item -ItemType Directory -Force build
openscad -D width=40 -o build/model.stl src/model.scad
if ($LASTEXITCODE -ne 0) { exit 1 }

3.3 Batch Processing (cmd.exe)

for %%f in (src\*.scad) do openscad -o build\%%~nf.stl %%f

3.4 Batch Processing (Git Bash)

for f in src/*.scad; do
  openscad -o build/$(basename "$f" .scad).stl "$f"
done

PART IV — WINDOWS COMMAND PROMPT (CMD.EXE) FULL REFERENCE

4.1 cmd Architecture

Text-based
Legacy DOS-compatible syntax
String-based (not object-based)

Executable:

C:\Windows\System32\cmd.exe

4.2 File System Operations

List Files

dir

Change Directory

cd builds

Create Directory

mkdir build

Remove Directory

rmdir /s /q build

4.3 Running Programs

openscad.exe -o model.stl model.scad

4.4 PATH Inspection

echo %PATH%

4.5 Temporary Environment Variables

set MYVAR=value

4.6 Exit Codes

echo %ERRORLEVEL%

Conditional:

if %ERRORLEVEL% NEQ 0 echo Build failed

4.7 Batch Files (.bat)

Example build.bat:

@echo off
mkdir build
openscad -o build\model.stl src\model.scad
if %ERRORLEVEL% NEQ 0 exit /b 1

PART V — POWERSHELL PROFESSIONAL REFERENCE

5.1 Architecture

Object-based pipeline
.NET-backed
Strong scripting support

5.2 Execution Policy

Get-ExecutionPolicy
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

5.3 Structured Error Handling

try {
    openscad -o model.stl model.scad
}
catch {
    Write-Host "Failure"
}

PART VI — GIT BASH (UNIX-LIKE SHELL)

6.1 POSIX-Compatible Commands

ls
pwd
mkdir
rm -rf build

6.2 Shell Variables

VAR=value
echo $VAR

PART VII — ADVANCED TROUBLESHOOTING COMPENDIUM

A. OpenSCAD Failures

A.1 Segmentation Fault

Cause:

Deep Minkowski
Memory exhaustion

Fix:

Reduce $fn
Simplify geometry

A.2 Empty STL Output

Cause:

Geometry evaluates to null

Diagnosis: Add temporary primitive to confirm render pipeline.

A.3 Boolean Artifacts

Cause:

Coplanar faces

Fix:

Add small offsets (0.01mm)

A.4 Syntax Errors

Missing Semicolons

Cause:

cube([10,10,10])  // Missing semicolon

Fix:

cube([10,10,10]);

Unmatched Brackets

Common errors:

{ } curly brackets
[ ] square brackets
( ) parentheses

Diagnosis: Check error line number in console.

Comment Syntax Errors

Invalid multiline comment:

/* Comment
// Still in comment
*/

Single-line comments use // Multiline comments use /* */

A.5 Logical Operator Errors

&& (AND) Usage

if (x > 5 && y < 10) {
    cube([10,10,10]);
}

|| (OR) Usage

if (x > 5 || y < 10) {
    cube([10,10,10]);
}

Missing parentheses can cause evaluation errors.

A.6 $fn Performance Issues

Cause:

Excessive fragment count

Example:

$fn = 500;  // Too high
sphere(5);

Fix:

$fn = 50;   // Sufficient for most cases
sphere(5);

B. 3dMake Failures

B.1 Command Not Found

Verify:

where openscad

Or check 3dm:

where 3dm

B.2 Silent Failure

Check exit code:

echo %ERRORLEVEL%

B.3 3dm build Failures

Common causes:

Source file not found
Syntax errors in .scad
OpenSCAD not in PATH

Diagnosis:

3dm build --verbose

B.4 3dm info Not Working

Requirements:

Valid STL file
Network connection (for AI service)

Check:

3dm info

If info works but describe doesn’t, check network.

C. Command Line Lesson Specific Failures

C.1 “Access is denied”

Cause:

Insufficient privileges

Fix: Run as Administrator.

C.2 Incorrect Variable Expansion in Loop

In batch files use:

%%f

In interactive shell use:

%f

D. PowerShell-Specific Failures

D.1 Script Not Running

Fix:

Set-ExecutionPolicy RemoteSigned

D.2 Command Returns But File Not Created

Check:

Test-Path build\model.stl

E. Git Bash Issues

E.1 Windows Path Confusion

Use forward slashes:

openscad -o build/model.stl src/model.scad

F. 3D Printing Mechanical Failures

F.1 Warping

Solutions:

Increase bed temp
Use enclosure
Add brim

F.2 Under-Extrusion

Cause:

Clogged nozzle
Incorrect flow rate

F.3 Dimensional Error

Test with calibration cube.

G. Performance Diagnostics

G.1 Slow Render

Reduce:

$fn
Minkowski usage
Nested difference()

G.2 High CPU Usage

Expected during full render.

G.3 For Loop Performance

Inefficient:

for (i = [0:1000]) {
    translate([i, 0, 0])
        minkowski() { ... }  // Very slow
}

Better:

for (i = [0:100]) {  // Reduce iterations
    translate([i, 0, 0])
        hull() { ... }   // Faster than minkowski
}

G.4 Hull vs Minkowski Performance

hull() — Fast for convex shapes
minkowski() — Slow but precise

Use hull() when possible.

H. SYSTEM DIAGNOSTIC CHECKLIST

Is OpenSCAD in PATH?
Does CLI produce STL?
Is STL manifold?
Does slicer preview correctly?
Is G-code generated?
Does printer firmware accept G-code?
Is first layer adhering?
Are dimensions within tolerance?
Are all brackets matched?
Are comments properly closed?
Is $fn set reasonably?
Are transform operations in correct order?

J. EDITOR AND IDE TROUBLESHOOTING

J.1 VS Code OpenSCAD Extension Issues

Symptom:

No syntax highlighting

Fix:

Install “OpenSCAD” extension
Restart VS Code
Check file extension is .scad

J.2 Notepad++ Syntax Highlighting

Setup:

Settings > Style Configurator
Select Language: C or C++
Apply to .scad files

J.3 Indentation Issues

Mixed tabs/spaces:

Fix:

Convert tabs to spaces
Set indent to 4 spaces

NVDA with VS Code

Settings:

Enable “Editor > Accessibility: Support”
Set “Editor > Render Whitespace”: “all”

Indent Announcement

NVDA:

Document Formatting > Report line indentation

JAWS:

Settings Center > Reading > Report Indentation

K. SLICER-SPECIFIC TROUBLESHOOTING

K.1 PrusaSlicer Import Failures

Symptom:

STL won’t load

Causes:

Non-manifold geometry
File corruption
Incorrect file path

Fix:

openscad -o model.stl model.scad --check

K.2 Cura Slicing Errors

Common:

Model outside build volume
Unsupported overhangs

Fix:

Scale model down
Enable supports

K.3 Bambu Studio Issues

Plate adhesion:

Clean build plate
Increase bed temperature
Add brim/raft

L. MATERIAL-SPECIFIC FAILURES

L.1 PLA Printing Issues

Stringing

Fix:

Enable retraction
Lower temperature by 5-10°C

Warping

Rare with PLA
Add brim if occurs

L.2 PETG Challenges

Stringing

Common with PETG.

Fix:

Increase retraction distance
Lower temperature

Bed Adhesion

Too good — may damage bed.

Use:

Glue stick as release agent

L.3 TPU (Flexible) Problems

Under-extrusion

Cause:

Too fast print speed

Fix:

Reduce to 20-30 mm/s

Stringing

Minimal retraction:

Set to 1-2mm only

L.4 ABS Warping

Major challenge.

Required:

Heated enclosure
100°C+ bed temp
Large brim

M. MEASUREMENT AND QA FAILURES

M.1 Caliper Measurement Errors

Over-tightening

Cause:

Pressing too hard

Result:

Part deforms
Inaccurate reading

Fix:

Use gentle pressure

M.2 Tolerance Stack-up Issues

Multiple parts don’t fit.

Analysis:

Part A: +0.15mm error
Part B: +0.12mm error
Total: +0.27mm

Fix:

Adjust design tolerances
Print test pieces first

M.3 Dimensional Accuracy Check

Print calibration cube:

cube([20,20,20]);

Measure all dimensions. Expected: 20.00 ± 0.2mm

I. FULL BUILD VALIDATION SCRIPT (CMD)

@echo off
echo Validating environment...
where openscad >nul 2>nul
if %ERRORLEVEL% NEQ 0 (
    echo OpenSCAD not found.
    exit /b 1
)

mkdir build
openscad -o build\model.stl src\model.scad
if %ERRORLEVEL% NEQ 0 (
    echo Build failed.
    exit /b 1
)

echo Build succeeded.

N. TEXT EMBOSSING TROUBLESHOOTING

N.1 Font Not Found

Symptom:

WARNING: No match for font family

Cause:

Font name incorrect
Font not installed

Fix:

Windows (PowerShell):

[System.Drawing.Text.InstalledFontCollection]::new().Families | Select-Object Name

Linux:

fc-list | grep -i "font name"

N.2 Text Not Visible

Cause:

Forgot linear_extrude()

Wrong:

text("HELLO");

Correct:

linear_extrude(height=2)
    text("HELLO");

N.3 Text Size Too Large/Small

Cause:

Size parameter is cap height in mm

Fix:

text("HELLO", size=8);  // 8mm tall letters

O. TRANSFORM OPERATION ERRORS

O.1 Transform Order Confusion

Transforms apply inside-out.

Example:

translate([10,0,0])    // Applied SECOND
    rotate([0,0,45])    // Applied FIRST
        cube([10,10,10]);

Order matters!

O.2 Rotate Angles Wrong

Angles in degrees, not radians.

rotate([0, 0, 45]);  // 45 degrees

O.3 Scale Issues

scale([2, 1, 1])  // 2x wider only
    cube([10,10,10]);

Result: 20×10×10 cube

O.4 Mirror Confusion

Mirror plane:

mirror([1, 0, 0])  // Mirror across YZ plane
    cube([10,10,10]);

P. IMPORT AND EXPORT ERRORS

P.1 Import STL Failed

Cause:

File path incorrect
File corrupted

Fix:

import("path/to/file.stl");

Use forward slashes even on Windows.

P.2 Export Failed

Check:

Write permissions
Sufficient disk space
Valid file path

Q. RANDOMIZATION ISSUES

Q.1 rands() Not Random

Cause:

Same seed produces same output

vals = rands(0, 100, 10, 42);  // Seed = 42

Change seed for different results.

Q.2 Random Position Overlap

Objects placed randomly may overlap.

Need collision detection logic.

Student Glossary — OpenSCAD • 3dMake • 3D Printing • PowerShell • Command Prompt • Git Bash

OpenSCAD • 3dMake • 3D Printing • PowerShell • Command Prompt • Git Bash

This glossary provides:

Formal definitions
Operational context
Cross-system distinctions
CLI examples
Practical implications in 3D printing workflows

SECTION I — Additive Manufacturing & Fabrication

Additive Manufacturing

A manufacturing methodology in which objects are fabricated layer-by-layer from digital models.
In desktop contexts, this typically refers to FDM (Fused Deposition Modeling).

Technical Characteristics

Layer-based deposition
Toolpath-generated geometry
STL-to-G-code workflow
Thermoplastic extrusion (in FDM)

Workflow Position

OpenSCAD -> STL -> Slicer -> G-code -> Printer -> Physical object

FDM (Fused Deposition Modeling)

A thermoplastic extrusion process in which filament is melted and deposited in sequential layers.

Critical Variables

Nozzle temperature
Bed temperature
Layer height
Print speed
Cooling rate

Layer Height

The vertical thickness of each printed layer.

Smaller values increase surface fidelity.
Larger values increase speed.

Example:

0.2 mm = standard
0.1 mm = high resolution

Infill

Internal structural lattice inside a model.

Typical values:

10–20% for visual models
40%+ for structural parts

Material Properties

PLA (Polylactic Acid)

Easy to print
Low warping
Biodegradable
Not heat-resistant

PETG

Stronger than PLA
Chemical resistant
Slight flexibility

TPU (Thermoplastic Polyurethane)

Flexible
Rubber-like
Requires slow printing

ABS (Acrylonitrile Butadiene Styrene)

Strong and durable
Higher temperature
Requires enclosure
Prone to warping

Tolerance

Intentional dimensional offset to ensure mechanical fit.

Example: A 10mm peg may require a 10.2mm hole for clearance.

Manifold (Watertight Model)

A printable model with:

No self-intersections
No zero-thickness faces
No holes in mesh

Non-manifold geometry causes slicer failure.

SECTION II — OpenSCAD (Parametric Modeling)

OpenSCAD

A script-based solid modeling system using Constructive Solid Geometry (CSG).

Official site: https://openscad.org

Constructive Solid Geometry (CSG)

Modeling technique combining primitives using Boolean operations.

Primitive

Basic geometric object.

Examples:

cube([10,10,10]);
sphere(5);
cylinder(h=20, d=10);

Cone

A tapered cylinder created using different top and bottom diameters.

cylinder(h=20, d1=10, d2=0);

2D Shapes

Flat geometry that can be extruded to 3D.

Examples:

square([10,10]);
circle(5);
polygon([[0,0], [10,0], [5,10]]);

Polygon

Custom 2D shape defined by vertices.

polygon(points=[[0,0], [10,0], [10,10], [0,10]]);

Text Commands

Create text geometry for embossing or debossing.

linear_extrude(height=2)
    text("HELLO", size=10, font="Liberation Sans");

Boolean Operations

union()

Combines shapes.

union() {
    cube([10,10,10]);
    sphere(6);
}

difference()

Subtracts shapes.

difference() {
    cube([20,20,20]);
    cylinder(h=25, d=5);
}

intersection()

Keeps overlapping geometry.

intersection() {
    sphere(10);
    cube([15,15,15], center=true);
}

Transform Operations

Translate

Move geometry in 3D space.

translate([10, 20, 30])
    cube([10,10,10]);

Rotate

Rotate geometry around axes.

rotate([0, 0, 45])
    cube([10,10,10]);

Scale

Resize geometry by multiplier.

scale([2, 1, 1])
    cube([10,10,10]);

Mirror

Flip geometry across a plane.

mirror([1, 0, 0])
    cube([10,10,10]);

Advanced Operations

Hull

Creates convex hull of children objects.

hull() {
    sphere(5);
    translate([20,0,0]) sphere(5);
}

Minkowski Sum

Expands geometry by rolling one shape around another.

minkowski() {
    cube([10,10,10]);
    sphere(2, $fn=12);
}

Warning: Computationally expensive.

Linear Extrude

Extends 2D shapes into 3D.

linear_extrude(height=10)
    square([10,10]);

Offset

Expands or contracts 2D shapes.

offset(r=2)
    square([10,10]);

Variable

A named parameter used to control geometry.

width = 30;
cube([width,10,5]);

Parametric Design

Geometry controlled by variables.

Advantages:

Rapid iteration
Reusability
Scalable models

Module

Reusable geometry block.

module peg(d, h) {
    cylinder(d=d, h=h);
}

peg(5, 20);

Control Structures

For Loop

Repeat operations.

for (i = [0:5]) {
    translate([i*15, 0, 0])
        cube([10,10,10]);
}

If Statement

Conditional execution.

if (width > 20) {
    cube([width, 10, 10]);
}

Else and ElseIf

Extended conditionals.

if (width > 20) {
    cube([width, 10, 10]);
} else if (width > 10) {
    cylinder(h=10, d=width);
} else {
    sphere(width/2);
}

Echo Function

Print debug information to console.

width = 30;
echo("Width is:", width);

Random Numbers

Generate random values.

rands(min, max, count, seed);

// Example:
positions = rands(0, 100, 5);

Import

Load external STL or other files.

import("model.stl");

$fn (Fragment Number)

Controls circular resolution.

$fn = 100;
sphere(10);

Higher values increase smoothness and render time.

# (Hash Mark - Debug Modifier)

Highlights geometry in transparent red during preview.

#cube([10,10,10]);

Used for debugging geometry positions.

Comments

Non-executable text for documentation.

Single-line Comments

// This is a comment
cube([10,10,10]);

Multiline Comments

/*
  This is a
  multiline comment
*/
cube([10,10,10]);

Logical Operators

&& (And)

Logical AND operator.

if (x > 5 && y < 10) {
    cube([10,10,10]);
}

|| (Or)

Logical OR operator.

if (x > 5 || y < 10) {
    cube([10,10,10]);
}

Brackets and Delimiters

[ ] (Square Brackets)

Used for vectors and arrays.

position = [10, 20, 30];
cube([10,10,10]);

{ } (Curly Brackets)

Define code blocks.

if (x > 5) {
    cube([10,10,10]);
}

< > (Angle Brackets)

Used in some operations and comparisons.

if (x < 10 && y > 5) { }

Preview vs Render

F5 = Preview (OpenGL approximation)
F6 = Render (full CSG evaluation)

CLI equivalent:

openscad -o model.stl model.scad

SECTION III — 3dMake (Automation Tool)

3dMake

A command-line tool for automating 3D model generation and processing.

Repository: https://github.com/tdeck/3dmake

3dm build

Command to generate STL from OpenSCAD source.

3dm build

Outputs to build/ directory.

3dm info

AI-powered geometric description for non-visual validation.

3dm info --view front

Headless Rendering

Running OpenSCAD without GUI.

openscad -o output.stl input.scad

Automated Build Pipeline

Example PowerShell pipeline:

openscad -o model.stl model.scad

Example Bash:

openscad -o model.stl model.scad

SECTION IV — Command-Line Systems

CLI (Command-Line Interface)

A text-based interface for interacting with the operating system.

Shell

A program that interprets commands.

Examples:

PowerShell
Command Prompt
Git Bash

PowerShell

Object-oriented Windows shell.

List Files

Get-ChildItem

Change Directory

Set-Location Documents

Run Script

.\build.ps1

Check Exit Code

$LASTEXITCODE

Command Prompt (cmd.exe)

Traditional Windows shell.

List Files

dir

Change Directory

cd Documents

Run Program

openscad.exe -o model.stl model.scad

Check Exit Code

echo %ERRORLEVEL%

Git Bash

Unix-like shell for Windows.

List Files

ls

Change Directory

cd Documents

Make Directory

mkdir builds

Working Directory

The directory in which commands execute.

Print Working Directory

pwd

Get-Location

PATH (Environment Variable)

Tells system where executables are located.

View PATH (PowerShell)

$env:PATH

View PATH (cmd)

echo %PATH%

Environment Variable

A system-level configuration variable.

Set Temporarily (PowerShell)

$env:TESTVAR="hello"

Set Temporarily (cmd)

set TESTVAR=hello

Exit Code

Numeric status returned by command.

0 = Success
Non-zero = Error

Example:

if ($LASTEXITCODE -ne 0) { Write-Host "Build Failed" }

if [ $? -ne 0 ]; then echo "Build Failed"; fi

Pipe

Pass output from one command to another.

Get-ChildItem | Select-String ".scad"

ls | grep ".scad"

SECTION V — Git & Version Control

Git

Distributed version control system.

Repository

Tracked project folder.

git init

Commit

Snapshot of changes.

git add .
git commit -m "Initial model"

Branch

Parallel development path.

git branch feature-peg
git checkout feature-peg

Clone

Download remote repository.

git clone https://github.com/user/project.git

Status

Check changes.

git status

SECTION VI — File Formats

STL

Triangle mesh file used in 3D printing.

Generated by:

openscad -o model.stl model.scad

Slicer Software

Converts STL to G-code.

PrusaSlicer

Open-source slicer with advanced features.

Cura

User-friendly slicer by Ultimaker.

Bambu Studio

Slicer for Bambu Lab printers.

G-code

Machine instructions generated by slicer.

Example fragment:

G1 X10 Y10 Z0.2 F1500

SECTION VII — Automation Concepts

Script

File containing executable instructions.

Examples:

.ps1
.sh
.scad

Debugging

Process of finding and fixing errors in code.

Techniques:

Use echo() statements
Use # modifier to highlight geometry
Test modules independently
Check console for warnings

Reproducibility

Ability to regenerate identical outputs from identical inputs.

Automation

Using scripts instead of manual steps.

Example build script (PowerShell):

openscad -o build/model.stl src/model.scad

SECTION VIII — Accessibility & Documentation

Markdown

Lightweight markup language.

Example:

# Heading
- Bullet

Semantic Structure

Proper heading hierarchy:

# Title
## Section
### Subsection

Important for screen readers.

Editor Setup

VS Code

Recommended extensions:

OpenSCAD Language Support
Bracket Pair Colorizer

Notepad++

Lightweight editor with syntax highlighting.

Configure:

Settings > Preferences > Language
Select OpenSCAD or C-style syntax

Indentation

Proper code formatting for readability.

module example() {
    if (condition) {
        cube([10,10,10]);
    }
}

Use consistent spacing (2 or 4 spaces per level).

Software that reads text aloud.

Examples:

NVDA
JAWS
Orca
VoiceOver

SECTION IX — Mechanical Design Concepts

Clearance Fit

Loose fit allowing movement.

Press Fit

Tight fit requiring force.

Overhang

Unsupported geometry exceeding safe angle (≈45° for FDM).

Tolerance

Intentional dimensional offset for mechanical fit.

Example:

Designed hole: 10.2mm
Designed peg: 10.0mm
Clearance: 0.2mm

Calipers

Precision measurement tool for verifying printed dimensions.

Types:

Digital calipers (recommended)
Vernier calipers

Accuracy: ±0.01mm typical

SECTION X — Advanced Workflow Concepts

Headless CI Build

Automated rendering using scripts or CI tools.

openscad -o output.stl model.scad

Deterministic Modeling

Same input -> same output every time.

OpenSCAD is deterministic.

Dependency

External program required for workflow.

Example:

OpenSCAD must be in PATH.

Teacher Glossary — Pedagogical Concepts for 3D Design and Computational Thinking Instruction

Pedagogical Concepts for 3D Design & Computational Thinking Instruction

This glossary provides instructors with:

Pedagogical frameworks
Teaching strategies
Assessment concepts
Accessibility guidance
Curriculum design principles

SECTION I — Computational Thinking Framework

Computational Thinking

Problem-solving approach using concepts fundamental to computer science.

Core pillars:

Decomposition — Breaking problems into smaller parts
Pattern Recognition — Identifying similarities
Abstraction — Focusing on relevant details
Algorithms — Creating step-by-step solutions

Application in OpenSCAD: Students decompose complex models into primitive shapes, recognize geometric patterns, abstract parameters, and write algorithmic module definitions.

Decomposition

Breaking a complex problem into manageable sub-problems.

In 3D Design Context

Example: A phone stand is decomposed into:

Base plate
Support angle
Lip to hold phone
Optional cable slot

Each component becomes a separate module.

Abstraction

Removing unnecessary details to focus on essential features.

In Parametric Design

module bolt(diameter, length) {
    // Abstract "bolt" concept
    // Hide implementation details
}

Students learn to identify which details matter and which can be parameterized.

Pattern Recognition

Identifying repeating structures or concepts.

Examples in OpenSCAD

Repeated geometric elements (array of holes)
Similar transformation sequences
Common parameter relationships

Algorithms

Step-by-step procedures for solving problems.

In Code

// Algorithm for creating gear teeth
for (i = [0:teeth-1]) {
    rotate([0, 0, i * 360/teeth])
        translate([radius, 0, 0])
            tooth_profile();
}

SECTION II — Instructional Design Strategies

Walking Skeleton Approach

Agile development practice: build minimal working version first, then iterate.

In 3D Design Curriculum

Create basic cube
Add one parameter
Add one transformation
Build and verify
Repeat

Prevents overwhelming students with complexity.

Design Cycle

Iterative process:

Define -> Ideate -> Prototype -> Test -> Refine -> Repeat

In 3dMake Context

Edit .scad -> 3dm build -> 3dm info -> Measure print -> Adjust parameters

Scaffolding

Temporary support structures that enable learning.

Examples:

Starter code templates
Pre-defined modules
Graduated exercises
Checklists

Remove scaffolding as competency increases.

Physical Computing

Learning that connects digital design to physical artifacts.

3D printing provides immediate tangible feedback:

Code -> STL -> Physical object
Reinforces cause-and-effect
Engages kinesthetic learners

Stakeholder-Centric Design

Designing with end-user needs in focus.

Teaching Application

Have students:

Interview stakeholders
Define requirements
Create design constraints
Iterate based on feedback

Example: Design assistive device for specific user needs.

SECTION III — Assessment & Validation

Code Review Criteria

Assess student code on:

Functionality — Does it work?
Parametrization — Are values abstracted?
Documentation — Are comments clear?
Modularity — Is code reusable?
Efficiency — Is approach optimal?

Quality Assurance

Systematic verification process.

For 3D Prints

Measure with calipers
Compare to specification
Document deviations
Adjust parameters
Retest

Teaches scientific method and iterative refinement.

Safety Protocols

3D Printing Safety

Required instruction:

Ventilation requirements
Hot surface warnings
Electrical safety
Material handling (MSDS)
Emergency shutdown procedures

SECTION IV — Accessibility & Universal Design

Ensure all students can access curriculum.

Key Principles

Semantic HTML/Markdown — Proper heading structure
Alt text for images — Describe geometric concepts
CLI-first workflows — Reduce GUI dependence
Descriptive output — 3dm info provides text descriptions

Braille Display Setup

For students using refreshable braille displays:

Ensure code editors support screen readers
Use semantic indentation (not tabs)
Provide geometric descriptions in text
Test commands with NVDA/JAWS

CLI navigation (pwd, ls, cd)
Text editor setup (VS Code with extensions)
3dm build command
3dm info for validation
Caliper measurement techniques (tactile)

Editor Setup for Accessibility

VS Code

Recommended extensions:

Screen Reader Optimized
Bracket Pair Colorizer (announces nesting)
OpenSCAD Language Support

Notepad++

Lightweight alternative:

Configure indentation announcement
Enable line number reading
Set up hotkeys for navigation

SECTION V — Technical Teaching Concepts

Parametric Architecture

Design philosophy where dimensions are variables, not fixed values.

Why Teach This

Promotes computational thinking
Enables design reuse
Teaches variable scope
Reinforces algebra concepts

Geometric Primitives

Basic 3D shapes that combine to form complex objects.

Teaching Sequence

Cube
Sphere
Cylinder (including cones)
Boolean operations
Transformations
Compound models

Tolerance Management

Critical mechanical engineering concept.

Teaching Approach

Print test parts
Measure with calipers
Calculate error
Adjust tolerance parameters
Reprint and verify

Teaches:

Precision vs accuracy
Measurement techniques
Iterative refinement

Interlocking Features

Mechanical joints and assemblies.

Examples:

Snap fits
Press fits
Sliding joints
Threaded connections

Requires understanding of:

Clearance tolerances
Material properties
Force analysis

SECTION VI — Curriculum Design Elements

Design Mode vs Print Mode

OpenSCAD workflows:

Design Mode (F5) — Fast preview
Print Mode (F6) — Full render for STL export

Teach distinction early to avoid confusion.

Editor Window vs Preview Window

OpenSCAD interface:

Left: Code editor
Right: 3D preview

Non-visual students use editor + CLI tools instead of preview.

File Format Progression

Teach file types in order:

.scad — Source code
.stl — 3D mesh
.gcode — Machine instructions

Each represents different abstraction level.

Debugging Strategies

Systematic approaches to finding errors.

For Students

Read error messages carefully
Use echo() to print values
Test modules independently
Use # modifier to highlight geometry
Simplify to minimal failing case

SECTION VII — Cross-Curricular Connections

Mathematics Integration

3D design reinforces:

Coordinate geometry (X, Y, Z axes)
Trigonometry (rotation angles)
Algebra (parametric equations)
Measurement & units

Physics Applications

Center of mass calculations
Material properties (stress, strain)
Thermal expansion
Friction coefficients

Engineering Design Process

Professional workflow:

Define problem
Research requirements
Brainstorm solutions
Build prototype
Test and evaluate
Refine design

3D printing makes this tangible.

SECTION VIII — Slicing & Print Management

Slicing Guides for Instruction

PrusaSlicer

Recommended teaching slicer:

Visual layer preview
Built-in supports
Print time estimates

Cura

Alternative:

Simpler interface
Good for beginners

Bambu Studio

For Bambu Lab printers:

Automated features
Multi-color support

Material Selection Pedagogy

PLA

Start here:

Easiest to print
Lowest temperature
Minimal warping

PETG

Intermediate:

Stronger
More forgiving than ABS

TPU

Advanced:

Flexible prints
Requires special techniques

ABS

Advanced:

Professional applications
Requires enclosure
Warping challenges teach troubleshooting

SECTION IX — Language & Syntax Teaching

Code Statement

Single executable instruction.

cube([10,10,10]);  // One statement

Comments as Documentation

Teach commenting best practices:

Explain why, not what
Document parameters
Include units
Note constraints

Arithmetic in Code

Reinforce math concepts:

width = 10;
spacing = width * 1.5;  // Arithmetic

SECTION X — Assessment Rubrics

Parametric Design Rubric

Criterion	Novice	Developing	Proficient	Advanced
Parameterization	Hard-coded values	Some parameters	Most values parameterized	Full parametric architecture
Documentation	No comments	Minimal comments	Clear parameter docs	Comprehensive documentation
Modularity	No modules	Basic modules	Reusable modules	Library-quality modules
Functionality	Doesn’t build	Builds with errors	Meets requirements	Exceeds requirements