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.
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.
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
Neuro-symbolic is not enough, we need neuro-*semantic*Frank van Harmelen
Neuro-symbolic (NeSy) AI is on the rise. However, simply machine learning on just any symbolic structure is not sufficient to really harvest the gains of NeSy. These will only be gained when the symbolic structures have an actual semantics. I give an operational definition of semantics as “predictable inference”.
All of this illustrated with link prediction over knowledge graphs, but the argument is general.
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.
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
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/
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
Key Trends Shaping the Future of Infrastructure.pdfCheryl Hung
Keynote at DIGIT West Expo, Glasgow on 29 May 2024.
Cheryl Hung, ochery.com
Sr Director, Infrastructure Ecosystem, Arm.
The key trends across hardware, cloud and open-source; exploring how these areas are likely to mature and develop over the short and long-term, and then considering how organisations can position themselves to adapt and thrive.
The Art of the Pitch: WordPress Relationships and SalesLaura Byrne
Clients don’t know what they don’t know. What web solutions are right for them? How does WordPress come into the picture? How do you make sure you understand scope and timeline? What do you do if sometime changes?
All these questions and more will be explored as we talk about matching clients’ needs with what your agency offers without pulling teeth or pulling your hair out. Practical tips, and strategies for successful relationship building that leads to closing the deal.
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.
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)