Introduction to Lisp. A survey of lisp's history, current incarnations and advanced features such as list comprehensions, macros and domain-specific-language [DSL] support.
Invented by John McCarthy (1958)
Two simple data structure (atoms and lists)
Heavy use of recursion
Interpretive language
Variations
Scheme
Common Lisp (de facto industrial standard)
Most widely used AI programming language
Functional Programming Paradigm
Low maintenance overhead
LISP Language, LISP Introduction, List Processing, LISP Syntax, Lisp Comparison Structures, Lisp Applications. Using of LISP language in Artificial Intelligence
LISP, an acronym for list processing, is a programming language that was designed for easy manipulation of data strings. It is a commonly used language for artificial intelligence (AI) programming.
Invented by John McCarthy (1958)
Two simple data structure (atoms and lists)
Heavy use of recursion
Interpretive language
Variations
Scheme
Common Lisp (de facto industrial standard)
Most widely used AI programming language
Functional Programming Paradigm
Low maintenance overhead
LISP Language, LISP Introduction, List Processing, LISP Syntax, Lisp Comparison Structures, Lisp Applications. Using of LISP language in Artificial Intelligence
LISP, an acronym for list processing, is a programming language that was designed for easy manipulation of data strings. It is a commonly used language for artificial intelligence (AI) programming.
This introduction to Lisp deals with the basis of lists processing. You can see :
* the elementary data structure of Lisp: the S-expressions
* the evaluation rules
* very brief introduction to the Lisp macros
Presentation introducing LISP, looking at the history and concepts behind this powerfull programming language.
Presentation by Tijs van der Storm for the sept 2012 Devnology meetup at the Mirabeau offices in Amsterdam
Slides for a lightning talk on Java 8 lambda expressions I gave at the Near Infinity (www.nearinfinity.com) 2013 spring conference.
The associated sample code is on GitHub at https://github.com/sleberknight/java8-lambda-samples
Big picture of category theory in scala with deep dive into contravariant and...Piotr Paradziński
A big picture of category theory in Scala - starting from regular functors with additional structure (Apply, Applicative, Monad) to Comonads. Usually, we think about structures like Monoids in a monoidal category with particular tensor. In here I analyze just signatures of different abstractions.
Exploration of Contravariant functors as a way to model computation "backward" or abstract over input with the ability to prepend operation. Examples for predicates, sorting, show and function input (or any other function parameter except the last one).
Profunctors as abstraction unifying Functors and Contravariant functors to model both input and output. Example for Profunctor - function with one argument.
Relation to Bifunctors, Kan extensions, Adjunctions, and Free constructions.
Watch video (in Hebrew): http://parleys.com/play/53f7a9cce4b06208c7b7ca1e
Type classes are a fundamental feature of Scala, which allows you to layer new functionality on top of existing types externally, i.e. without modifying or recompiling existing code. When combined with implicits, this is a truly remarkable tool that enables many of the advanced features offered by the Scala library ecosystem. In this talk we'll go back to basics: how type classes are defined and encoded, and cover several prominent use cases.
A talk given at the Underscore meetup on 19 August, 2014.
Quark: A Purely-Functional Scala DSL for Data Processing & AnalyticsJohn De Goes
Quark is a new Scala DSL for data processing and analytics that runs on top of the Quasar Analytics compiler. Quark is adept at processing semi-structured data and compiles query plans to operations that run entirely inside a target data source. In this presentation, John A. De Goes provides an overview of the open source library, showing several use cases in data processing and analytics. John also demonstrates a powerful technique that every developer can use to create their own purely-functional, type-safe DSLs in the Scala programming language.
An overview of the programming techniques available and some of the ongoing research in the Haskell community around concurrent and parallel programming.
Slideshare hasn't imported my notes, so here's the link to the Google Presentation: https://goo.gl/Gl4Vhm
Haskell is a statically typed, non strict, pure functional programming language. It is often talked and blogged about, but rarely used commercially. This talk starts with a brief overview of the language, then explains how Haskell is evaluated and how it deals with non-determinism and side effects using only pure functions. The suitability of Haskell for real world data science is then discussed, along with some examples of its users, a small Haskell-powered visualization, and an overview of useful packages for data science. Finally, Accelerate is introduced, an embedded DSL for array computations on the GPU, and an ongoing attempt to use it as the basis for a deep learning package.
What's the best way to model modular, composable effects in your purely functional program? In this presentation, I take a look at monad transformers and free monads, discuss their history, and compare how effectively they solve the problem.
This introduction to Lisp deals with the basis of lists processing. You can see :
* the elementary data structure of Lisp: the S-expressions
* the evaluation rules
* very brief introduction to the Lisp macros
Presentation introducing LISP, looking at the history and concepts behind this powerfull programming language.
Presentation by Tijs van der Storm for the sept 2012 Devnology meetup at the Mirabeau offices in Amsterdam
Slides for a lightning talk on Java 8 lambda expressions I gave at the Near Infinity (www.nearinfinity.com) 2013 spring conference.
The associated sample code is on GitHub at https://github.com/sleberknight/java8-lambda-samples
Big picture of category theory in scala with deep dive into contravariant and...Piotr Paradziński
A big picture of category theory in Scala - starting from regular functors with additional structure (Apply, Applicative, Monad) to Comonads. Usually, we think about structures like Monoids in a monoidal category with particular tensor. In here I analyze just signatures of different abstractions.
Exploration of Contravariant functors as a way to model computation "backward" or abstract over input with the ability to prepend operation. Examples for predicates, sorting, show and function input (or any other function parameter except the last one).
Profunctors as abstraction unifying Functors and Contravariant functors to model both input and output. Example for Profunctor - function with one argument.
Relation to Bifunctors, Kan extensions, Adjunctions, and Free constructions.
Watch video (in Hebrew): http://parleys.com/play/53f7a9cce4b06208c7b7ca1e
Type classes are a fundamental feature of Scala, which allows you to layer new functionality on top of existing types externally, i.e. without modifying or recompiling existing code. When combined with implicits, this is a truly remarkable tool that enables many of the advanced features offered by the Scala library ecosystem. In this talk we'll go back to basics: how type classes are defined and encoded, and cover several prominent use cases.
A talk given at the Underscore meetup on 19 August, 2014.
Quark: A Purely-Functional Scala DSL for Data Processing & AnalyticsJohn De Goes
Quark is a new Scala DSL for data processing and analytics that runs on top of the Quasar Analytics compiler. Quark is adept at processing semi-structured data and compiles query plans to operations that run entirely inside a target data source. In this presentation, John A. De Goes provides an overview of the open source library, showing several use cases in data processing and analytics. John also demonstrates a powerful technique that every developer can use to create their own purely-functional, type-safe DSLs in the Scala programming language.
An overview of the programming techniques available and some of the ongoing research in the Haskell community around concurrent and parallel programming.
Slideshare hasn't imported my notes, so here's the link to the Google Presentation: https://goo.gl/Gl4Vhm
Haskell is a statically typed, non strict, pure functional programming language. It is often talked and blogged about, but rarely used commercially. This talk starts with a brief overview of the language, then explains how Haskell is evaluated and how it deals with non-determinism and side effects using only pure functions. The suitability of Haskell for real world data science is then discussed, along with some examples of its users, a small Haskell-powered visualization, and an overview of useful packages for data science. Finally, Accelerate is introduced, an embedded DSL for array computations on the GPU, and an ongoing attempt to use it as the basis for a deep learning package.
What's the best way to model modular, composable effects in your purely functional program? In this presentation, I take a look at monad transformers and free monads, discuss their history, and compare how effectively they solve the problem.
Lisp Macros in 20 Minutes (Featuring Clojure)Phil Calçado
"We just started holding 20 minutes presentations during lunch time in the ThoughtWorks Sydney office. For the first session I gave a not-that-short talk on Lisp macros using Clojure. The slides are below.
It turns out that 20 minutes is too little time to actually acquire content but I think at least we now have some people interested in how metaprogramming can be more than monkey patching."
http://fragmental.tw/2009/01/20/presentation-slides-macros-in-20-minutes/
These are the outline slides that I used for the Pune Clojure Course.
The slides may not be much useful standalone, but I have uploaded them for reference.
Dr. Hsieh is teaching how to use the state-of-the-art libraries, Spark by Apache, to conduct data analysis on hadoop platform in ISSNIP 2015, Singapore. He started with teaching the basic operations like “map, reduce, flatten, and more,” followed by explaining the extension of Spark, including MLib, GraphX, and SparkSQL.
PHP Frameworks: I want to break free (IPC Berlin 2024)Ralf Eggert
In this presentation, we examine the challenges and limitations of relying too heavily on PHP frameworks in web development. We discuss the history of PHP and its frameworks to understand how this dependence has evolved. The focus will be on providing concrete tips and strategies to reduce reliance on these frameworks, based on real-world examples and practical considerations. The goal is to equip developers with the skills and knowledge to create more flexible and future-proof web applications. We'll explore the importance of maintaining autonomy in a rapidly changing tech landscape and how to make informed decisions in PHP development.
This talk is aimed at encouraging a more independent approach to using PHP frameworks, moving towards a more flexible and future-proof approach to PHP development.
Builder.ai Founder Sachin Dev Duggal's Strategic Approach to Create an Innova...Ramesh Iyer
In today's fast-changing business world, Companies that adapt and embrace new ideas often need help to keep up with the competition. However, fostering a culture of innovation takes much work. It takes vision, leadership and willingness to take risks in the right proportion. Sachin Dev Duggal, co-founder of Builder.ai, has perfected the art of this balance, creating a company culture where creativity and growth are nurtured at each stage.
UiPath Test Automation using UiPath Test Suite series, part 3DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 3. In this session, we will cover desktop automation along with UI automation.
Topics covered:
UI automation Introduction,
UI automation Sample
Desktop automation flow
Pradeep Chinnala, Senior Consultant Automation Developer @WonderBotz and UiPath MVP
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Search and Society: Reimagining Information Access for Radical FuturesBhaskar Mitra
The field of Information retrieval (IR) is currently undergoing a transformative shift, at least partly due to the emerging applications of generative AI to information access. In this talk, we will deliberate on the sociotechnical implications of generative AI for information access. We will argue that there is both a critical necessity and an exciting opportunity for the IR community to re-center our research agendas on societal needs while dismantling the artificial separation between the work on fairness, accountability, transparency, and ethics in IR and the rest of IR research. Instead of adopting a reactionary strategy of trying to mitigate potential social harms from emerging technologies, the community should aim to proactively set the research agenda for the kinds of systems we should build inspired by diverse explicitly stated sociotechnical imaginaries. The sociotechnical imaginaries that underpin the design and development of information access technologies needs to be explicitly articulated, and we need to develop theories of change in context of these diverse perspectives. Our guiding future imaginaries must be informed by other academic fields, such as democratic theory and critical theory, and should be co-developed with social science scholars, legal scholars, civil rights and social justice activists, and artists, among others.
Transcript: Selling digital books in 2024: Insights from industry leaders - T...BookNet Canada
The publishing industry has been selling digital audiobooks and ebooks for over a decade and has found its groove. What’s changed? What has stayed the same? Where do we go from here? Join a group of leading sales peers from across the industry for a conversation about the lessons learned since the popularization of digital books, best practices, digital book supply chain management, and more.
Link to video recording: https://bnctechforum.ca/sessions/selling-digital-books-in-2024-insights-from-industry-leaders/
Presented by BookNet Canada on May 28, 2024, with support from the Department of Canadian Heritage.
Let's dive deeper into the world of ODC! Ricardo Alves (OutSystems) will join us to tell all about the new Data Fabric. After that, Sezen de Bruijn (OutSystems) will get into the details on how to best design a sturdy architecture within ODC.
Dev Dives: Train smarter, not harder – active learning and UiPath LLMs for do...UiPathCommunity
💥 Speed, accuracy, and scaling – discover the superpowers of GenAI in action with UiPath Document Understanding and Communications Mining™:
See how to accelerate model training and optimize model performance with active learning
Learn about the latest enhancements to out-of-the-box document processing – with little to no training required
Get an exclusive demo of the new family of UiPath LLMs – GenAI models specialized for processing different types of documents and messages
This is a hands-on session specifically designed for automation developers and AI enthusiasts seeking to enhance their knowledge in leveraging the latest intelligent document processing capabilities offered by UiPath.
Speakers:
👨🏫 Andras Palfi, Senior Product Manager, UiPath
👩🏫 Lenka Dulovicova, Product Program Manager, UiPath
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
UiPath Test Automation using UiPath Test Suite series, part 4DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 4. In this session, we will cover Test Manager overview along with SAP heatmap.
The UiPath Test Manager overview with SAP heatmap webinar offers a concise yet comprehensive exploration of the role of a Test Manager within SAP environments, coupled with the utilization of heatmaps for effective testing strategies.
Participants will gain insights into the responsibilities, challenges, and best practices associated with test management in SAP projects. Additionally, the webinar delves into the significance of heatmaps as a visual aid for identifying testing priorities, areas of risk, and resource allocation within SAP landscapes. Through this session, attendees can expect to enhance their understanding of test management principles while learning practical approaches to optimize testing processes in SAP environments using heatmap visualization techniques
What will you get from this session?
1. Insights into SAP testing best practices
2. Heatmap utilization for testing
3. Optimization of testing processes
4. Demo
Topics covered:
Execution from the test manager
Orchestrator execution result
Defect reporting
SAP heatmap example with demo
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Slack (or Teams) Automation for Bonterra Impact Management (fka Social Soluti...Jeffrey Haguewood
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on the notifications, alerts, and approval requests using Slack for Bonterra Impact Management. The solutions covered in this webinar can also be deployed for Microsoft Teams.
Interested in deploying notification automations for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
State of ICS and IoT Cyber Threat Landscape Report 2024 previewPrayukth K V
The IoT and OT threat landscape report has been prepared by the Threat Research Team at Sectrio using data from Sectrio, cyber threat intelligence farming facilities spread across over 85 cities around the world. In addition, Sectrio also runs AI-based advanced threat and payload engagement facilities that serve as sinks to attract and engage sophisticated threat actors, and newer malware including new variants and latent threats that are at an earlier stage of development.
The latest edition of the OT/ICS and IoT security Threat Landscape Report 2024 also covers:
State of global ICS asset and network exposure
Sectoral targets and attacks as well as the cost of ransom
Global APT activity, AI usage, actor and tactic profiles, and implications
Rise in volumes of AI-powered cyberattacks
Major cyber events in 2024
Malware and malicious payload trends
Cyberattack types and targets
Vulnerability exploit attempts on CVEs
Attacks on counties – USA
Expansion of bot farms – how, where, and why
In-depth analysis of the cyber threat landscape across North America, South America, Europe, APAC, and the Middle East
Why are attacks on smart factories rising?
Cyber risk predictions
Axis of attacks – Europe
Systemic attacks in the Middle East
Download the full report from here:
https://sectrio.com/resources/ot-threat-landscape-reports/sectrio-releases-ot-ics-and-iot-security-threat-landscape-report-2024/
3. Effort vs Productivity
(my subjective point of view)
(not to scale)
(this chart has no meaning, it is a joke)
100
PAIP, On Lisp, SICP
75
The segafault that
made you leave C++
50
Java Cookbook EJB3, J5EE, JMX,
Me Struts, JMS,
Exhausted Permgen
25
You are Here
0
Java C++ Lisp
4. Overview
What is Lisp?
How to get started
Some Basics
Some Common Recipes
Wet your appetite for more
Not so basic things
Where to go next
5. What is Lisp?
A Programming Language
Brought to you by John McCarthy circa 1958
Resistance is Futile...
Garbage Collection, Closures, Functional, Object
Oriented, AOP, DSLs, Conditions and Restarts,
Continuations, what else ya got?
6. Welcome to the Family
Common Lisp (Lisp 2)
LispWorks, Alegro
OpenMCL, SBCL, Clisp, ABCL and others
Scheme (Lisp 1) by Sussman and Steele
PLT, Chicken, Bigloo, Clojure, SISC, JScheme, and
others
Less Common
Dylan, Qi, Termite, ECL, Arc, and others...
7. Quick Start
LispBox
http://gigamonkeys.com/lispbox/
Windows, OS X, Linux
Ready Lisp
http://www.newartisans.com/software/readylisp.html
OS X
8. Roll your own
Emacs
SLIME
The Superior Lisp Interaction Mode for Emacs
Common Lisp
SBCL, CLISP
paraedit-el
9. Basics
Parentheses, lots and lots of parentheses
Everything is an Expression
Prefix Notation
Lists, ‘cons’, pair
Singly Linked List
17. Library System: ASDF
ASDF - another system definition facility
Like Ruby’s gem or Perl’s CPAN (but inscrutable)
(require :asdf-install)
(asdf-install:install :cl-ppcre)
Repository: cliki.net
18. Example: Fetch the Web
(require :drakma)
(use-package :drakma)
(defvar content nil)
(setf content
(http-request quot;http://google.com/quot;))
(format t quot;len:~a~" (length content))
(format t quot;~a~" (subseq content 0 100))
19. Example: Serve the Web
(require :hunchentoot)
(use-package :hunchentoot)
(setq *dispatch-table*
(list
(create-prefix-dispatcher
quot;/indexquot; 'index-page)))
(defun index-page ()
quot;<h1>Hunchentoot Demo</h1>.quot;)
(defvar server
(hunchentoot:start-server :port 4242))
20. Example: Process Files
(require :cl-ppcre)
(with-open-file (inp quot;.../input.txtquot; :direction :input)
(loop for line = (read-line inp nil nil)
while line
do
(format t quot;~a~"
(cl-ppcre:regex-replace quot;lis+pquot; line quot;lispquot;))))
21. Example: Unit Testing
(define-test test-flatten
(assert-false (flatten))
(assert-false (flatten '()))
(assert-equal '(a)
(flatten 'a))
(assert-equal '(a)
(flatten '(a)))
(assert-equal '(a b c d)
(flatten '(a (b (c (d)))))))
22. More Interesting Stuff
Macros, Reader Macros, syntax-rules
Restarts
“To Err is Expected, To Recover, Divine” -- David B. Lamkins
Functional Programming
Pattern Matching (Unification)
23. What’s a Macro?
A tool for Abstraction
Code Generator
Compiler
defmacro
define-macro
syntax-rules
25. Macro: aprog1
(defmacro aprog1 (it &rest body)
`(let ((it ,it)) give the thing a name
,@body
let them use it
it))
return it
(aprog1 (make-hash-table :test #’equal)
(setf (gethash “a” it) 1)
(setf (gethash “b” it) 2))
=> #<HASH-TABLE :TEST EQUAL :COUNT 2 {BE49831}>
28. Restarts in action
CL-USER> (format t quot;bytes:~a~" (bytes-used '(quot;/etc/passwdquot; quot;/foo/barquot;)))
Condition FILE-NOT-FOUND was signalled.
[Condition of type FILE-NOT-FOUND]
Restarts:
0: [FILE-NOT-FOUND] Specify missing size.
1: [ABORT] Return to SLIME's top level.
2: [TERMINATE-THREAD] Terminate this thread (#<THREAD quot;repl-threadquot; ...>)
Backtrace:
0: (FILE-SIZE quot;/foo/barquot;)
1: (BYTES-USED (quot;/etc/passwdquot; quot;/foo/barquot;))
...snip...
Enter a new value: 12
bytes:2900
29. More Interesting Stuff
Functional Programming
Functions are first class - composable
list comprehensions (cl-incf)
pattern-matching (cl-unification, pcond)
DSLs, mini-languages
31. First Class Functions
(defun memoize (fn)
(let ((cache (make-hash-table :test #'equal)))
#’(lambda (&rest args)
(let ((key (format nil quot;~aquot; args)))
(if (gethash key cache)
Return (gethash key cache)
from
cache (aprog1
(apply fn args)
(setf (gethash key cache) it)))))))
Add result to
cache and return
32. First Class Functions
(defun myfn (a b c)
(format t quot;called: a:~a b:~a c:~a~" a b c)
(+ a b c))
(let ((mfn (memoize #'myfn))
(args '(1 2 3))
(args2 '(4 5 6)))
(format t quot;mfn ~a: ~a~" args (apply mfn args))
(format t quot;mfn ~a: ~a~" args (apply mfn args))
(format t quot;mfn ~a: ~a~" args2 (apply mfn args2))
(format t quot;mfn ~a: ~a~" args2 (apply mfn args2)))
=>
called: a:1 b:2 c:3 not in cache
mfn (1 2 3): 6
mfn (1 2 3): 6 in cache
called: a:4 b:5 c:6 not in cache
mfn (4 5 6): 15
mfn (4 5 6): 15 in cache
33. List Comprehensions
(defun lcmp-qsort (things)
(cond ((null things)
things)
(t
(destructuring-bind (pivot . tl) things
(append
(lcmp-qsort
(assemble x (<- x tl) (< x pivot)))
(list pivot)
(lcmp-qsort
(assemble x (<- x tl) (>= x pivot))))))))
34. List Comprehensions
(defun lcmp-qsort (things)
(cond ((null things)
things)
(t
(destructuring-bind (pivot . tl) things
(append
(lcmp-qsort
(assemble x (<- x tl) (< x pivot)))
(list pivot)
(lcmp-qsort
(assemble x (<- x tl) (>= x pivot))))))))
35. List Comprehensions
(defun lcmp-qsort (things)
(cond ((null things)
things)
(t
(destructuring-bind (pivot . tl) things
(append
(lcmp-qsort
(assemble x (<- x tl) (< x pivot)))
(list pivot)
(lcmp-qsort
(assemble x (<- x tl) (>= x pivot))))))))
36. List Comprehensions
(defun lcmp-qsort (things)
(cond ((null things)
things)
(t
(destructuring-bind (pivot . tl) things
(append
(lcmp-qsort
(assemble x (<- x tl) (< x pivot)))
(list pivot)
(lcmp-qsort
(assemble x (<- x tl) (>= x pivot))))))))
37. List Comprehensions
(defun lcmp-qsort (things)
(cond ((null things)
things)
(t
(destructuring-bind (pivot . tl) things
(append
(lcmp-qsort
(assemble x (<- x tl) (< x pivot)))
(list pivot)
(lcmp-qsort
(assemble x (<- x tl) (>= x pivot))))))))
38. List Comprehensions
(defun lcmp-qsort (things)
(cond ((null things)
things)
(t
(destructuring-bind (pivot . tl) things
(append
(lcmp-qsort
(assemble x (<- x tl) (< x pivot)))
(list pivot)
(lcmp-qsort
(assemble x (<- x tl) (>= x pivot))))))))
39. List Comprehensions
(defun all-permutations (things)
(cond
((= 1 (length things))
(list things))
(t
(assemble
(cons Head Tail)
(<- Head things)
(<- Tail
(all-permutations (remove Head things)))))))
40. List Comprehensions
(defun all-permutations (things)
(cond
((= 1 (length things))
(list things))
(t
(assemble
(cons Head Tail)
(<- Head things)
(<- Tail
(all-permutations (remove Head things)))))))
41. List Comprehensions
(defun all-permutations (things)
(cond
((= 1 (length things))
(list things))
(t
(assemble
(cons Head Tail)
(<- Head things)
(<- Tail
(all-permutations (remove Head things)))))))
42. List Comprehensions
(defun all-permutations (things)
(cond
((= 1 (length things))
(list things))
(t
(assemble
(cons Head Tail)
(<- Head things)
(<- Tail
(all-permutations (remove Head things)))))))
43. List Comprehensions
(defun all-permutations (things)
(cond
((= 1 (length things))
(list things))
(t
(assemble
(cons Head Tail)
(<- Head things)
(<- Tail
(all-permutations (remove Head things)))))))
44. List Comprehensions
(defun all-permutations (things)
(cond
((= 1 (length things))
(list things))
(t
(assemble
(cons Head Tail)
(<- Head things)
(<- Tail
(all-permutations (remove Head things)))))))
50. That’s the overview
http://lisperati.org/casting.html, by permission of Conrad Barski, MD
51. Now where am I supposed to go?
On-Line Resources
Common Lisp Hyper Spec
On Lisp (Paul Graham)
Practical Common Lisp (Peter Siebel)
Cliki.net
common-lisp.net
JRMs Syntax Rules Primer
Casting Spells with Lisp: http://lisperati.org/casting.html
http://del.icio.us/mortis/lisp
52. Now where am I supposed to go?
Books
PAIP (Peter Norvig)
Practical Common Lisp (Peter Seibel)
SICP (Ableson and Sussman)
Common Lisp the Language (Guy Steele)
ANSI Common Lisp (Paul Graham)