Book Image

Clean Code in JavaScript

By : James Padolsey
Book Image

Clean Code in JavaScript

By: James Padolsey

Overview of this book

Building robust apps starts with creating clean code. In this book, you’ll explore techniques for doing this by learning everything from the basics of JavaScript through to the practices of clean code. You’ll write functional, intuitive, and maintainable code while also understanding how your code affects the end user and the wider community. The book starts with popular clean-coding principles such as SOLID, and the Law of Demeter (LoD), along with highlighting the enemies of writing clean code such as cargo culting and over-management. You’ll then delve into JavaScript, understanding the more complex aspects of the language. Next, you’ll create meaningful abstractions using design patterns, such as the Class Pattern and the Revealing Module Pattern. You’ll explore real-world challenges such as DOM reconciliation, state management, dependency management, and security, both within browser and server environments. Later, you’ll cover tooling and testing methodologies and the importance of documenting code. Finally, the book will focus on advocacy and good communication for improving code cleanliness within teams or workplaces, along with covering a case study for clean coding. By the end of this book, you’ll be well-versed with JavaScript and have learned how to create clean abstractions, test them, and communicate about them via documentation.

Related Content you might be interested in

Current Title:

Small book image
Clean Code in JavaScript
James Padolsey
Jan, 2020 | 548 pages
Small book image
Object-Oriented JavaScript
Stoyan STEFANOV | Ved Antani
Jan, 2017 | 550 pages
Small book image
Learn ECMAScript
Narayan Prusty | MEHUL MOHAN
Feb, 2018 | 298 pages
Table of Contents (26 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
1
Section 1: What is Clean Code Anyway?
Section 1: What is Clean Code Anyway?
Free Chapter
2
Setting the Scene
Setting the Scene
Why we write code
Writing code for humans
Summary
3
The Tenets of Clean Code
The Tenets of Clean Code
Reliability
Efficiency
Maintainability
Usability
Summary
4
The Enemies of Clean Code
The Enemies of Clean Code
Enemy #1 – JavaScript
Enemy #2 – management
Enemy #3 – Self
Enemy #4 – The cargo cult
Summary
5
SOLID and Other Principles
SOLID and Other Principles
The Law of Demeter
SOLID
The abstraction principle
Functional programming principles
Summary
6
Naming Things Is Hard
Naming Things Is Hard
What's in a name?
Naming anti-patterns
Consistency and hierarchy
Techniques and considerations
Summary
7
Section 2: JavaScript and Its Bits
Section 2: JavaScript and Its Bits
8
Primitive and Built-In Types
Primitive and Built-In Types
Primitive types
Objects
Functions
Arrays and iterables
RegExp
Summary
9
Dynamic Typing
Dynamic Typing
Detection
Conversion, coercion, and casting
Summary
10
Operators
Operators
What is an operator?
Arithmetic and numeric operators
Logical operators
Comparative operators
Assignment operators
Property access operators
Other operators and syntax
Bitwise operators
Summary
11
Parts of Syntax and Scope
Parts of Syntax and Scope
Expressions, statements, and blocks
Scopes and declarations
Summary
12
Control Flow
Control Flow
What is control flow?
Imperative versus declarative programming
The movement of control
Statements of control flow
Handling cyclomatic complexity
Asynchronous control flow
Summary
13
Section 3: Crafting Abstractions
Section 3: Crafting Abstractions
14
Design Patterns
Design Patterns
The perspective of a designer
Architectural design patterns
JavaScript modules
Modular design patterns
Planning and harmony
Summary
15
Real-World Challenges
Real-World Challenges
The DOM and single-page applications
Dependency management
Security
Summary
16
Section 4: Testing and Tooling
Section 4: Testing and Tooling
17
The Landscape of Testing
The Landscape of Testing
What is a test?
Types of testing
Test-Driven Development
Summary
18
Writing Clean Tests
Writing Clean Tests
Testing the right thing
Writing intuitive assertions
Creating clear hierarchies
Providing final clarity
Creating clean directory structures
Summary
19
Tools for Cleaner Code
Tools for Cleaner Code
Linters and formatters
Static typing
E2E testing tools
Automated builds and CI
Summary
20
Section 5: Collaboration and Making Changes
Section 5: Collaboration and Making Changes
21
Documenting Your Code
Documenting Your Code
Aspects of clean documentation
Documentation is everywhere
Writing for non-technical audiences
Summary
22
Other Peoples' Code
Other Peoples' Code
Inheriting code
Dealing with third-party code
Summary
23
Communication and Advocacy
Communication and Advocacy
Planning and setting requirements
Communication strategies
Identifying issues and driving change
Summary
24
Case Study
Case Study
The problem
The design
The implementation
Summary
25
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Setting the Scene

JavaScript was created by Brendan Eich in 1995, with the goal of being a glue language. It was intended to help web designers and amateurs easily manipulate and derive behavior from their HTML. JavaScript was able to do this via the DOM API, a set of interfaces provided by the browser that would give access to the parsed representation of HTML. Soon after this, DHTML became the popular term, referring to the more dynamic user interfaces that JavaScript enabled: everything from animated rollover button states to client-side form validation. Eventually came the rise of Ajax, which enabled communication between the client and the server. This opened up a considerable fountain of potential applications. The web, previously purely the domain of documents, was now on the way to becoming a powerhouse of processor- and memory-intensive applications:

In 1995, nobody could have predicted that JavaScript would one day be used to build complex web applications, program robots, query databases, write plugins for photo manipulation software, and be behind one of the most popular server runtimes in existence, Node.js.

In 1997, not long after its creation, JavaScript was standardized by Ecma International under the name ECMAScript, and it is still undergoing frequent changes under the TC39 committee. Most recent versions of the language have been named according to the year of their release, such as ECMAScript 2020 (ES2020).

Due to its burgeoning capabilities, JavaScript has attracted a passionate community that drives its growth and ubiquity. And due to its considerable popularity, there are now countless different ways to do the same thing in JavaScript. There are thousands of popular frameworks, libraries, and utilities. The language too is changing on a near-constant basis in reaction to the increasing demands of its applications. This creates a great challenge: among all of this change, while being pushed and pulled in different directions, how can we know how to write the best possible code? Which frameworks should we use? What conventions should we employ? How should we test our code? How should we craft sensible abstractions?

To answer these questions, we need to briefly go back to basics. And that is the purpose of this chapter. We'll be discussing the following:

  • What the true purpose of the code is
  • Who our users are and what problems they have
  • What it means to write code for humans
Previous Section
End of Section 1
Next Section