Return to home page
Searching: Muskingum library catalog

LEADER 00000cam  2200685Ii 4500 
001    934096903 
003    OCoLC 
005    20181130031634.5 
006    m     o  d         
007    cr cnu|||unuuu 
008    160108t20162016caua    ob    001 0 eng d 
019    934046473|a934197934|a936117873|a985061124|a1005815884
       |a1008950372|a1012078273|a1026452521|a1048145530
       |a1066433653|a1066581545 
020    9781484211762|q(electronic bk.) 
020    1484211766|q(electronic bk.) 
020    |z9781484211779 
020    |z1484211774 
024 7  10.1007/978-1-4842-1176-2|2doi 
035    (OCoLC)934096903|z(OCoLC)934046473|z(OCoLC)934197934
       |z(OCoLC)936117873|z(OCoLC)985061124|z(OCoLC)1005815884
       |z(OCoLC)1008950372|z(OCoLC)1012078273|z(OCoLC)1026452521
       |z(OCoLC)1048145530|z(OCoLC)1066433653|z(OCoLC)1066581545 
037    884369|bMIL 
040    GW5XE|beng|erda|epn|cGW5XE|dN$T|dOCLCF|dYDXCP|dAZU|dCDX
       |dIDEBK|dEBLCP|dDEBSZ|dCOO|dOCLCQ|dK6U|dIDB|dUAB|dIAD|dJBG
       |dICW|dVT2|dZ5A|dILO|dICN|dLIV|dOCLCQ|dMERUC|dESU|dOCLCQ
       |dIOG|dU3W|dD6H|dVVB|dEZ9|dREB|dINT|dWYU 
049    MAIN 
050  4 QA76.73.L23 
072  7 UY|2bicssc 
072  7 COM014000|2bisacsh 
072  7 COM|x051310|2bisacsh 
072  7 COM|x051280|2bisacsh 
072  7 COM|x051130|2bisacsh 
082 04 005.13/3|223 
100 1  Weitz, E.|q(Edmund),|d1965-|0http://id.loc.gov/authorities
       /names/n99046695|eauthor. 
245 10 Common LISP recipes :|ba problem-solution approach /
       |cEdmund Weitz. 
246 3  Common List processing computer language recipes 
264  1 [Berkeley, California] :|bApress,|c2016. 
264  2 New York, NY :|bDistributed to the Book trade worldwide by
       Springer 
264  4 |c2016 
300    1 online resource (xxvii, 744 pages) :|billustrations. 
336    text|btxt|2rdacontent 
337    computer|bc|2rdamedia 
338    online resource|bcr|2rdacarrier 
340    |gpolychrome|2rdacc|0http://rdaregistry.info/termList/
       RDAColourContent/1003 
490 1  The expert's voice in LISP 
504    Includes bibliographical references and index. 
505 00 Machine generated contents note:|g1.|tSymbols and Packages
       --|g1-1.|tUnderstanding the Role of Packages and the 
       Symbol Nomenclature --|g1-2.|tMaking Unique Symbols --|g1-
       3.|tMaking Symbols Inaccessible --|tHow Can We Fix This? -
       -|g1-4.|tAvoiding Name Conflicts --|tWhen Name Conflicts 
       Do Not Occur --|g1-5.|tUsing Symbols As Stand-Ins for 
       Arbitrary Forms --|g1-6.|tSearching for Symbols by Name --
       |g1-7.|tIterating Through All Symbols of a Package --
       |tWhat To Do If You Don't Like LOOP --|g1-8.
       |tUnderstanding Common Lisp's Case (In)Sensitivity --
       |tStyle Hint: Don't Use CamelCase! --|g1-9.|tUsing Symbols
       As String Substitutes --|tSo, What Should You Use? --|g1-
       10.|t"Overloading" of Standard Common Lisp Operators --
       |g2.|tConses, Lists, and Trees --|g2-1.|tUnderstanding 
       Conses --|tList Access --|tTesting Whether Something Is a 
       Cons or a List --|g2-2.|tCreating Lists --|tConverting 
       Vectors to Lists --|g2-3.|tTransposing a Matrix --|g2-4.
       |tUsing List Interpolation --|g2-5.|tAdding Objects to the
       End of a List --|tTail Wagging the List --|g2-6.
       |t"Splicing" into a List --|g2-7.|tDetecting Shared 
       Structure in Lists --|tIsolating the Non-Shared Part --|g2
       -8.|tWorking with Trees --|tMore Complicated Trees --
       |tCommon Lisp's Standard Tree Functions --|g2-9.|tWorking 
       with Stacks --|g2-10.|tImplementing a Queue --|g2-11.
       |tDestructuring and Pattern Matching --|g3.|tStrings and 
       Characters --|g3-1.|tGetting the ASCII Code of a Character
       --|tOther Way Around --|tLimit --|g3-2.|tNaming Characters
       --|g3-3.|tUsing Different Character Encodings --|g3-4.
       |tComparing Strings or Characters --|tInternationalization
       --|g3-5.|tEscaping Characters in String Literals and 
       Variable Interpolation --|tIs It Still a Literal? --|g3-6.
       |tControlling Case --|tWhat About Unicode? --|g3-7.
       |tAccessing or Modifying a Substring --|g3-8.|tFinding a 
       Character or a Substring Within a String --|g3-9.
       |tTrimming Strings --|g3-10.|tProcessing a String One 
       Character at a Time --|g3-11.|tJoining Strings --|g3-12.
       |tReading CSV Data --|g4.|tNumbers and Math --|g4-1.
       |tUsing Arbitrarily Large Integers --|g4-2.|tUnderstanding
       Fixnums --|g4-3.|tPerforming Modular Arithmetic --
       |tEfficiency Considerations --|g4-4.|tSwitching Bases --
       |g4-5.|tPerforming Exact Arithmetic with Rational Numbers 
       --|tVarious Ways of Converting Numbers to Integers --|tHow
       Not to Use FLOOR and Friends --|tConverting Floating-Point
       Numbers to Rationals and Vice Versa --|tMixing Rationals 
       and Floats --|g4-6.|tControlling the Default Float Format 
       --|g4-7.|tEmploying Arbitrary Precision Floats --|g4-8.
       |tWorking with Complex Numbers --|g4-9.|tParsing Numbers -
       -|g4-10.|tTesting Whether Two Numbers Are Equal --|tDon't 
       Ever Use EQ with Numbers! --|g4-11.|tComputing Angles 
       Correctly --|g4-12.|tCalculating Exact Square Roots --|g5.
       |tArrays and Vectors --|g5-1.|tWorking with Multiple 
       Dimensions --|g5-2.|tUnderstanding Vectors and Simple 
       Arrays --|g5-3.|tObtaining the Size of an Array --|g5-4.
       |tProviding Initial Contents --|tWarning About Identical 
       Objects --|g5-5.|tTreating Arrays As Vectors --|g5-6.
       |tMaking the Length of Vectors Flexible --|g5-7.
       |tAdjusting Arrays --|g5-8.|tUsing an Array As a "Window" 
       into Another Array --|g5-9.|tRestricting the Element Type 
       of an Array --|tUpgrading Element Types --|g5-10.|tCopying
       an Array --|tWarning About Object Identity --|g6.|tHash 
       Tables, Maps, and Sets --|g6-1.|tUnderstanding the Basics 
       of Hash Tables --|tWhy Does GETHASH Return Two Values? --
       |tHow Many Entries Does the Hash Table Have? --|g6-2.
       |tProviding Default Values For Hash Table Lookups --|g6-3.
       |tRemoving Hash Table Entries --|g6-4.|tIterating Through 
       a Hash Table --|tDon't Rely on Any Order! --|tDon't Modify
       While You're Iterating! --|tCan't This Be More Concise, 
       Please? --|g6-5.|tUnderstanding Hash Table Tests and 
       Defining Your Own --|tWhat Is SXHASH For? --|g6-6.
       |tControlling Hash Table Growth --|g6-7.|tGetting Rid of 
       Hash Table Entries Automatically --|g6-8.|tRepresenting 
       Maps As Association Lists --|tCombining Lookup and 
       Manipulation --|tWhy Would Anybody Prefer Alists over Hash
       Tables? --|g6-9.|tRepresenting Maps As Property Lists --
       |tWhen to Prefer Plists over Alists --|tPlist of a Symbol 
       --|g6-10.|tWorking with Sets --|tRepresenting Sets As Hash
       Tables --|tRepresenting Sets As Bit Patterns --|g7.
       |tSequences and Iteration --|g7-1.|tFiltering a Sequence -
       -|g7-2.|tSearching a Sequence --|g7-3.|tSorting and 
       Merging Sequences --|g7-4.|tMixing Different Sequence 
       Types --|g7-5.|tRe-Using a Part of a Sequence --|g7-6.
       |tRepeating Some Values Cyclically --|tAlternatives --|g7-
       7.|tCounting Down --|g7-8.|tIterating over "Chunks" of a 
       List --|g7-9.|tClosing over Iteration Variables --|g7-10.
       |t"Extending" Short Sequences in Iterations --|g7-11.
       |tBreaking out of LOOP --|g7-12.|tMaking Sense of the MAP 
       ... 
505 00 |tZoo --|tSequence Variants --|g7-13.|tDefining Your Own 
       Sequence Types --|g7-14.|tIterating with Iterate --|g7-15.
       |tIterating with Series --|tWhat the Example Does --|g8.
       |tLisp Reader --|g8-1.|tEmploying the Lisp Reader for Your
       Own Code --|tWhy READ Is Potentially Dangerous --|tWhat 
       READ Doesn't Do --|tOptional Arguments to READ --|tGo 
       Wild! --|g8-2.|tTroubleshooting Literal Object Notation --
       |tThis Also Applies to Strings! --|g8-3.|tEvaluating Forms
       at Read Time --|tWhat to Look Out For --|tAlternatives --
       |g8-4.|tEmbedding Literal Arrays into Your Code --|tUsual 
       Warning --|g8-5.|tUnderstanding the Different Ways to 
       Refer to a Function --|g8-6.|tRepeating Something You 
       Already Typed --|tThey Don't Only Look Identical, They Are
       Identical! --|g8-7.|tSafely Experimenting with Read tables
       --|tTemporarily Switching to Standard IO Syntax --|g8-8.
       |tChanging the Syntax Type of a Character --|tSix Syntax 
       Types --|tHow to Actually Change the Syntax Type --|tSome 
       Things Never Change --|g8-9.|tCreating Your Own Reader 
       Macros --|tWhat Reader Macro Functions Do --|g8-10.
       |tWorking with Dispatching Macro Characters --|g8-11.
       |tPreserving Whitespace --|g9.|tPrinting --|g9-1.|tUsing 
       the Printing Primitives --|tPrinting Objects So That They 
       Can Be Read Back in Again --|tShortcuts --|g9-2.|tPrinting
       to and into Strings --|g9-3.|tPrinting NIL As a List --|g9
       -4.|tExtending FORMAT Control Strings Over More Than One 
       Line --|g9-5.|tUsing Functions As FORMAT Controls --|g9-6.
       |tCreating Your Own FORMAT Directives --|g9-7.|tRecursive 
       Processing of FORMAT Controls --|g9-8.|tControlling How 
       Your Own Objects Are Printed --|g9-9.|tControlling the 
       Pretty Printer --|g9-10.|tPrinting Long Lists --|g9-11.
       |tPretty-Printing Compound Objects --|tUsing the Pretty 
       Printer from FORMAT --|g9-12.|tModifying the Pretty 
       Printer --|g10.|tEvaluation, Compilation, Control Flow --
       |g10-1.|tComparing Arbitrary Lisp Objects --|tComparing 
       State --|tConstants --|g10-2.|tUsing Constant Variables as
       Keys in CASE Macros --|g10-3.|tUsing Arbitrary Variable 
       Names for Keyword Parameters --|tKeyword Names Don't Have 
       to Be Keywords --|tKeyword Dames Don't Have to Be Constant
       --|g10-4.|tCreating "Static Local Variables," Like in C --
       |g10-5.|t"Preponing" the Computation of Values --|g10-6.
       |tModifying the Behavior of Functions You Don't Have the 
       Source Of --|g10-7.|tSwapping the Values of Variables (or 
       Places) --|g10-8.|tCreating Your Own Update Forms for 
       "Places" --|tUsing DEFSETF --|tUsing DEFINE -- SETF -- 
       EXPANDER --|tSo, Which One Do I Use? --|tUsing DEFINE -- 
       MODIFY -- MACRO --|tMultiple-Valued Places --|g10-9.
       |tWorking with Environments --|g10-10.|tCommenting Out 
       Parts of Your Code --|tSome Notes About; and #I --|tHow;, 
       #I, and Others Are Implemented --|g11.|tConcurrency --|g11
       -1.|tManaging Lisp Processes --|tEscape Hatches --
       |tThreads Are Expensive --|g11-2.|tAccessing Shared 
       Resources Concurrently --|tLocks --|tAtomic Operations --
       |tMore Problems --|g11-3.|tUsing Special Variables in 
       Concurrent Programs --|tPer-Thread Initial Bindings --
       |tVariables That Are Always Global --|g11-4.
       |tCommunicating with Other Threads --|tAlternatives --|g11
       -5.|tParallelizing Algorithms Without Threads and Locks --
       |tWhat the Example Does --|tFine-Tuning --|tPtrees --
       |tAlternatives --|g11-6.|tDetermining the Number of Cores 
       --|g12.|tError Handling and Avoidance --|g12-1.|tChecking 
       Types at Run Time --|tAlternatives --|g12-2.|tAdding 
       Assertions to Your Code --|tDisabling Assertions in 
       "Production Code" --|g12-3.|tDefining Your Own Conditions 
       --|tHow Conditions Are Printed --|g12-4.|tSignaling a 
       Condition --|tCondition Designators --|g12-5.|tHandling 
       Conditions --|tIgnoring Errors --|g12-6.|tProviding and 
       Using Restarts --|tVisible Restarts --|tPredefined 
       Restarts --|g12-7.|tGetting Rid of Warning Messages --|g12
       -8.|tProtecting Code from Non-Local Exits --|t"WITH -- " 
       Macros --|g13.|tObjects, Classes, Types --|g13-1.
       |tDefining Types --|tCompound Type Specifiers --|tDerived 
       Types --|g13-2.|tUsing Classes As Types --|g13-3.|tWriting
       Methods for Built-In Classes --|g13-4.|tProviding 
       Constructors for Your Classes --|g13-5.|tMarking Slots As 
       "Private" --|g13-6.|tChanging the Argument Precedence 
       Order --|g13-7.|tAutomatically Initializing Slots on First
       Usage --|g13-8.|tChanging and Redefining Classes on the 
       Fly --|tObjects Changing Their Class --|tRedefining 
       Classes --|g13-9.|tMaking Your Objects Externalizable --
       |g13-10.|tUsing and Defining Non-Standard Method 
       Combinations --|tRolling Your Own --|tArbitrarily Complex 
       Method Combinations --|g13-11.|tExtending and Modifying 
       CLOS --|tWhat the example does --|g14.|tI/O: Streams and 
       Files --|g14-1.|tRedirecting Streams --|tOther Ways to Do 
       It --|tSynonym Streams --|g14-2.|tFlushing an Output 
       Stream --|g14-3.|tDetermining the Size of a File --|g14-4.
       |tReading a Whole File at Once --|tAlternatives --|g14-5.
       |tSending Data to Two Streams in Parallel --|tSynonym 
       Streams --|g14-6.|tSending Data to "/dev/null" 
505 00 Note continued:|g14-7.|tPretending a String Is a Stream --
       |tMore Details --|g14-8.|tConcatenating Streams --|g14-9.
       |tProcessing Text Files Line by Line --|tWhat Happens at 
       the End of a Line? --|tWhat Happens at the End of the 
       File? --|g14-10.|tWorking with Binary Data --|tReading or 
       Writing Several Bytes at Once --|tYou Might Get Bigger 
       Chunks Than You Asked For --|g14-11.|tReading "Foreign" 
       Binary Data --|tFloating-Point Values --|g14-12.|tUsing 
       Random Access I/O --|tDifferent Characters May Have 
       Different Lengths --|g14-13.|tSerializing Lisp Objects --
       |tShared Structure --|tIs It Readable? --|tCan This Be 
       Done Faster, Please? --|tWhat About JSON or Other Formats?
       --|g14-14.|tCustomizing Stream Behavior --|g15.|tPathnames,
       Files, Directories --|g15-1.|tGetting and Setting the 
       Current Directory --|tShortcuts and Deviations --|g15-2.
       |tTesting Whether a File Exists --|tWhat About 
       Directories? --|g15-3.|tCreating a Directory --
       |tImplementation-Specific Alternatives --|tWhat Might Go 
       Wrong --|g15-4.|tFinding Files Matching a Pattern --|g15-
       5.|tSplitting a Filename into its Component Parts --|g15-
       6.|tRenaming a File --|tImplementation-Specific 
       Alternatives --|tDon't Expect "Move" Behavior! --|g15-7.
       |tDeleting a File --|tWhat Does "Success" Mean Anyway? --
       |g15-8.|tDeleting a Directory --|g15-9.|tCopying a File --
       |g15-10.|tProcessing the Contents of a Directory 
       Recursively --|tCL-FAD Library --|g15-11.|tGetting the 
       Pathname a Stream Is Associated With --|g15-12.|tDealing 
       with Symbolic Links --|tWhat If I Want the Symlinks? --
       |g15-13.|tNavigating a Directory Tree --|g15-14.|tFiguring
       Out (Source) File Locations Programmatically --|g15-15.
       |tUnderstanding Logical Pathnames --|tWhat Exactly Are 
       Logical Pathnames? --|tSo, Maybe Logical Pathnames Aren't 
       Totally Useless --|g16.|tDeveloping and Debugging --|g16-
       1.|tEmbracing Lisp's Image-Based Development Style --
       |tRole of the Source Code --|g16-2.|tDeciding Which IDE to
       Use --|tBrief History of Emacs (As Seen from Lisp) --
       |tAlternatives (?) --|g16-3.|tDebugging with the Debugger 
       --|tEntering the Debugger Intentionally --|tWithout SLIME 
       --|tLogging Backtraces --|g16-4.|tTracing Functions --
       |tGraphical Tracing --|g16-5.|tStepping Through Your Code 
       --|g16-6.|tAcquiring Information About Functions, Macros, 
       and Variables --|tAccessing the HyperSpec --|tCross-
       Reference Information --|g16-7.|tInspecting and Modifying 
       (Compound) Objects --|tSLIME Inspector --|g16-8.|tBrowsing
       Your Lisp Image --|tAlternatives --|g16-9.|t"Undoing" 
       Definitions --|g16-10.|tDistinguishing Your IDE's Streams 
       --|g16-11.|tUtilizing the REPL's Memory --|tIDE History 
       Features --|g16-12.|tRecording Your Work --|g17.
       |tOptimization --|g17-1.|tUnderstanding the Importance of 
       the Right Algorithms --|g17-2.|tDeciding If and Where to 
       Optimize --|tInstrumentation --|tStatistical Profiling --
       |tSome Things Cannot Be Profiled --|tWhere to Go From Here
       --|tWarning About Empirical Data --|tWhat Does TIME Do? --
       |tCPUs Can Deceive You --|g17-3.|tAsking the Compiler to 
       Optimize --|tImplementation-Defined Optimize Qualities --
       |tCan I Have This Global, Please? --|tCompilers Aren't 
       Wizards --|g17-4.|tObtaining Optimization Hints from the 
       Compiler --|g17-5.|tHelping the Compiler by Providing Type
       Information --|tGeneric Operations --|tBoxing --|tHow to 
       Declare Types --|tScope of Type Declarations --|tDeclaring
       the Return Type of Forms --|tType Inference --|tPitfalls -
       -|g17-6.|tReducing "Consing" --|t"Consing" and the Heap --
       |tReusing Data Structures --|tDestructive Functions --
       |t"Hidden" Consing --|t"Tuning" the Garbage Collector --
       |g17-7.|tUsing the Stack Instead of the Heap --|tMultiple 
       Values --|g17-8.|tOptimizing Recursive Functions --|g17-9.
       |tHelping the Compiler with Alternative Implementation 
       Strategies --|g17-10.|tAvoiding Repeated Computations --
       |g17-11.|tAvoiding Function Calls --|tAlternatives That 
       Aren't Really Alternatives --|tNotinline Declaration and 
       Compiler Macros --|g17-12.|tUtilizing the Disassembler --
       |g17-13.|tSwitching to Machine Code --|tInline Assembly 
       Code --|g17-14.|tOptimizing Array Access --|g17-15.
       |tComparing Different Implementations --|g18.|tLibraries -
       -|g18-1.|tOrganizing Your Code --|tComponents --
       |tDependencies --|tHow Does ASDF Find System Definitions? 
       --|tAdditional Information --|tWhat About the Names? --
       |tAdvanced Usage of ASDF --|g18-2.|tEmploying Open Source 
       Libraries --|tInstalling Quicklisp --|tUsing Quicklisp for
       Your Own Code --|g18-3.|tCreating a Project's Skeleton 
       Automatically --|g18-4.|tAvoiding Wheel-Reinvention --|g18
       -5.|tUsing Libraries to Write Portable Code --|g18-6.
       |tUtilizing Regular Expressions --|tRegex Syntax --
       |tScanners --|tConvenience Features --|tModifying and 
       Dissecting Strings --|tMore Information --|g18-7.
       |tObtaining Data via HTTP --|tParsing HTML --|g18-8.
       |tCreating Dynamic Web Sites with Lisp --|tGenerating HTML
       --|tWeb Frameworks --|g19.|tInterfacing with Other 
       Languages --|g19-1.|tCalling C Functions from Lisp --|tHow
       the FFI Finds and Loads Shared Libraries --|tHow the FFI 
       Calls C Functions --|tHow the FFI Converts Between C and 
       Lisp Types --|t"stdcall Problem" --|g19-2.|tWorking with C
       Pointers --|tTyped Pointers --|g19-3.|tAccessing and 
       Generating C Arrays --|tGiving C Access to Lisp Arrays --
       |g19-4.|tHandling C Structs and Unions --|tPassing Structs
       by Value --|g19-5.|tConverting Between Lisp and C Strings 
       --|g19-6.|tCalling Lisp Functions from C --|g19-7.
       |tGenerating FFI Code Automatically --|g19-8.|tEmbedding C
       in Common Lisp --|g19-9.|tCalling C++ from Lisp --
       |tAutomating the Process --|tECL and Clasp --|g19-10.
       |tUsing Java from Lisp --|tAlternatives --|g19-11.
       |tReading and Writing JSON --|g19-12.|tReading and Writing
       XML --|g19-13.|tUsing Prolog from Common Lisp --|g20.
       |tGraphical User Interfaces --|g20-1.|tUsing a Web Browser
       as the GUI for Your Lisp Program --|tWhat the Example Does
       --|g20-2.|tBuilding Applications with the "Lisp Toolkit" -
       -|tWhat the Example Does --|g20-3.|tCreating Common Lisp 
       GUIs Through Java --|tWhat the Example Does --|tBetter 
       Example --|g20-4.|tUsing CAPI to Build Graphical User 
       Interfaces --|tWhat the Example Does --|g20-5.|tUsing Lisp
       on Mobile Devices --|tAlternatives --|g21.|tPersistence --
       |g21-1.|tSerializing Your Data --|g21-2.|tAccessing 
       Relational Databases --|g21-3.|tKeeping Your Database in 
       RAM --|g21-4.|tUsing a Lisp Object Database --|g22.|tWorld
       Outside --|g22-1.|tAccessing Environment Variables --
       |tWindows Registry and Application-Specific Settings --
       |g22-2.|tAccessing the Command-Line Arguments --|g22-3.
       |tQuerying Your Lisp for Information About Its Environment
       --|g22-4.|tDelivering Stand-Alone Executables --
       |tDelivering Programs with the Commercial Lisps --|g22-5.
       |tCustomizing Your Lisp --|tSaving an Image --|g22-6.
       |tRunning External Programs --|g22-7.|tEmbedding Lisp --
       |tCreating Shared Libraries with LispWorks --|tEmbedding 
       ABCL in a JAVA Program --|g22-8.|tMeasuring Time --|g22-9.
       |tWorking with Dates and Times --|tLocal-Time Library --
       |g22-10.|tWorking with the Garbage Collector --
       |tFinalizers. 
520    Find solutions to problems and answers to questions you 
       are likely to encounter when writing real-world 
       applications in Common Lisp. This book covers areas as 
       diverse as web programming, databases, graphical user 
       interfaces, integration with other programming languages, 
       multi-threading, and mobile devices as well as debugging 
       techniques and optimization, to name just a few. Written 
       by an author who has used Common Lisp in many successful 
       commercial projects over more than a decade, Common Lisp 
       Recipes is also the first Common Lisp book to tackle such 
       advanced topics as environment access, logical pathnames, 
       Gray streams, delivery of executables, pretty printing, 
       setf expansions, or changing the syntax of Common Lisp. 
       The book is organized around specific problems or 
       questions each followed by ready-to-use example solutions 
       and clear explanations of the concepts involved, plus 
       pointers to alternatives and more information. Each recipe
       can be read independently of the others and thus the book 
       will earn a special place on your bookshelf as a reference
       work you always want to have within reach. Common Lisp 
       Recipes is aimed at programmers who are already familiar 
       with Common Lisp to a certain extent but do not yet have 
       the experience you typically only get from years of 
       hacking in a specific computer language. It is written in 
       a style that mixes hands-on no-frills pragmatism with 
       precise information and prudent mentorship. If you feel 
       attracted to Common Lisp's mix of breathtaking features 
       and down-to-earth utilitarianism, you'll also like this 
       book. 
588 0  Online resource; title from PDF title page (SpringerLink, 
       viewed January 8, 2016). 
650  0 LISP (Computer program language)|0http://id.loc.gov/
       authorities/subjects/sh85077449 
650 14 Computer Science. 
650 24 Computer Science, general. 
655  0 Electronic book. 
655  4 Electronic books. 
776 08 |iPrint version:|aWeitz, E. (Edmund), 1965-|tCommon LISP 
       recipes.|z1484211774|z9781484211779|w(OCoLC)920847127 
830  0 Expert's voice in LISP. 
990    SpringerLink|bSpringer English/International eBooks 2016 -
       Full Set|c2018-11-30|yMaster record variable field(s) 
       change: 650|5OH1 
990    SpringerLink|bSpringer English/International eBooks 2016 -
       Full Set|c2018-10-31|yNew collection 
       springerlink.ebooks2016|5OH1 
LOCATION CALL # STATUS MESSAGE
 OHIOLINK SPRINGER EBOOKS    ONLINE  
View online