CF

Refactoring to Collections

4h 44m 21s
English
Paid

Refactoring to Collections is a 28-lesson 4 hours 44 minutes self-paced course by Adam Wathan. Learn how to craft simple, elegant code that's a pleasure to write and a joy to maintain.

Course facts

Lessons
28
Duration
4 hours 44 minutes
Level
All levels
Language
English
Updated
Instructor
Adam Wathan
Price
Premium

Learn how to craft simple, elegant code that's a pleasure to write and a joy to maintain. Learn how to use collection pipelines to break down ugly, complex functions into a series of simple transformations, free of loops, complex conditionals, and temporary variables.

Who teaches Refactoring to Collections? Adam Wathan

Adam Wathan thumbnail

Adam Wathan is the creator of Tailwind CSS — the utility-first CSS framework that has reshaped how front-end engineers write styles since its 2017 release. He is also a co-founder of Tailwind Labs (the company behind Tailwind CSS, Tailwind UI, Headless UI, and Heroicons), the host of the Full Stack Radio podcast, and the author of Refactoring UI (with Steve Schoger).

His paid course catalog covers Tailwind CSS in depth (the framework's design philosophy, advanced patterns, plugin authoring), the broader modern CSS landscape, refactoring patterns for UI work, advanced Vue.js (he was a long-running Vue advocate before Tailwind became the primary work), Test-Driven Laravel, and the design-engineering boundary material that bridges UI design and front-end implementation.

The CourseFlix listing under this source carries 5 Adam Wathan courses spanning that range. Material is paid; Adam's courses are sold individually on adamwathan.me on the original platform. Courses are aimed at developers and designers serious about the craft of building interfaces.

What lessons are included in Refactoring to Collections?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 28 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Pricing Lamps and Wallets
All Course Lessons (28)
#Lesson TitleDurationAccess
1
Pricing Lamps and Wallets Demo
20:45
2
CSV Surgery 101
06:31
3
Binary to Decimal
10:46
4
What's your GitHub Score
16:38
5
Formatting a Pull Request Comment
08:53
6
Stealing Mail
12:15
7
Choosing a Syntax Handler
15:04
8
Tagging on the Fly
08:45
9
Nitpicking a Pull Request
15:43
10
Comparing Monthly Revenue
06:29
11
Manipulating DNA
07:37
12
Building a Lookup Table
11:05
13
Transposing Form Input
15:06
14
Ranking a Competition
34:19
15
Building a Table of Contents - Intro
03:15
16
Building a Table of Contents - Extracting Headings
07:34
17
Building a Table of Contents - Slice and Dice
16:26
18
Building a Table of Contents - Nesting Headings with Recursion
07:42
19
Building a Table of Contents - Building Markup
08:01
20
Highlighting Code Blocks - Intro
03:21
21
Highlighting Code Blocks - Basic Structure
03:18
22
Highlighting Code Blocks - Slicing out the Code
04:37
23
Highlighting Code Blocks - Introducing chunkBy
10:54
24
Highlighting Code Blocks - Introducing eachCons
10:33
25
Highlighting Code Blocks - Slicing with a Window
02:49
26
Highlighting Code Blocks - Chunking Lines of Code
02:31
27
Highlighting Code Blocks - Self-Rendering Code Blocks
09:39
28
Highlighting Code Blocks - Recap
03:45
Unlock unlimited learning

Get instant access to all 27 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to Refactoring to Collections?

More courses by Adam Wathan

Frequently asked questions

What are the prerequisites for enrolling in this course?
Prospective students should have a basic understanding of programming concepts and familiarity with collection data structures. Experience with functional programming paradigms and basic knowledge of a programming language that supports collections, such as Python or JavaScript, would be beneficial.
What kind of projects or exercises will I work on during the course?
The course includes a variety of exercises such as Pricing Lamps and Wallets, Formatting a Pull Request Comment, and Building a Table of Contents. These exercises focus on transforming complex functions into simple collection pipelines and involve tasks like manipulating DNA and comparing monthly revenue.
Who is the target audience for this course?
This course is aimed at software developers and programmers who are looking to improve their code quality by utilizing collection pipelines. It is especially suitable for those who wish to eliminate loops and complex conditionals from their codebase.
How does this course compare in depth and scope to similar courses?
The course offers a focused approach to refactoring using collection pipelines, with 28 lessons dedicated to specific techniques such as chunking lines of code and building markup. Unlike broader courses, it targets the transformation of complex code into simple, maintainable structures through practical examples.
What specific tools or platforms will be used in this course?
The course emphasizes the use of collection pipelines, which are applicable across various programming languages. While specific tools are not highlighted, the lessons are designed to be adaptable to tools and platforms that support functional programming and collections.
What topics or areas are not covered in this course?
The course does not cover introductory programming concepts or specific language syntax. It assumes a basic understanding of programming languages and does not delve into advanced topics such as concurrency or parallel processing.
What is the time commitment required to complete the course?
The course consists of 28 lessons, each designed to be concise and focused. While the exact runtime is not specified, students should be prepared to dedicate time for watching lessons and completing exercises, allowing for in-depth understanding and application of the concepts.