Greg Wilson

Software Design by Example

A Tool-Based Introduction with JavaScript

• Broschiertes Buch

Produktbeschreibung

This book can be used for self-paced study, in an undergraduate course on software design, or as the core of an intensive weeklong workshop for working programmers. Each chapter has a set of exercises ranging in size and difficulty from half a dozen lines to a full day's work.

Produktdetails

• Verlag: Taylor & Francis Ltd
• Seitenzahl: 329
• Erscheinungstermin: 29. Dezember 2022
• Englisch
• Abmessung: 253mm x 178mm x 30mm
• Gewicht: 646g
• ISBN-13: 9781032330235
• ISBN-10: 1032330236
• Artikelnr.: 65614107

Autorenporträt

Greg Wilson has worked in industry and academia for 35 years, and is the author, coauthor, or editor of several books, including Beautiful Code, The Architecture of Open Source Applications, JavaScript for Data Science, Teaching Tech Together, and Research Software Engineering with Python. He is the co-founder and first executive director of Software Carpentry and received ACM SIGSOFT's Influential Educator Award in 2020.

Inhaltsangabe

1. Introduction. 1.1. Who is our audience? 1.2. What tools and ideas do we
cover? 1.3. How are these lessons laid out? 1.4. How did we get here? 1.5.
How can people use and contribute to this material? 1.6. Who helped us? 2.
Systems Programming. 2.1. How can we list a directory? 2.2. What is a
callback function? 2.3. What are anonymous functions? 2.4. How can we
select a set of files? 2.5. How can we copy a set of files? 2.6. Exercises.
3. Asynchronous Programming. 3.1. How can we manage asynchronous execution?
3.2. How do promises work? 3.3. How can we chain operations together? 3.4.
How are real promises different? 3.5. How can we build tools with promises?
3.6. How can we make this more readable? 3.7. How can we handle errors with
asynchronous code? 3.8. Exercises. 4. Unit Testing. 4.1. How should we
structure unit testing? 4.2. How can we separate registration, execution,
and reporting? 4.3. How should we structure test registration? 4.4. How can
we build a command-line interface for testing? 4.5. Exercises. 5. File
Backup. 5.1. How can we uniquely identify files? 5.2. How can we back up
files? 5.3. How can we track which files have already been backed up? 5.4.
How can we test code that modifies files? 5.5. Exercises. 6. Data Tables.
6.1. How can we implement data tables? 6.2. How can we test the performance
of our implementations? 6.3. What is the most efficient way to save a
table? 6.4. Does binary storage improve performance? 6.5. Exercises. 7.
Pattern Matching. 7.1. How can we match query selectors? 7.2. How can we
implement a simple regular expression matcher? 7.3. How can we implement an
extensible matcher? 7.4. Exercises. 8. Parsing Expressions. 8.1. How can we
break text into tokens? 8.2. How can we turn a list of tokens into a tree?
8.3. Exercises. 9. Page Templates. 9.1. What will our system look like?
9.2. How can we keep track of values? 9.3. How do we handle nodes? 9.4. How
do we implement node handlers? 9.5. How can we implement control flow? 9.6.
How did we know how to do all of this? 9.7. Exercises. 10. Build Manager.
10.1. What's in a build manager? 10.2. Where should we start? 10.3. How can
we specify that a file is out of date? 10.4. How can we update out-of-date
files? 10.5. How can we add generic build rules? 10.6. What should we do
next? 10.7. Exercises. 11. Layout Engine. 11.1. How can we size rows and
columns? 11.2. How can we position rows and columns? 11.3. How can we
render elements? 11.4. How can we wrap elements to fit? 11.5. What subset
of CSS will we support? 11.6. Exercises. 12. File Interpolator. 12.1. How
can we evaluate JavaScript dynamically? 12.2. How can we manage files?
12.3. How can we find files? 12.4. How can we interpolate pieces of code?
12.5. What did we do instead? 12.6. Exercises. 13. Module Loader. 13.1. How
can we implement namespaces? 13.2. How can we load a module? 13.3. Do we
need to handle circular dependencies? 13.4. How can a module load another
module? 13.5. Exercises. 14. Style Checker. 14.1. How can we parse
JavaScript to create an AST? 14.2. How can we find things in an AST? 14.3.
How can we apply checks? 14.4. How does the AST walker work? 14.5. How else
could the AST walker work? 14.6. What other kinds of analysis can we do?
14.7. Exercises. 15. Code Generator. 15.1. How can we replace a function
with another function? 15.2. How can we generate JavaScript? 15.3. How can
we count how often functions are executed? 15.4. How can we time function
execution? 15.5. Exercises. 16. Documentation Generator. 16.1. How can we
extract documentation comments? 16.2. What input will we try to handle?
16.3. How can we avoid duplicating names? 16.4. Exercises. 17. Module
Bundler. 17.1. What will we use as test cases? 17.2. How can we find
dependencies? 17.3. How can we safely combine several files into one? 17.4.
How can files access each other? 17.5. Exercises. 18. Package Manager.
18.1. What is semantic versioning? 18.2. How can we find a consistent set
of packages? 18.3. How can we satisfy constraints? 18.4. How can we do less
work? 18.5. Exercises. 19. Virtual Machine. 19.1. What is the architecture
of our virtual machine? 19.2. How can we execute these instructions? 19.3.
What do assembly programs look like? 19.4. How can we store data? 19.5.
Exercises. 20. Debugger. 20.1. What is our starting point? 20.2. How can we
make a tracing debugger? 20.3. How can we make the debugger interactive?
20.4. How can we test an interactive application? 20.5. Exercises. 21.
Conclusion.