Scribba
It seems like computer science notes should be typed. The subject is code, after all. But spend a week in a data structures or algorithms class and you'll notice that most of what matters goes on the whiteboard as pictures: a tree being rebalanced, pointers moving through a linked list, a graph being searched node by node. Typing doesn't capture that well. Handwriting does.
This guide covers how to take CS lecture notes that help you understand the ideas, not just copy the code. First, a clear note on what Scribba is.
Scribba is a notebook, not a code editor
Scribba is a handwriting app for class notes. It's not a code editor or an IDE. It doesn't run, compile, check or highlight code. Write and test your real code in the tools your course uses. Use your notes for the thinking around the code: diagrams, traces, pseudocode and the reasons behind each design choice.
That split works well. The code lives in your editor. The understanding lives in your notes.
Draw the data structure, every time
CS professors explain most ideas by drawing state and showing how it changes. Your notes should do the same.
- Linked lists: boxes for nodes, arrows for pointers. Show the list before and after an insert or delete.
- Trees: circles for nodes, straight lines for edges. Redraw after each rotation or insertion, rather than erasing.
- Graphs: circles and edges, with weights written on the edges. Number nodes as a search visits them.
- Memory diagrams: a column for the stack, a region for the heap, and arrows from variables to the objects they point to.
- Flowcharts and state machines: rectangles for steps, diamonds for decisions, circles for states and labeled arrows for transitions.
Tip: draw a sequence of small "snapshots" across the page instead of one diagram you keep changing. Snapshots show each step of the algorithm, which is exactly what exam questions ask you to trace.
Snapped shapes keep diagrams clean
In Scribba, hold the Apple Pencil still at the end of a stroke and it snaps into a straight line, arrow, circle, ellipse, triangle, rectangle or polygon. That covers almost every CS diagram: rectangles for nodes and stack frames, circles for tree and graph nodes, arrows for pointers and edges. If you're drawing a big diagram, switch to the Shape tool and every stroke snaps. For a flowchart decision diamond, draw four short lines; each one snaps straight.
Pick paper with a light grid
Dot grid is a good default for CS. The dots help you line up tree levels and table columns without visual clutter. Grid or graph (mm) paper suits memory layouts, arrays, truth tables and anything with cells. For wide graphs or long arrays, create the notebook in landscape. You can change any page's paper from the page sidebar. See iPad note paper templates.
Write pseudocode by hand or in a text box
You'll rarely need to copy full code from a slide; you can usually get it from the course site. What's worth writing is pseudocode: the algorithm in plain steps, with the details that make it work.
Some habits:
- Indent clearly. Draw a faint vertical line down each block so you can see where loops end.
- Name the invariant. Write what stays true each time through the loop. This is often the key to understanding why the algorithm works.
- Note the complexity next to the algorithm, with a one-line reason.
- Trace a small example by hand, in a table with one row per step.
In Scribba, you can write pseudocode by hand, or type it in a text box from the + menu in the notebook's top bar if you'd rather. Text boxes sit on the page with your handwriting, so you can type the steps and draw arrows and notes around them. You can move, resize and recolor them. If you want to reuse handwritten pseudocode somewhere else, Scribba can copy a page's handwriting as text; check it carefully, since symbols and brackets are easy to misread.
Record live coding explanations
Live coding is hard to take notes on. The professor types, talks, runs the code, fixes a bug and explains why, all at once. By the time you've written down the function, you've missed the explanation of the bug.
If your professor allows recording, it helps a lot here. In Scribba, tap the mic (or press ⌘R) and take short notes as usual: the function name, a sketch of the data, "bug: off by one?" Every stroke is linked to that moment in the recording. After class, tap that note and you'll hear the explanation that went with it. Check your course policy first; see is it OK to record lectures?.
Scribba transcribes recordings too, so you can search for a term the professor said, like "base case" or "hash collision," and find it later. More in how to record a lecture on iPad.
Tip: during live coding, write less and listen more. A few keywords and a mark in the margin are enough when the recording has the rest.
Annotate the slides
Many CS courses post slides as PDFs before class. Import them into the class notebook, then write directly on them: circle the line that matters, draw the data structure next to the code, and add the edge case your professor mentioned out loud.
In Scribba, you can import PDFs as a new notebook or into the current one, and their text is searchable. Pull past the last page to add blank paper for longer traces. If you want your slides and your own notes side by side, open a notebook in its own window with Split View. See how to annotate lecture slides on iPad.
Keep your classes one tap apart
CS students often juggle a programming course, a theory course and a math course in the same semester, and ideas jump between them. Scribba keeps up to six notebooks open as tabs, so your algorithms notes and your discrete math notes are one tap apart. With a keyboard, ⌘O opens the quick switcher, and ⌘⇧[ and ⌘⇧] move between tabs.
Study by tracing, not rereading
The best way to study algorithms is to run them by hand. Take a small input, trace the algorithm step by step, and check your result against your notes. Then cover your snapshot diagrams and try to redraw them from the starting state.
In Scribba, drag study tape over the later snapshots in a sequence, trace the algorithm yourself, then tap to peek. See study tape on iPad.
Frequently asked questions
Can I write and run code in Scribba?
No. Scribba isn't a code editor. You can type pseudocode in text boxes, but it won't run, check or highlight it. Use your course's tools for real code.
What's the best paper for computer science notes?
Dot grid for diagrams and pseudocode, grid paper for arrays, memory layouts and truth tables, and ruled paper for theory-heavy lectures.
Can I type my notes instead of handwriting them?
You can type in text boxes on any page. Scribba is built around handwriting, though, and doesn't have a typed-notes-first editor.