📝 Lesson 2.2: Beyond Basics — Callouts, Tables, Code & Math

Callouts: Obsidian's Colored Boxes

You've seen them all over this course — the blue "info" boxes, the yellow "watch out" warnings, the green "pro tip" panels. Inside Obsidian, those are callouts, and they're built directly on top of the humble blockquote (>) you learned last lesson. Add a special tag on the first line and a plain quote becomes a styled, icon-topped box.

Here's the basic shape. Every line of the callout starts with >:

> [!note]
> This is a note callout. Everything on these
> quoted lines is inside the box.

The common callout types

Obsidian ships with many built-in types. Here are the ones you'll use most (the type keyword is case-insensitive, and several have aliases):

Custom titles

Put your own text right after the [!type] to replace the default title. Leave it blank and the title becomes just the type name.

> [!tip] Save yourself an hour
> Learn the command palette early — it's the fastest way
> to do almost anything in Obsidian.

Foldable callouts

Add a - or + right after the type to make the callout collapsible — great for long asides you don't want cluttering the page.

> [!example]- Click to reveal the answer
> The mitochondria is the powerhouse of the cell.

Tables (& the Advanced Tables Plugin)

Markdown tables use vertical pipes (|) to separate columns and a row of dashes to separate the header from the body. They look a little fiddly written by hand but render into clean, sortable-looking tables.

| Habit    | Time    | Done |
| -------- | ------- | ---- |
| Read     | 20 min  | ✅   |
| Exercise | 30 min  | ❌   |
| Journal  | 10 min  | ✅   |

That renders as a three-column table. The key rules:

• The first row is the header.
• The second row must be dashes (---) — this line tells Obsidian "everything above is a header."
• The outer pipes are optional but make raw tables easier to read.

Aligning columns

Add colons to the dash row to control alignment: :--- left, :---: center, ---: right.

| Item   | Price |
| :----- | ----: |
| Coffee |  3.50 |
| Muffin |  2.75 |

Code Blocks with Syntax Highlighting

Last lesson you learned the three-backtick "fence" for code blocks. The upgrade here is one small addition: write the language name right after the opening fence, and Obsidian colors the code — keywords, strings, numbers — so it's far easier to read.

```python
def greet(name):
    return f"Hello, {name}!"
```

Change python to javascript, css, bash, sql, json, yaml, and dozens more. Obsidian recognizes the common languages out of the box.

Math with LaTeX

If you take notes on math, physics, statistics, or finance, this feature is a gift. Obsidian renders mathematical notation using LaTeX syntax, powered by a math engine called MathJax. You write formulas in a compact code and Obsidian typesets them beautifully.

Inline math

Wrap an expression in single dollar signs to drop it into a sentence:

The area of a circle is $A = \pi r^2$, where $r$ is the radius.

Block (display) math

Wrap it in double dollar signs for a centered formula on its own line:

$$
E = mc^2
$$

Inside the dollar signs you use LaTeX commands: \pi for π, r^2 for a superscript, x_1 for a subscript, \frac{a}{b} for a fraction, \sqrt{x} for a square root, \sum and \int for sums and integrals.

$$
\frac{-b \pm \sqrt{b^2 - 4ac}}{2a}
$$

Footnotes, Embeds & Comments

Footnotes

Footnotes let you add a reference or aside without breaking your sentence's flow. Place a marker like [^1] where you want the little number, then define it anywhere in the note:

Plain text is the most durable format in computing.[^1]

[^1]: Text files from the 1970s still open perfectly today.

Obsidian renders a small superscript link that jumps to the definition (usually collected at the bottom). You can also write inline footnotes with ^[like this] when you don't want to manage separate labels.

Embedding images and files

The ! prefix turns a link into an embed — the content shows up inline rather than as a clickable link. For an image saved in your vault, use the Obsidian wikilink style with a bang in front:

![[diagram.png]]

You can resize an embedded image by adding a pixel width after a pipe: ![[diagram.png|400]]. (For images out on the web, the standard Markdown form ![alt text](https://...) also works.)

Transclusion: embedding one note inside another

Here's a genuinely magical Obsidian feature. The same ![[ ]] embed syntax works on notes, not just images — this is called transclusion. The embedded note's live content appears inside the current one, and it updates automatically when the source changes.

![[Project Overview]]          <!-- embeds the whole note -->
![[Project Overview#Goals]]    <!-- embeds just that heading's section -->
![[Meeting Notes#^a1b2c3]]     <!-- embeds one specific block -->

This lets you write something once and reuse it everywhere — a definition, a status block, a shared checklist — with zero copy-paste and no risk of versions drifting apart. You'll see how powerful this becomes once you're linking heavily in Module 3.

Comments: text only you see

Wrap text in double percent signs (%%) to make a comment — it stays in the file but is hidden in Reading view and Live Preview. Perfect for private notes-to-self, reminders, or draft text you're not ready to show.

This paragraph is public. %%But this reminder is hidden.%%

%%
Even a whole block can be a private comment
that never appears in the rendered note.
%%

Mermaid Diagrams Inside Notes

Obsidian can draw flowcharts and diagrams from plain text using a tool called Mermaid — the very same engine that renders the diagrams in this course. You write a few lines describing the boxes and arrows, and Obsidian draws the picture. No mouse, no shapes to drag.

Put your diagram description inside a code fence labeled mermaid:

```mermaid
graph TD
    A[Capture an idea] --> B[Write a note]
    B --> C[Link it to others]
    C --> D[A connected second brain]
```

Which renders as an actual flowchart, like this:

Mermaid can draw far more than flowcharts — sequence diagrams, mind maps, Gantt charts, pie charts, and more — all from readable text. It's ideal for sketching a process or a relationship without leaving your keyboard, and because it's plain text, your diagrams stay version-friendly and future-proof like the rest of your notes.

🎯 Project: Build a Cheat Sheet

The best way to remember all of this is to make your own reference. You'll build a single note that demonstrates every feature from this lesson — and because it's in your vault, it becomes a cheat sheet you can return to forever.

# Markdown Cheat Sheet

## Callouts
> [!tip] My favorite shortcut
> Press Ctrl/Cmd + E to toggle Reading view.

> [!example]- Hidden until clicked
> Surprise! This started collapsed.

## Table
| Feature | Syntax     | Easy? |
| ------- | ---------- | ----: |
| Bold    | `**text**` |   Yes |
| Math    | `$...$`     |    Ok |

## Code
```javascript
const hi = (name) => `Hello, ${name}`;
```

## Math
Inline: $a^2 + b^2 = c^2$

$$
\frac{-b \pm \sqrt{b^2 - 4ac}}{2a}
$$

## Footnote & comment
Plain text is durable.[^1] %%remember to add examples%%

[^1]: Still opens decades later.

## Diagram
```mermaid
graph LR
    A[Idea] --> B[Note] --> C[Link]
```

Best Practices for the Fancy Stuff

✅ Do's

• Use callouts to guide future-you. A [!warning] on a gotcha or a [!tip] at the top of a how-to note is a gift you leave yourself.
• Embed instead of copy-paste. The moment you'd duplicate a block, transclude it with ![[ ]] so it stays in sync.
• Fold long callouts. Use [!type]- for asides so notes stay skimmable.

❌ Don'ts

• Don't decorate for decoration's sake. A rainbow of callouts on every note is noise. Reserve them for information that truly needs to stand apart.
• Don't hand-polish table pipes. Ragged raw tables render fine; wait for Advanced Tables rather than aligning by hand.
• Don't hide anything important in a %%comment%% and forget it's there — comments are invisible in Reading view by design.

📓 Learning Journal

📝 Lesson Summary

🎉 What You've Accomplished

You've gone from "I can format text" to "I can build a rich, structured document" — callouts that guide the reader, tables that organize, code that reads clearly, math that typesets, and even diagrams and reusable embedded content. Your cheat sheet is now a living reference you'll thank yourself for. Very impressive progress for Module 2.

❓ Common Questions at This Stage

🔭 Looking Ahead

You can now write genuinely rich notes. Next we make them findable and organized: in Lesson 2.3 you'll learn metadata — tags, YAML frontmatter Properties, and aliases — the invisible structure that lets you (and, later, Dataview) locate and query any note in seconds.

✅ Before the Next Lesson

• Finish your Markdown Cheat Sheet and keep it somewhere easy to reach
• Try adding a callout to an older note where a warning or tip belongs
• Write your Learning Journal entry (bonus points for using a callout)

📚 Additional Resources

• Obsidian Help — Callouts
• Obsidian Help — Tables, math, footnotes & more
• Obsidian Help — Embedding files & notes
• Mermaid — diagram syntax reference