https://llthw.common-lisp.dev/ [ ] * LEARN LISP THE HARD WAY * Second Draft (in-progress) * CHANGELOG * TODO * FAQ * PREFACE * TANSTAAFL * The Hard Way is Easier * Who Is This Book For? * Configuring Your Development Environment * Lisp: A Future History * Acknowledgements * PART ONE: GROKKING LISP * Overview * Common Lisp Bootcamp + Syntax Overview in 5 Minutes + The REPL + Expressions, Parentheses, and Return Values + Lists, Cons-Cells, and Memory + Symbols and Namespaces + Prefix Notation + Common Lisp Style Guide * Printing, Streams, and Strings + Strings + More Strings + Unicode and Strings + Characters + More Characters + Character Codes + Strings from Chars + Printing + More Printing + Printing With prin1 + Printing With princ + A Brief Introduction to Format + A Little Bit More on Format + Pathnames + Streams + File Streams + Binary Streams + Prompting Users + Pretty-Printing * Extra Credit: Getting Input from Users * Lists and List-Operations + Cons-Cells + Consing + Dot-Notation + More Consing + CAR and CDR + More CAR and CDR + Lists + More Lists + Even More CAR and CDR + Stacks + PUSH and POP + More PUSH and POP + FIRST, REST, and LAST + List Position + Appending + More Appending + Circular Lists + Circular Trees + Quoting + More Quoting * Extra Credit: Look-up Lists and Trees * Numbers and Math + Integers + More Integers + Hexadecimal Integer Notation + Octal Integer Notation + Binary Integer Notation + Ratios and Rational Numbers + Floating-point Numbers + Numeric Constants + Complex Numbers + Arithmetic + More Arithmetic + Even More Arithmetic + Exponents + Logarithms + Trigonometry + Pseudo-Random Numbers * Extra Credit: Arrays and Vectors * Variables, Parameters, and Constants * Extra Credit: Closures * Functions and Macros * Extra Credit: A Simple Text Adventure * Namespaces, Symbols, Packages, and Systems * Extra Credit: A Simple Web Application * Conditionals * Extra Credit: Command-Line Utilities * Mapping and Looping * Extra Credit: Revisiting Loops with Iterate * Format Strings * Extra Credit: Domain Specific Languages * Part One in Review * PART TWO: THE SUFFUSION OF BLUE * Overview * Programming Paradigms * Extra Credit: Regular Expressions * Objects and Control Structures * Extra Credit: Persistence and Databases * Extended Types * Extra Credit: Concurrency and Memoization * Logic and Advanced Math * Extra Credit: Number Theory * Binary Streams, Octet-Vectors, and Bit-Vectors * Extra Credit: An Improved Text Adventure Engine * Conditions and Error Handling * Extra Credit: Write a 2D Game * The Compiler * Extra Credit: Write a Tree-Shaker * Documentation and Inspection * Extra Credit: Foreign Libraries in Lisp * Debugging and Unit Testing * Extra Credit: Write a Foreign Function Interface * Essential Lisp Libraries * Extra Credit: Packaging Lisp Libraries * Detailed Syntax Review * PART THREE: LISP SO(U)RCERY * Overview * Real-world Web Apps * Typesetting * Native Mobile Applications * Cross-platform Desktop Applications * Drivers, Daemons, and System-Utilities * Reverse Engineering * Graphics Rendering * OpenGL, SDL, and 3D Game Development * Audio Generation and Manipulation * Data Aggregation and Analysis * Cryptography and Security * Financial Software and Crypto-Currencies * Scientific Computing * Computational Physics * Quantum Computing * Natural Language Processing * Artificial Intelligence * Robotics * Space Tech * Neuroscience and Thought-Controlled Computing * A Simple LispOS * Build Your Own Lisp Machine * Government and Military Grade Systems * * Published with GitBook Second Draft (in-progress) Learn Lisp The Hard Way (Second Draft, In-Progress) by "the Phoeron" Colin J.E. Lupton ;; Welcome to L(l)THW! (let ((llthw '(learn lisp the hard way))) (format t "~{~@(~A~)~^ ~}, because ~{~A~^ ~} is easier!" llthw (cddr llthw))) ;; Common Lisp: Powerful, Expressive, Programmable, General Purpose, Multi-Paradigm. This is a draft-in-progress edition of Learn Lisp the Hard Way. Content is being constantly added and revised. Please check back often for updates. About the Author "the Phoeron" Colin J.E. Lupton is a full-time open-source developer (and recovering serial entrepreneur). He first discovered the Common Lisp and Scheme programming languages when he was 9 years old and has been in love with the Lisp-family of languages ever since. You can find him online on: * common-lisp.net: @thephoeron * GitHub: @thephoeron * Twitter: @thephoeron Supporting This Project If you would like to show your support for this project, please consider sponsoring the author through GitHub Sponsors: https://github.com/sponsors/thephoeron Recent Updates Learn Lisp The Hard Way is under active development and changes often. For a list of recent updates, please see the CHANGELOG, and for a summary of upcoming changes to look out for, please see the TODO list. You can also check the commit history directly on the source-control repository at: https://gitlab.common-lisp.net/llthw/llthw.common-lisp.dev/-/commits/ master Updates to the LLTHW repository are automatically built and deployed to the live server, typically within 5 minutes or less. Issues To report technical problems with the content of this book, please create an Issue on the source-control repository at: https://gitlab.common-lisp.net/llthw/llthw.common-lisp.dev/-/issues Past Contributors Past contributors from the Toronto Lisp User Group no longer involved in the project include: * Leo "Inaimathi" Zovic * Dann Toliver * Gaelen D'Costa * Josh Teneycke --------------------------------------------------------------------- Creative Commons License Learn Lisp The Hard Way by "the Phoeron" Colin J.E. Lupton is licensed under a Creative Commons Attribution-NoDerivatives 4.0 International License. results matching "" No results matching ""