Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Eloquent JavaScript

Eloquent JavaScript

A Modern Introduction to Programming
Build JavaScript programs that stay understandable, from tiny functions to browser apps and servers.
by Marijn Haverbeke 2010 224 pages
4.14
3k+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Make code eloquent by replacing machine steps with problem-shaped ideas

Climb above the mechanics. A computer follows precise, simple instructions, but a useful program combines them into something complex. The same task can be expressed at different levels: a long sequence of memory updates, a loop that totals numbers from 1 to 10, or a concise expression that sums a range. JavaScript helps programmers move upward by providing control structures and letting them define their own building blocks.

Name what matters. The book’s central aim is not merely to teach JavaScript syntax. It is to make programs easier to understand by expressing the problem in concepts that fit it. JavaScript runs in browsers and in Node.js, so these ideas can power both interactive pages and programs outside the browser.

Analysis

What's striking is that readability is treated as an engineering tool, not decoration. A well-chosen abstraction lets a reader reason about a sum instead of mentally simulating counters and updates. That is a form of cognitive compression: fewer incidental details compete for attention. Yet abstraction is not automatically clarity. A short expression can hide surprising behavior, especially in a permissive language. The useful test is whether the named operation matches the problem and whether its implementation remains understandable.

Give repeated or complex behavior a small, well-named function

Functions create vocabulary. A function packages instructions under a name, accepts inputs, and may return a result. Local scope keeps its temporary bindings separate from the rest of the program. A closure is a function that retains access to bindings around where it was created, even after that surrounding call has ended. This lets a function remember a multiplier, for example, and reuse it later.

Abstract actions, too. Higher-order functions accept or return other functions. Array methods such as `filter`, `map`, and `reduce` respectively select entries, transform them, and combine them into one result. Composed together, they can describe a data-processing pipeline more directly than a loop full of intermediate bookkeeping. Prefer focused functions over premature general-purpose machinery.

Analysis

The progression from named functions to functions that manipulate other functions is a shift from describing steps to describing reusable patterns. It resembles the way a good scientific model identifies a stable relationship, then lets many cases fit that relationship. The book also supplies a practical restraint: abstraction should remove confusion, not merely reduce line count. A dense chain of array methods can be harder to inspect than a loop, particularly when each transformation has side effects.

Model data around the question, then treat correlations as clues

Choose a useful representation. Arrays hold ordered sequences; objects group named properties. Together they let a program store records such as a day’s activities and whether Jacques, the book’s fictional weresquirrel, transformed. Objects are mutable, and two bindings can refer to the same object, so a change through one is visible through the other. JSON turns these linked structures into text that can be stored or sent elsewhere.

Let evidence guide the next question. Jacques records events and uses the phi coefficient to compare each event with transformations. Peanuts show a strong positive correlation, about 0.59, while brushing teeth shows a negative one. Combining peanuts with not brushing produces a perfect correlation in his log. The pattern points to a possible trigger, but the data alone cannot establish why it occurs.

Analysis

The weresquirrel story makes data modeling feel less like bookkeeping and more like experimental design. A table is valuable because it preserves the distinctions needed to ask a question; a poor representation can make important relationships invisible. The tale also offers a useful caution: a perfect association inside one recorded dataset is not a universal causal law. In real analysis, a correlation can identify what to investigate, while alternative explanations, measurement quality, and new observations determine how much confidence it deserves.

Design objects around stable interfaces, not every noun in the story

Hide the machinery. An abstract data type exposes a limited set of operations while keeping its internal implementation private. JavaScript prototypes let objects share behavior, and class syntax offers a familiar way to define constructors and methods. When unrelated object types support the same expected interface, code can work with either one. That flexibility is called polymorphism.

Use inheritance selectively. In the village-robot project, the useful state is simply the robot’s location and the parcels’ locations and destinations. Creating classes for every village concept would add links and changing state without solving the central problem. The book instead favors a compact state and transitions that produce a new state. Inheritance can reuse behavior, but it also binds classes together, so it should not be the automatic design choice.

Analysis

This section resists a common design reflex: translating every noun in a story into a class. Its deeper point is that software boundaries should follow responsibilities, not grammar. Interfaces permit useful substitution, while encapsulation limits how much one component must know about another. Inheritance is more ambivalent because reuse comes with structural dependence. The robot example shows that a small representation can be more expressive than a miniature simulation of the real world.

Make mistakes loud, localized, and reproducible

Catch errors early. JavaScript can quietly accept mistakes that other languages might reject, allowing bad values to travel through a program before anything visibly fails. Strict mode catches some common slips, automated tests check known behaviors repeatedly, and assertions expose invalid assumptions near their source. When a program misbehaves, add targeted observations or use a debugger instead of changing code at random.

Handle failure deliberately. Exceptions let a failure travel up the call stack to code equipped to respond. Catch only errors the program can genuinely handle, and use `finally` when cleanup must happen regardless. The book’s broken number-conversion example divides by its base without rounding, producing a stream of tiny fractions. Inspecting the changing value reveals the faulty step and points to the correct fix.

Analysis

Debugging here is presented as a disciplined cycle: observe, form an explanation, and test it. That method is more reliable than treating errors as mysterious interruptions. Tests add a memory of past expectations, while assertions make internal assumptions explicit. Error handling also has a boundary: catching everything can conceal programmer mistakes and leave a program stuck repeating the wrong response. Robustness is not the absence of failure, but a clear distinction between recoverable conditions and defects that need attention.

Use regular expressions for compact patterns, then respect their sharp edges

Describe text patterns. A regular expression is a compact notation for matching strings. Character sets recognize alternatives, repetition operators match recurring pieces, and groups capture portions of a match for extraction or replacement. The book uses these tools to parse an INI configuration file, where lines may contain settings, section headings, comments, or invalid syntax.

Know when matching gets costly. Repetition is greedy by default, so a pattern may consume too much text before backtracking. Poorly designed nested repetition can make the search grow dramatically. JavaScript’s default character shortcuts also miss many non-English letters; Unicode property groups such as `\p{L}` require Unicode mode. Regular expressions simplify well-bounded text tasks, but they become brittle when forced to describe a complex language.

Analysis

Regular expressions are powerful partly because they compress a search procedure into a small notation. That compression can conceal the procedure’s cost and assumptions. The chapter’s examples make two limits concrete: a pattern can backtrack through many possibilities, and familiar shortcuts may encode an English-centric idea of a letter. The practical lesson is not to avoid the tool, but to choose patterns whose behavior can be explained, tested against edge cases, and kept within a clearly defined text format.

Split programs where boundaries clarify dependencies and reuse

Make connections explicit. A module declares what it exports and which other modules it imports. This gives each part a defined interface and makes its dependencies visible, reducing the risk that unrelated code becomes entangled through global names. JavaScript supports ES modules, while CommonJS remains common in older code and packages.

Reuse without surrendering judgment. NPM distributes packages and manages project dependencies. A package can save the work of rebuilding a tested capability, but every dependency also brings installation, compatibility, and maintenance concerns. Good modules do one focused job, use familiar data structures where possible, and compose with other code. Bundlers combine module files for delivery, while minifiers reduce their size.

Analysis

Modularity is presented as a way to lower the cost of understanding, not simply a way to arrange files. Explicit dependencies let a reader trace what a component needs and what it offers in return. Reuse becomes most valuable when the imported capability is substantial and the package’s interface fits the project. For tiny helpers, dependency overhead can exceed the benefit. The deciding question is whether a boundary makes responsibilities clearer and future change safer.

Let slow work proceed asynchronously, but keep shared state disciplined

Do useful work while waiting. Network and file operations take far longer than ordinary processor instructions. Callbacks let an operation notify the program when it finishes; promises represent results that may arrive later and carry failures through a chain. `async` functions and `await` make sequential asynchronous work easier to read without making the operation synchronous.

Remember the gaps. JavaScript’s event loop runs one piece of code at a time, then handles queued callbacks and other events. An `await` yields control, so other work can run before the suspended function resumes. In the book’s file-size example, several asynchronous tasks all append to one shared string, overwriting one another’s results. Returning independent lines and joining them after `Promise.all` avoids the race.

Analysis

Asynchronous programming is less about doing several instructions simultaneously than about not wasting the program’s opportunity to respond while an operation is pending. The event loop makes that responsiveness possible, but each pause creates a point where assumptions about shared state may become stale. The file-size example shows why immutable results compose well: independent computations can finish in any order and still be combined predictably. Concurrency is useful, but it is not free of coordination costs.

Treat the browser as a programmable document, not just a display

Work with a live structure. The DOM represents an HTML page as a tree of elements and text. JavaScript can find nodes, change their content or style, and respond to events such as clicks, key presses, and form input. Event handlers should preserve expected browser behavior unless there is a good reason to override it. Browser code is sandboxed, which limits access to a user’s device and other sites.

Pick the right drawing surface. HTML suits text-rich interfaces, SVG preserves editable shapes, and canvas turns drawings into pixels that must be redrawn when they change. The platform game demonstrates animation and collisions; the pixel editor organizes changes through a central state and actions. That flow keeps tools from having to update every other part of the interface directly.

Analysis

The browser is both a programming environment and a collection of historical compromises. Its DOM makes documents interactive, but frequent layout reads mixed with writes can make rendering expensive. The graphics options reflect different representations: structured elements are easy to target, while a pixel surface can handle many small shapes efficiently. The pixel editor’s single state-update path is especially important because it limits synchronization problems as tools and controls interact.

Use HTTP as a contract between browser code and real services

Specify the exchange. HTTP requests identify a method and resource; responses carry a status, headers, and sometimes a body. Browser `fetch` makes these exchanges available to JavaScript, while JSON provides a portable format for structured data. GET is suited to retrieving information, while methods such as POST and PUT communicate changes. HTTPS protects traffic in transit, and browser cross-origin rules restrict which servers a page may contact.

Build beyond the page. Node.js runs JavaScript outside the browser, with modules for files and HTTP servers. The book builds a file server, then a skill-sharing site whose server stores talks and comments while browsers update through long polling. The latter keeps requests open briefly so clients can learn about changes without a permanent server-initiated connection.

Analysis

The move from browser interactions to HTTP services extends the same design principle: make the boundary explicit. A request method, URL, status, and data format form a contract that both sides can interpret. Long polling is a pragmatic fit for the project’s live updates, though it repeatedly occupies connections and requires retry logic. The examples also make security part of ordinary engineering: a service that accepts network requests must validate input and restrict what its file paths can reach.

Analysis

This book teaches JavaScript, but its more durable subject is the management of complexity. The progression is deliberate: values become expressions, expressions become functions, functions organize data, and interfaces connect larger pieces. Each step adds expressive power while also creating new ways to misunderstand a program. The answer is not a single design doctrine. It is a set of choices about where to hide details, what to make explicit, and when to preserve state rather than mutate it.

The examples carry much of the teaching. Jacques’s log turns objects and arrays into evidence; the village robot makes state transitions tangible; Egg demystifies how parsing and evaluation work; the platform game links physics, events, and rendering; the pixel editor shows how one state model can coordinate many controls. These projects give abstract mechanisms a reason to exist. They also show that working software is assembled from ordinary pieces, not conjured from clever syntax.

The book’s strongest recurring criterion is intelligibility. Pure functions, narrow module interfaces, explicit error checks, and data structures shaped around a task all make reasoning more local. This is not an argument that every program should be immutable, highly abstract, or class-free. Each technique has costs: abstraction can hide execution, inheritance can create tight coupling, asynchronous code introduces timing hazards, and browser APIs carry historical irregularities. The craft lies in recognizing which cost is worth paying for a particular problem.

As a learning path, the book is unusually broad: it moves from language fundamentals to browser graphics, HTTP, and Node.js, while repeatedly asking readers to write code. Its scope is a strength because the same ideas recur in different settings. It is also a limitation: no short introduction can make every platform detail feel current or complete. The central payoff is a way to think: represent the problem clearly, build small pieces that compose, and test the behavior rather than trusting appearances.

Summary in 30 Seconds
Clear programs represent a problem in useful concepts, then combine small functions and data structures to solve it. Stable interfaces and focused modules make larger systems easier to change, while tests, assertions, and targeted debugging expose mistakes early. Use regular expressions for bounded text patterns. Promises and async functions manage delayed work, but shared state can still create race conditions. Browser interfaces, HTTP services, and Node.js extend JavaScript beyond basic syntax.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.14 out of 5
Average of 3k+ ratings from Goodreads and Amazon.

Eloquent JavaScript receives mixed reviews. Many praise its comprehensive coverage and engaging style, finding it excellent for intermediate programmers. However, opinions vary on its suitability for beginners, with some considering it too complex. Readers appreciate the free online version and interactive exercises. Critics note inconsistent explanations, overly complex examples, and occasionally confusing pedagogy. The book's unique approach and coverage of advanced topics are both praised and criticized. Overall, it's considered a valuable resource for those looking to deepen their JavaScript knowledge, but may not be ideal for absolute beginners.

Your rating:
4.54
267 ratings
Want to read the full book?

Glossary

Higher-order functions

Functions that handle functions

Functions that accept other functions as arguments, return functions, or both. They let a program abstract over actions as well as values. Array methods such as filter, map, and reduce are common examples: each accepts a function that specifies how elements should be selected, transformed, or combined.

Closure

Function with remembered bindings

A function together with access to bindings in the surrounding scope where it was created. Those bindings remain available even after the outer function call has finished. A closure can therefore preserve information, such as a chosen multiplier, and use it when called later.

Pure function

Predictable function without side effects

A function that returns a value without changing external state and does not rely on changing external state. Given the same arguments, it returns the same result. This makes its behavior easier to combine and test, though many useful operations, such as writing to a console, necessarily have side effects.

phi coefficient

Correlation for two Boolean variables

A measure of association between two Boolean variables, calculated from a frequency table of their observed combinations. Its value ranges from -1 to 1. Zero indicates no measured association, while values near either extreme indicate strong association. In the weresquirrel example, it helps compare daily events with transformations.

Abstract data type

Data behind a limited interface

A type whose internal implementation is hidden behind a defined set of operations available to outside code. Other parts of a program use that interface rather than depending on internal details. This separation can allow an implementation to be changed without requiring every user of the type to change.

Prototype

Object supplying shared properties

An object that JavaScript consults when another object does not have a requested property. Prototypes allow instances to share methods without copying each method into every instance. A chain of prototypes can provide inherited properties, though long or intricate chains can make behavior harder to trace.

Polymorphism

Different objects, shared interface

The ability of code to work with different kinds of objects because they provide the same expected operations. For example, code that needs a toString method can accept varied objects that implement one. The code depends on the interface, not on a particular class.

Persistent data structure

Structure preserved across updates

A data structure that is not modified when an update is made. Instead, an operation produces a new structure while leaving the previous version intact. This makes earlier states available for comparison or reuse and can make program behavior easier to reason about, though creating updates may require extra work.

Regular expression

Pattern for matching text

A compact pattern language used to test, search, extract, or replace parts of strings. It supports character sets, repetition, alternatives, and groups. Regular expressions are effective for bounded text patterns, but complex expressions can be difficult to read, may backtrack extensively, and require care with Unicode.

Promise

Representation of a future result

An object representing the eventual success or failure of an asynchronous operation. A promise can be resolved with a value or rejected with a reason. Handlers attached through methods such as then and catch form chains that carry results and failures through subsequent work.

Event loop

Scheduler for queued events

The mechanism used by JavaScript environments to run queued callbacks and event handlers between pieces of currently executing code. JavaScript runs one such piece at a time, so long-running work delays other events. Asynchronous operations can yield while waiting, allowing the environment to process other work.

Long polling

Repeated requests held for updates

A technique for delivering server updates over ordinary HTTP. A client repeatedly requests information, and the server delays a request when there is nothing new to report. When data changes or a waiting period expires, the server responds and the client starts another request.

Egg

Small interpreted teaching language

A compact programming language built in the book to demonstrate how parsing and evaluation work. Its uniform syntax represents literals, names, and applications as expression trees. An evaluator runs those trees using a scope, while special forms provide behavior such as conditionals, loops, definitions, and functions.

FAQ

What's Eloquent JavaScript about?

  • Comprehensive Guide: Eloquent JavaScript by Marijn Haverbeke is a modern introduction to programming, focusing on JavaScript. It covers fundamental programming concepts and the intricacies of the JavaScript language.
  • Language and Environment: The book explains how JavaScript operates within web browsers and Node.js, providing insights into both environments.
  • Practical Examples: It includes numerous practical examples and exercises to reinforce learning, encouraging readers to experiment with code.

Why should I read Eloquent JavaScript?

  • Skill Development: The book enhances programming skills, particularly in JavaScript, which is essential for web development.
  • Engaging Style: Marijn Haverbeke presents complex topics in an engaging and accessible manner, making it easier to grasp challenging concepts.
  • Comprehensive Coverage: It covers a wide range of topics, from basic syntax to advanced concepts like asynchronous programming and the Document Object Model (DOM).

What are the key takeaways of Eloquent JavaScript?

  • JavaScript Fundamentals: Readers gain a thorough understanding of JavaScript, including its syntax, data structures, and functions.
  • Programming Concepts: Key programming concepts such as values, types, operators, control flow, and functions are thoroughly explained.
  • Asynchronous Programming: The book covers asynchronous programming, including callbacks and promises, essential for modern web development.

What are the best quotes from Eloquent JavaScript and what do they mean?

  • "We think we are creating the system for our own purposes.": Reflects the complexity and unpredictability of programming, where systems often evolve beyond initial intentions.
  • "Learning is hard work, but everything you learn is yours.": Emphasizes the value of persistence in learning programming, with knowledge becoming a personal asset.
  • "A program is a building of thought.": Illustrates programming as a creative process, akin to constructing a building, requiring careful planning and structure.

How does Eloquent JavaScript approach teaching JavaScript?

  • Incremental Learning: Concepts are introduced incrementally, building on previous knowledge to help readers grasp complex ideas without feeling overwhelmed.
  • Hands-On Exercises: Each chapter includes exercises that encourage readers to apply what they’ve learned, reinforcing understanding and solidifying skills.
  • Real-World Projects: Projects throughout the book allow readers to see how concepts are applied in real-world scenarios, enhancing engagement and retention.

What programming concepts are covered in Eloquent JavaScript?

  • Values and Types: The book begins with an exploration of values, types, and operators in JavaScript, crucial for writing effective code.
  • Control Flow and Functions: It delves into control flow structures like loops and conditionals, as well as the definition and use of functions.
  • Data Structures: Covers objects and arrays, explaining how to use them to organize and manipulate data, essential for effective programming.

How does Eloquent JavaScript address asynchronous programming?

  • Callbacks and Promises: The book covers the use of callbacks and promises to handle asynchronous operations, vital for modern web development.
  • Async/Await Syntax: Introduces the async/await syntax, simplifying working with asynchronous code and improving code clarity.
  • Event Loop Explanation: Explains the event loop and how it manages asynchronous operations, crucial for building responsive applications.

What is the significance of functions in Eloquent JavaScript?

  • Core Programming Concept: Functions are presented as a fundamental building block of programming, allowing for code reuse and abstraction.
  • Higher-Order Functions: Introduces higher-order functions, which can take other functions as arguments or return them, enhancing code flexibility.
  • Closure and Scope: Explains closures and scope, essential for understanding how functions interact with variables in JavaScript.

How can I manipulate the DOM using JavaScript as described in Eloquent JavaScript?

  • Creating Elements: The book explains how to create new HTML elements using methods like document.createElement.
  • Modifying Elements: Readers learn how to modify existing elements by changing their attributes, styles, and content.
  • Event Listeners: Covers how to add event listeners to DOM elements, enabling applications to respond to user actions like clicks and key presses.

What are some common pitfalls in JavaScript that Eloquent JavaScript warns about?

  • Type Coercion Issues: Highlights the quirks of JavaScript's type coercion, which can lead to unexpected results.
  • Scope Confusion: Addresses common mistakes related to variable scope, particularly with the use of var, let, and const.
  • Error Handling: Emphasizes the importance of proper error handling, particularly with asynchronous code.

How does Eloquent JavaScript encourage experimentation?

  • Interactive Code Examples: Provides numerous code examples that readers are encouraged to modify and experiment with.
  • Online Sandbox: Offers an online coding sandbox where readers can run and test code snippets directly.
  • Encouragement of Creativity: Encourages readers to think creatively and explore different solutions to problems.

What is the structure of Eloquent JavaScript?

  • Three Main Parts: The book is divided into three main parts: the JavaScript language, web programming, and Node.js.
  • Project Chapters: Each part includes project chapters that allow readers to apply what they’ve learned in practical scenarios.
  • Exercises and Solutions: Each chapter concludes with exercises that challenge readers to apply their knowledge, with solutions provided online.

About the Author

Marijn Haverbeke is a talented programmer and writer known for his work on JavaScript. He has gained recognition for his ability to explain complex programming concepts in an accessible manner. Haverbeke's writing style is described as light, to the point, and occasionally humorous. His expertise in JavaScript is evident through his comprehensive coverage of the language, including advanced topics like functional programming and asynchronous programming. While some readers find his explanations challenging, many appreciate his unique approach to teaching programming. Haverbeke's commitment to open access is demonstrated by making his book freely available online, complete with interactive examples and exercises. His work has significantly impacted the JavaScript learning community, earning him respect among both beginners and experienced programmers.

Download PDF

To save this Eloquent JavaScript summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.43 MB     Pages: 21

Download EPUB

To read this Eloquent JavaScript summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.42 MB     Pages: 25
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...