APA vs. MLA vs. Chicago: A Developer's Guide to Citation Formats (and a Tiny Formatter in TypeScript)

Citation formatting is a strange corner of academic life. The rules are precise, they differ from style to style, and they change between editions. Students lose points for a misplaced period or a missing italic, and the frustration is real because the rules feel arbitrary.

To a developer, though, a citation looks very familiar. It's structured data (author, title, year, publisher, URL) rendered through a template. Different styles are just different templates operating on the same fields. Once you see it that way, the whole thing becomes a lot less mysterious, and you can reason about it the same way you'd reason about a serializer.

This article walks through the three most common styles in US coursework (APA, MLA, and Chicago), explains where they differ and why, and builds a small TypeScript formatter so the patterns are concrete. A note on scope: style guides publish detailed edition-specific rules, and your instructor may have their own requirements. Use this as a mental model and a quick reference, and check the official manual for edge cases.

Why citations exist at all

Before the formatting, the purpose. A citation does three jobs:

1. Gives credit to the people whose work you used.
2. Lets readers find the source so they can verify or follow up.
3. Shows your reasoning, making clear which claims rest on which evidence.

Each style optimizes for a different academic culture, and that explains most of the differences.

• APA (American Psychological Association) comes from the social and behavioral sciences. It emphasizes the date, because in those fields, how recent a study is matters a great deal. That's why the year sits right after the author's name.
• MLA (Modern Language Association) comes from literature and the humanities. It emphasizes the author and the text itself, and de-emphasizes the date. Page numbers matter because you're often quoting specific passages.
• Chicago comes from publishing and history. It offers two systems: notes-bibliography (footnotes or endnotes, common in history and the arts) and author-date (similar to APA, common in the sciences). Chicago is the most flexible and the most detailed.

If you remember only one thing, remember that: the style reflects what the discipline cares about.

The shared data model

Every style draws from roughly the same set of fields. Here's a reasonable model for a source:

type SourceType = "book" | "website" | "journal";

interface Author {
  first: string;
  middle?: string;
  last: string;
}

interface Source {
  type: SourceType;
  authors: Author[];
  title: string;
  year?: number;
  publisher?: string;     // books
  city?: string;          // Chicago books
  siteName?: string;      // websites
  containerTitle?: string; // journal name
  volume?: string;
  issue?: string;
  pages?: string;
  url?: string;
  doi?: string;
  accessed?: string;      // e.g. "March 3, 2026"
}

Notice how many optional fields there are. Real-world sources are messy: websites often lack authors, books have editions, articles have DOIs. A good formatter handles missing data gracefully instead of printing "undefined (n.d.)" everywhere. The conventions for missing fields (like "n.d." for no date) are part of each style's rules.

APA (7th edition): author, date, title

APA reference entries follow the pattern Author. (Year). Title. Source.

A few defining traits:

• Authors appear as last name, initials: Smith, J. A.
• The year is in parentheses right after the author.
• Titles of standalone works (books, reports) are italicized and in sentence case, meaning only the first word, proper nouns, and the first word after a colon are capitalized.
• For journal articles, the article title is plain sentence case and the journal name is italicized in title case, followed by the volume (italicized), issue in parentheses, and page range.
• A DOI, formatted as a URL, goes at the end when available.

Examples, in plain text with * marking italics:

Book:
Smith, J. A. (2021). *Learning to write clearly: A practical guide*. Academic Press.

Journal article:
Nguyen, T., & Alvarez, M. (2020). Sleep patterns and academic performance. *Journal of Student Wellbeing, 12*(3), 45–61. https://doi.org/10.0000/example

Webpage:
Rivera, L. (2022, May 4). How to plan a study schedule. Campus Learning Center. https://example.edu/study-schedule

APA's in-text citations use the author-date form: (Smith, 2021) or Smith (2021) argues…. With two authors, use (Nguyen & Alvarez, 2020). For three or more authors, APA 7 uses (Rivera et al., 2022) from the first citation on.

MLA (9th edition): author, title, container

MLA's central idea is the container. A source sits inside a larger thing: a poem inside an anthology, an article inside a journal, a page inside a website. The entry lists elements in order, ending with the most specific location.

The general pattern is: Author. Title. Container, Contributors, Version, Number, Publisher, Date, Location. You include only what's applicable.

Key traits:

• Authors appear as Last, First: Smith, Jane A.
• Titles of standalone works are italicized; titles of shorter works (articles, chapters, webpages) go in quotation marks.
• Titles use title case (major words capitalized).
• The year goes near the end, not after the author.
• There's no mandatory "accessed on" date, though it's allowed, and for web sources it's optional but sometimes recommended when content may change.

Examples:

Book:
Smith, Jane A. *Learning to Write Clearly: A Practical Guide*. Academic Press, 2021.

Journal article:
Nguyen, Thanh, and Maria Alvarez. "Sleep Patterns and Academic Performance." *Journal of Student Wellbeing*, vol. 12, no. 3, 2020, pp. 45–61.

Webpage:
Rivera, Luis. "How to Plan a Study Schedule." *Campus Learning Center*, 4 May 2022, example.edu/study-schedule.

MLA's in-text citations use author and page: (Smith 42). There's no comma between the name and page number, and no year.

Chicago (17th edition): notes and bibliography

Chicago's notes-bibliography system uses numbered footnotes or endnotes in the text, plus a bibliography at the end. The first time you cite a source in a note, you give the full details; later notes use a shortened form.

Key traits:

• In the bibliography, authors appear as Last, First.
• Titles are in title case, with standalone works italicized.
• The bibliography entry puts publication details at the end, and for books includes the city of publication and publisher in the form City: Publisher, Year.
• Notes are written like sentences, with commas rather than periods separating elements.

Examples:

Bibliography (book):
Smith, Jane A. *Learning to Write Clearly: A Practical Guide*. New York: Academic Press, 2021.

First footnote (book):
1. Jane A. Smith, *Learning to Write Clearly: A Practical Guide* (New York: Academic Press, 2021), 42.

Shortened later footnote:
2. Smith, *Learning to Write Clearly*, 57.

Notice that Chicago footnotes use First Last order, while the bibliography uses Last, First. That reversal trips up a lot of students. Newer Chicago guidance has relaxed some conventions (such as the city of publication), so check which edition your instructor expects.

Side-by-side comparison

Here's the same book rendered in all three styles, so the differences are visible at a glance:

Style	Entry
APA	Smith, J. A. (2021). Learning to write clearly: A practical guide. Academic Press.
MLA	Smith, Jane A. Learning to Write Clearly: A Practical Guide. Academic Press, 2021.
Chicago	Smith, Jane A. Learning to Write Clearly: A Practical Guide. New York: Academic Press, 2021.

The differences, in short:

• Name format: APA uses initials; MLA and Chicago spell out the first name.
• Year position: early in APA; late in MLA and Chicago.
• Title case: APA uses sentence case for titles in references; MLA and Chicago use title case.
• Publisher location: Chicago traditionally adds the city.

Building a formatter

Here's a small TypeScript sketch that renders the book case for all three styles. It's intentionally minimal. Real citation engines (such as those based on the Citation Style Language) handle thousands of edge cases.

const initials = (a: Author) =>
  [a.first, a.middle]
    .filter(Boolean)
    .map((n) => n![0].toUpperCase() + ".")
    .join(" ");

const sentenceCase = (s: string) => {
  // simplistic: lowercases everything except the first letter
  // (a real formatter must preserve proper nouns and acronyms)
  return s.charAt(0) + s.slice(1).toLowerCase();
};

function formatAuthorsAPA(authors: Author[]): string {
  const names = authors.map((a) => `${a.last}, ${initials(a)}`);
  if (names.length === 1) return names[0];
  if (names.length === 2) return `${names[0]}, & ${names[1]}`;
  return `${names.slice(0, -1).join(", ")}, & ${names[names.length - 1]}`;
}

function bookAPA(s: Source): string {
  const year = s.year ?? "n.d.";
  return `${formatAuthorsAPA(s.authors)} (${year}). *${sentenceCase(s.title)}*. ${s.publisher}.`;
}

function bookMLA(s: Source): string {
  const a = s.authors[0];
  const name = `${a.last}, ${a.first}${a.middle ? " " + a.middle : ""}`;
  return `${name}. *${s.title}*. ${s.publisher}, ${s.year}.`;
}

function bookChicago(s: Source): string {
  const a = s.authors[0];
  const name = `${a.last}, ${a.first}${a.middle ? " " + a.middle : ""}`;
  return `${name}. *${s.title}*. ${s.city}: ${s.publisher}, ${s.year}.`;
}

A few things this sketch demonstrates, and a few it papers over:

• Templates differ, data doesn't. That's the core insight. Once your data model is clean, adding a new style means adding a new set of templates.
• Sentence case is hard. Lowercasing everything breaks proper nouns ("Python," "Harvard") and acronyms ("NASA"). A production tool needs a list of exceptions or a way for users to mark them.
• Author handling gets complicated fast. Rules for how many authors to list, when to use "et al.," how to handle organizations as authors, and how to handle editors all vary by style and edition.
• Italic markup needs a rendering layer. The asterisks above are placeholders for whatever output format you need, such as HTML, Word, or LaTeX.

Common mistakes students make

Having seen the rules side by side, the typical errors make more sense:

1. Mixing styles inside one paper, such as APA-style years in an MLA works-cited list.
2. Title case in APA references. APA reference titles use sentence case, while MLA and Chicago use title case.
3. Forgetting hanging indents. Reference lists in all three styles generally use a hanging indent, where the first line is flush left and subsequent lines are indented.
4. Citing the wrong edition. Style manuals update, and instructors expect the edition they specified.
5. Trusting auto-generated metadata blindly. Whatever tool creates a citation, check the output against the source: author names, capitalization, dates, and URLs can be wrong.
6. Missing in-text/reference pairing. Every in-text citation needs a matching entry, and every entry should be cited somewhere in the text (except in a "further reading" or full bibliography, which Chicago and MLA sometimes allow).
7. Inconsistent URL handling. Some instructors want live links; others want them removed.

What a generator can and can't do

Citation generators save time by taking structured input and applying the right template. They're excellent for the mechanical parts: ordering elements, adding punctuation, italics, and consistent formatting. They're less reliable at judgment calls: deciding whether a source has a real author or just a publisher, whether a page is a "website" or a "report," or how to handle unusual material like interviews, datasets, or social media posts.

So treat the output as a strong first draft. Verify it against your style guide or your instructor's requirements, especially for assignments where formatting counts toward your grade.

If you want a quick way to produce a draft entry, the Citation Generator at Take My Class For Me formats citations in APA, MLA, or Chicago style for books, websites, and papers. Enter the details, pick the style, and check the result against your manual before you submit.

Citation management as a habit

The best way to avoid last-minute citation panic is to capture source details as you research, not after you've finished writing. A habit that works well:

• Record the full details the moment you find a source: author, title, date, publisher or site, URL, DOI, and page numbers for anything you quote.
• Keep your notes and sources together, so you can trace a claim back to where it came from.
• Pick your style early and format as you go.
• Run a final pass that matches every in-text citation to a reference entry.

Developers will recognize this as the same discipline as writing documentation while the code is fresh rather than at release time. The cost of capturing details at discovery is tiny; the cost of reconstructing them at 2 a.m. before a deadline is not.

Quick reference

• APA: Author, year in parentheses, sentence-case titles, in-text (Author, Year).
• MLA: Author, title in title case, container, year near the end, in-text (Author Page).
• Chicago: Footnotes or endnotes plus bibliography; title case; publisher details at the end; full note first, shortened note after.
• All three: Hanging indents in the reference list and strict consistency.

Closing thoughts

Citation styles feel arbitrary until you notice they're each optimized for a different field's priorities: recency in the sciences, textual detail in the humanities, and bibliographic completeness in publishing. After that, the rules stop feeling like trivia and start feeling like design decisions.

If you build your own formatter, start with one style and one source type, write tests with real examples from the official manual, and expand from there. The edge cases will humble you quickly, and you'll come away with a lot more respect for the people who maintain citation libraries.