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

Other Peoples' Code

Humans, being complex and fickle, create complex and fickle things. However, dealing with other people and their code is an unavoidable part of being a programmer. Whether we deal with libraries and frameworks constructed by someone else or inherit entire legacy code bases, the challenges are similar. The first step should always be to seek an understanding of the code and its paradigms. When we have a full understanding of the code, we can begin to interface with it in a clean way, enabling us to create new functionality or make improvements on top of existing work. In this chapter, we'll be exploring this topic in more detail and, through the lens of clean code, considering how we can individually take actions to make other people's code less of a pain to deal with.

In this chapter, we will cover the following topics:

  • Inheriting code
  • Dealing...
Previous Section
End of Section 1
Next Section