MicroSims and Research Communication

Summary

This chapter covers the ways research results are communicated and taught: slide decks, interactive simulations, MicroSims, embedded simulations, learning graphs, and intelligent textbooks. It introduces generating a MicroSim with an agent. After this chapter you can create an interactive simulation that illustrates a concept from your research.

Concepts Covered

This chapter covers the following 11 concepts from the learning graph:

Concept	Concept Impact Score
Research Communication	15
Slide Deck	2
Interactive Simulation	10
p5.js	10
MicroSim	9
Concept Dependency	7
Learning Graph	6
Intelligent Textbook	5
Embedding Simulations	1
Teaching From Research	2
MicroSim Generation	1

Prerequisites

This chapter builds on concepts from:

• Chapter 1: Research Workflows and the Researcher as Orchestrator
• Chapter 5: Markdown Project Files and Version Control
• Chapter 6: Knowledge Bases, Personal Knowledge Graphs, and the Anatomy of an Agent Skill
• Chapter 9: Supervising Agents and Defining Agent Roles
• Chapter 13: Simulation, Testing, and Reproducible Code
• Chapter 15: AI-Assisted Manuscript Preparation

Let Readers Turn the Knob

A figure shows one setting of a result, and a reader who can move the slider understands the whole relationship. You are looking at a book built this way: every interactive on these pages began as a written specification. By the end you will be able to write one for your own result. Trust, but verify!

Communicating Research

Research communication is the transfer of a result and its reasoning to a particular audience for a particular purpose. The same result is communicated differently to a reviewer, who wants evidence and limits, to a colleague who wants the method, to a student who wants the idea, and to a funder who wants significance. The medium follows from the audience, and agents can help with several of them.

A slide deck is the standard medium for a talk. An agent drafts a deck quickly from a paper, and the common failure is a deck that mirrors the paper's structure instead of a talk's. A talk has one message, a few supporting points, and few words per slide. Ask for the deck from a stated audience, time, and single message, and require that each slide state its point as a sentence in the title. Reuse figures from the paper's source scripts and not screenshots, and run the number check of Chapter 15 on every slide, since figures in slides are copied and changed more often than anywhere else.

A static figure shows a result at the parameter values the author chose. An interactive simulation is a program that lets the viewer change parameters and see the response, and so lets the viewer explore the relationship the result describes. It is the right medium when the point of the result is a dependence: how ENOB falls as noise rises, how leakage changes with window choice, how a search converges. It is the wrong medium for a fact that has no parameter.

MicroSims

A MicroSim is a small, single-concept, interactive simulation that runs in a web browser, is embedded in a page, has open and readable source code, and is built from a short specification. The idea, developed in the author's MicroSims project, is that a simulation small enough to specify in a page can be generated by an AI model, checked by a person, and embedded anywhere that displays web pages. This book contains many, each in its own directory under docs/sims/ with a main.html that is embedded in the chapter and an index.md lesson page.

The library most often used is p5.js, a JavaScript library for drawing and interaction in the browser. It needs no installation, runs everywhere, and has built-in controls such as sliders, buttons, and drop-downs. The rule in this book is to use the library's own controls and not to draw them by hand, since the built-in ones are accessible and consistent. Two further conventions keep sims embeddable: the first statement in setup() reads the container width so that the canvas fits the page, and the canvas is attached to the page's main element.

Before the code, here is the relationship it shows. When Gaussian noise of standard deviation \( \sigma \), measured in least-significant bits, is added to an ideal \( N \)-bit quantizer whose own quantization noise has standard deviation \( 1/\sqrt{12} \) LSB, the effective number of bits becomes

\[ \text{ENOB} = N - \tfrac{1}{2}\log_2\!\left(1 + 12\,\sigma^2\right). \]

For \( N = 10 \) and \( \sigma = 2 \) the value is 7.19 bits, the number used in Chapter 13. The sketch below draws one bar for ENOB and one for the nominal bits, and a slider changes \( \sigma \). It uses createSlider(min, max, value, step), which creates a slider with a minimum, a maximum, a starting value, and a step size.

let sigmaSlider;
let canvasWidth = 400;

function updateCanvasSize() {
  canvasWidth = document.querySelector('main').offsetWidth;
}

function setup() {
  updateCanvasSize();
  const canvas = createCanvas(canvasWidth, 220);
  canvas.parent(document.querySelector('main'));
  sigmaSlider = createSlider(0, 4, 1, 0.25);   // noise in LSB
  sigmaSlider.parent(document.querySelector('main'));
}

function draw() {
  background('aliceblue');
  const sigma = sigmaSlider.value();
  const enob = 10 - 0.5 * Math.log2(1 + 12 * sigma * sigma);
  const scale = (canvasWidth - 40) / 10;             // pixels per bit
  fill('lightgray'); rect(20, 40, 10 * scale, 40);   // nominal 10 bits
  fill('steelblue'); rect(20, 110, enob * scale, 40);
  fill(0); noStroke();
  text('Nominal: 10 bits', 20, 30);
  text('ENOB: ' + enob.toFixed(2) + ' bits at sigma = ' + sigma + ' LSB', 20, 100);
}

Slide the control to 0 and the bar reaches about 10 bits; slide it to 2 and it falls to about 7.2. A reader who has seen this does not need the formula explained. The same sketch, with labels and a lesson page, is a complete MicroSim.

The Interactive Is the Result in Motion

Notice that the sketch has no data in it, only the relationship. A paper's table gives you the points the authors measured, and a sim gives you the function that the points came from. That is why a good MicroSim teaches in a minute what a page of text takes ten to explain.

Generating a MicroSim With an Agent

MicroSim generation is the use of an agent to build a MicroSim from a specification. The workflow of this book is specification first. A specification states what the learner must be able to do afterward, the evidence that shows it, the full content, the rules the model must obey, the activity, and the feedback. It deliberately leaves out layout and code, which the generating agent decides. You have already seen the form: each interactive in the chapters of this book has such a specification in a collapsed block above it, with a Bloom level and verb, an objective, evidence of mastery, content, rules, learner activity, feedback, and chapter anchors.

The workflow has five steps, and the checks matter more than the generation.

1. Specify. Write the objective with one verb, the evidence of mastery, and every item of content with its correct answer. If you cannot write the evidence, the sim has no purpose yet.
2. Search before building. Look for an existing MicroSim that already teaches the concept. Reuse is cheaper than generation.
3. Generate. Give the specification to the agent, with the conventions above. Ask for the code in the standard directory layout.
4. Verify. Run it. Check each rule in the specification against the behavior: the formulas, the thresholds, the feedback texts, the boundary cases. A sim that looks right and computes a slightly wrong number is the worst outcome, and the checks of Chapter 13 apply.
5. Approve. A person tests the controls and decides that it is ready for learners. In this repository a lesson page carries a status value that shows in the navigation: scaffold for a specification with no implementation, built for an implementation awaiting review, instrumented for one that records learner events, and approved for one the author has tested. Agents may set the first three. Only the human author sets approved.

Write the Evidence of Mastery First

Before you describe the sim, write one sentence that begins "The learner shows they understand by...". If the sentence names something the sim can check, such as a number entered, a prediction committed, or an item sorted, you have the spine of the activity. If it says "explores", the sim will be a toy.

The following reused MicroSim, from the author's instructional design project, supports the first step of the workflow. It matches each of the six levels of Bloom's taxonomy to the kind of interaction that fits it, which is the guidance behind the "Bloom level" and "verb" lines of every specification in this book.

Diagram: Bloom's Taxonomy MicroSim Matcher

Run the Bloom's Taxonomy MicroSim Matcher fullscreen

Bloom's Taxonomy MicroSim Matcher (reused MicroSim)

Type: microsim sim-id: blooms-microsim-matcher
Library: p5.js
Status: Reused
Source: https://dmccreary.github.io/infographics/sims/blooms-microsim-matcher/
Source Repo: https://github.com/dmccreary/infographics/tree/main/docs/sims/blooms-microsim-matcher
Bloom Level: Understand
Bloom Verb: classify
Learning Objective: The learner will classify each Bloom's taxonomy level with the kind of MicroSim interaction pattern that suits it.

Reused from the MicroSim catalog (WHAT match score 0.85).

The five-step workflow has a prerequisite that is easy to overlook: the sim must be the right medium. The following specification practices the judgment of when a MicroSim earns its place.

Diagram: MicroSim Suitability Judge

MicroSim Suitability Judge

Type: microsim sim-id: microsim-suitability-judge
Library: p5.js
Status: Built
Bloom Level: Evaluate
Bloom Verb: judge
Learning Objective: The learner will judge, for each of eight pieces of research content, whether an interactive MicroSim or a static figure or text is the better medium, with at least 7 of 8 correct.

Prerequisites: interactive simulation, MicroSim, and the criterion that a MicroSim suits a dependence or process the learner can manipulate or predict, all defined in the sections "Communicating Research" and "MicroSims" above.

Evidence of Mastery: For each of eight items the learner commits "MicroSim" or "static figure or text". A judgment is correct when it equals the answer in Content. Mastery is at least 7 of 8 correct on the first attempt. Reading the criterion is exploration and is not evidence.

Misconceptions: (1) Interactive is always better than static. (2) Any technical content should become a simulation. (3) A table of values is equivalent to a sim of the function.

Instructional Rationale: Evaluate-level work needs the learner to apply a criterion and decline to build when the criterion is not met, which saves the effort of building sims that add nothing.

Content:

All items are invented for illustration and labeled "illustrative". The criterion shown is: "A MicroSim suits content with a parameter the learner can change, or a process the learner can step through or predict, where seeing the response builds understanding."

#	Content	Correct medium	Why (shown as feedback)
1	How the ENOB of an ADC falls as added noise increases.	MicroSim	It is a dependence on a parameter, and moving the noise slider shows the relationship.
2	A die photograph of the fabricated converter.	Static figure or text	It is a single image with no parameter or process.
3	How a successive-approximation search converges, bit by bit, to the digital code of an input voltage.	MicroSim	It is a process the learner can step through and predict.
4	The bill of materials for the test board.	Static figure or text	It is a reference table with no parameter or process.
5	How the choice of window changes spectral leakage when the signal frequency moves away from an exact FFT bin.	MicroSim	It is a dependence on two parameters, and the response is visual.
6	The author list and affiliations of the paper.	Static figure or text	It is a fact with no parameter or process.
7	The derivation of the Walden figure of merit from its definition.	Static figure or text	It is a short derivation with no parameter, and text with an equation serves it.
8	How the spread of residual offset across devices changes as the number of calibration bits increases.	MicroSim	It is a dependence on a parameter, and the distribution changes visibly.

Provenance: The criterion is from the sections "Communicating Research" and "MicroSims" of this chapter. The items are invented for illustration.

Rules: An item is a MicroSim when it has a parameter the learner can change, or a process the learner can step through or predict, and the response aids understanding. Otherwise it is static figure or text. Each item has exactly one correct answer.

Learner Activity:

1. The learner reads item 1 and the criterion.
2. The learner chooses "MicroSim" or "static figure or text" and submits.
3. The sim shows whether it was correct and the "Why" sentence, naming the parameter or process where there is one.
4. After item 8, the sim shows the count correct.

Feedback: Eight items, one attempt each, in a fixed order. Correct: "Correct." plus the "Why" sentence. Incorrect: "The better medium is ." plus the "Why" sentence. The correct answer is always revealed after the single attempt. A final score "n of 8 correct" is shown with whether the mastery threshold of 7 was met.

Starting State: Item 1 is shown with two choices. The question on screen is "Would a learner understand this better by changing something?"

Chapter Anchors: The chapter states that an interactive simulation is the right medium when the point of the result is a dependence, and the wrong medium for a fact that has no parameter.

MicroSim: MicroSim Suitability Judge. Open it fullscreen.

Embedding, Concept Dependencies, and Intelligent Textbooks

Embedding simulations is placing a MicroSim in a page, normally with an HTML iframe element that points at the sim's main.html. An iframe isolates the sim from the page, which is also a safety property: the sim's code cannot reach the rest of the page. The chapter pages of this book embed their sims with a relative path such as ../../sims/<sim-id>/main.html and add a link to open the sim fullscreen. The same sim can be embedded in a slide deck, a course page, or a paper's supplementary website without change. When you cite a sim in a paper, give its published address, and include the repository name in the address so that it can be found.

A concept dependency is the relation that one concept must be understood before another can be. A learning graph is a directed acyclic graph of concepts in which each edge is a concept dependency. It is the structure that decides the order of a course and, with the chapter's concept impact scores, how much space each concept deserves. This book is organized by one, and its chapters are the groupings of the graph's concepts in dependency order. The reused sim below lets you explore a graph of concept dependencies, including the difference between hard prerequisites and supporting ones.

Diagram: Concept Dependencies Graph

Run the Concept Dependencies Graph MicroSim fullscreen

Concept Dependencies Graph (reused MicroSim)

Type: graph-model sim-id: concept-dependencies
Library: vis-network
Status: Reused
Source: https://dmccreary.github.io/automating-instructional-design/sims/concept-dependencies/
Source Repo: https://github.com/dmccreary/automating-instructional-design/tree/main/docs/sims/concept-dependencies
Bloom Level: Understand
Bloom Verb: interpret
Learning Objective: The learner will interpret a directed acyclic graph of concept dependencies, distinguishing hard prerequisites from supporting ones and tracing upstream and downstream concepts.

Reused from the MicroSim catalog (WHAT match score 0.86).

An intelligent textbook is a textbook whose content is interactive and, at higher levels, responsive to the reader. The author's classification of intelligent textbooks distinguishes five levels: static text (level 1), interactive content with MicroSims and learning graphs (level 2), adaptive content driven by student goals and progress (level 3), conversational tutoring (level 4), and autonomous generation of personalized instruction (level 5). This book sits at level 2, and it is organized so that the skills and records needed for level 3 could be added. Level 3 and above require storing student records, which raises privacy questions that the classification flags as a threshold.

Teaching from research is turning a result into instruction. The procedure follows the structure of this chapter. Choose one concept from your paper that a newcomer needs. Write the objective and the evidence of mastery. Check the catalog for an existing sim. Specify the one you need, build and verify it, and write a short lesson page that states the prerequisite, the activity, and what the learner should notice. The same sim then serves your talk, your group's onboarding, and your supplementary materials, and a result that others can manipulate is a result that others can build on.

Summary and Key Takeaways

Communicating a result well is choosing the medium that matches the point. When the point is a dependence, an interactive that lets the reader move the parameter does what a static figure cannot, and an agent can build it quickly from a precise specification that you check.

The main points to carry forward:

• Research communication is shaped by the audience. A slide deck carries one message and needs a number check.
• An interactive simulation suits a dependence or a process, and not a fact.
• A MicroSim is small, single-concept, embeddable, and readable. p5.js with built-in controls is the usual library.
• MicroSim generation is specification first: evidence of mastery, content, and rules, then search, generate, verify, and approve. Only a human marks a sim approved.
• Embedding is an iframe with a relative path, and the sim is reusable across decks, pages, and papers.
• Concept dependencies and learning graphs order a course, and intelligent textbooks range from static to autonomous, with student data privacy rising at the adaptive level.
• Teaching from research turns one concept of a paper into an objective, a sim, and a lesson page.

From a Result to a Lesson

You can now say when a result deserves a simulation, read a p5.js sketch that shows a dependence, and write the specification, evidence, and checks from which an agent builds one. That gives a result a form that others can handle, not only read.

The next chapter returns to the question that runs under all of these: how do you know an AI-assisted result is right. Round up one result you are about to rely on, and bring it.

See Annotated References