Redesigning Common Lisp
Upcoming SlideShare
Loading in...5
×
 

Redesigning Common Lisp

on

  • 2,154 views

Shibuya.lisp Tech Talk #8

Shibuya.lisp Tech Talk #8

Statistics

Views

Total Views
2,154
Views on SlideShare
894
Embed Views
1,260

Actions

Likes
6
Downloads
5
Comments
1

12 Embeds 1,260

https://twitter.com 639
http://blog.8arrow.org 575
http://feedly.com 26
http://www.slideee.com 4
http://digg.com 4
http://reader.fufabu.com 3
https://www.inoreader.com 2
http://192.168.11.5 2
http://www.feedspot.com 2
http://www.inoreader.com 1
https://tweetdeck.twitter.com 1
http://webcache.googleusercontent.com 1
More...

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
  • Thank you very much for these works. I hope CL21 will grow into a mainstream programing language for lispers. I love it.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Redesigning Common Lisp Redesigning Common Lisp Presentation Transcript

  • Shibuya.lisp Tech Talk #8 Eitaro Fukamachi Redesigning Common Lisp
  • Thank you for coming.
  • I’m Eitaro Fukamachi @nitro_idiot fukamachi
  • (and 'web-application-developer 'common-lisper)
  • GitHub product languages Others Clojure Perl Emacs Lisp JavaScript Common Lisp
  • GitHub product languages
  • I ♥ Common Lisp
  • because…
  • Common Lisp is the most powerful, expressive and fast language ever.
  • Common Lisp is damn powerful • First class functions + lexical closures • Object system + multiple dispatch • Metaobject protocol
  • Common Lisp is expressive • Reader macros • Macros
  • Common Lisp is fast • (Optional) type declaration • Inlining functions • Compiler macros • Disassembler included • Free high-performance implementation
  • Common Lisp is the most powerful, expressive and fast language ever.
  • = GOD LANGUAGE
  • So, here is a question.
  • Is Common Lisp perfect?
  • Is Common Lisp successful?
  • Is Common Lisp attractive to young people?
  • ……………..
  • “well…”
  • Common Lisp is not sophisticated • too-long-wordy-name-for-common-macros • append & nconc • elt vs aref vs nth • getf vs gethash • map?? mapc?? dolist?? loop?? • Functional vs Procedual
  • It’s because of the origin.
  • Portability 8 Goals of standardising Common Lisp Commonality Consistency Expressiveness Compatibility Efficiency Power Stability from Common Lisp the Language
  • Common Lisp is a compound of MacLISP, Zetalisp, Spice Lisp, NIL and S-1 Lisp.
  • Common Lisp was designed for MacLISP, Zetalisp, Spice Lisp, NIL and S-1 Lisp users, not us.
  • Besides, Common Lisp is old.
  • Common Lisp = 30 years old Ruby = 19 years old JavaScript = 19 years old Clojure = 7 years old
  • Common Lisp was designed for people 30 years ago.
  • But it doesn’t mean Common Lisp is obsolete.
  • Common Lisp is the most powerful, expressive and fast language ever.
  • Common Lisp is the best one, but I’m still not fulfilled in it.
  • CLtL3? Almost hopeless.
  • Let’s redesign Common Lisp for the 21st century by ourselves.
  • “Common Lisp for the 21st century”
  • “CL21”
  • What is CL21? • (One of) the next generation of Common Lisp • Bases on Common Lisp • Designed for us • Actual implementation (not only discussions)
  • Portability 8 Goals of standardising Common Lisp Commonality Consistency Expressiveness Compatibility Efficiency Power Stability from Common Lisp the Language
  • Consistency Expressiveness 4 Goals of CL21 Compatibility Efficiency
  • Goal 1: Consistency
  • Consistency of CL21 • Naming convention • Argument order
  • Consistency of CL21 Common Lisp (reverse '(1 2 3)) (nreverse '(1 2 3)) ! (append '(1 2 3) '(a b c)) (nconc '(1 2 3) '(a b c))
  • Consistency of CL21 CL21 (reverse '(1 2 3)) (nreverse '(1 2 3)) ! (append '(1 2 3) '(a b c)) (nappend '(1 2 3) '(a b c))
  • Consistency of CL21 Common Lisp (getf person :name) (gethash :name person-hash)
  • Consistency of CL21 CL21 (getf person :name) (gethash person-hash :name)
  • Goal 2: Expressiveness
  • Expressiveness of CL21 • Specific vs Generic • Delete useless symbols
  • Expressiveness of CL21 • Specific vs Generic • Delete useless symbols
  • Expressiveness of CL21 • Specific vs Generic • Delete useless symbols
  • Expressiveness of CL21 • Specific vs Generic • Delete useless symbols (ed “~/.sbclrc”)
  • Expressiveness of CL21 • Specific vs Generic • Delete useless symbols Are you crazy???? (ed “~/.sbclrc”)
  • Expressiveness of CL21 Common Lisp (append '(1 2 3) '(a b c)) (concatenate 'vector #(1 2 3) '()) (concatenate 'string "Hello, " name)
  • Expressiveness of CL21 CL21 (append '(1 2 3) '(a b c)) (append #(1 2 3) '()) (append "Hello, " name)
  • Expressiveness of CL21 Common Lisp (mapcar #'1+ '(1 2 3)) (map 'vector #'1+ #(1 2 3))
  • Expressiveness of CL21 CL21 (map #'1+ '(1 2 3)) (map #'1+ #(1 2 3))
  • Expressiveness of CL21 Common Lisp (format nil "Hello, World!~%") (format nil "Hello, ~A~%" name)
  • Expressiveness of CL21 CL21 "Hello, World!n" #"Hello, ${name}n"
  • Expressiveness of CL21 Common Lisp (parse-integer "1984") (symbol-name 'alien-technology)
  • Expressiveness of CL21 CL21 (coerce "1984" 'integer) (coerce 'alien-technology 'string)
  • Expressiveness of CL21 (ql:quickload :cl-ppcre) (use-package :cl-ppcre) ! (scan-to-strings "^(d{4})-(d{2})-(d{2})$" "2014-01-23") (regex-replace-all "a" "Eitaro Fukamachi" "α" :preserve-case nil) Common Lisp
  • Expressiveness of CL21 CL21 (use-package :cl21.re) ! (#/^(d{4})-(d{2})-(d{2})$/ "2014-01-23") (re-replace #/a/ig "Eitaro Fukamachi" "α")
  • Expressiveness of CL21 CL21 ! (use-package :cl21.re) ! (#/^(#/^(d{4})-(d{2})-(d{2})$/ "2014-01-23") (re-replace #/a/ig "Eitaro Fukamachi" "α")
  • Expressiveness of CL21 CL21 ! (use-package :cl21.re) ! (#/^(#/^(d{4})-(d{2})-(d{2})$/ "2014-01-23") (re-replace #/a/ig "Eitaro Fukamachi" "α") Appliable Regex literal
  • Expressiveness of CL21 Common Lisp (ql:quickload :clazy) (use-package :clazy) ! (defun fib-seq () (labels ((rec (a b) (clazy:lazily (cons a (rec b (+ a b)))))) (rec 0 1))) ! (head (tail (tail (tail (fib-seq))))) (lazy-seq:take 5 (fib-seq))
  • Expressiveness of CL21 CL21 (use-package :cl21.lazy) ! (defun fib-seq () (labels ((rec (a b) (lazy-sequence (cons a (rec b (+ a b)))))) (rec 0 1))) ! (first (rest (rest (rest (fib-seq))))) (elt (fib-seq) 3) (subseq (fib-seq) 0 5)
  • Expressiveness of CL21 CL21 ! (use-package :cl21.lazy) ! (defun fib-seq () (labels ((rec (a b) Abstract sequence (lazy-sequence (cons a (rec b (+ a b)))))) (rec 0 1))) ! ! ! ! ! (first (rest (rest (rest (fib-seq))))) (elt (fib-seq) 3) (subseq (fib-seq) 0 5)
  • Expressiveness of CL21 CL21 ! (use-package :cl21.lazy) ! (defun fib-seq () (labels ((rec (a b) Abstract sequence (lazy-sequence (cons a (rec b (+ a b)))))) (rec 0 1))) ! ! ! ! ! (first (rest (rest (rest (fib-seq))))) (elt (fib-seq) 3) (subseq (fib-seq) 0 5) Builtin sequence functions are available
  • Goal 3: Compatibility
  • Compatibility of CL21 • Written in Common Lisp • 100% compatible with Common Lisp • All CL libraries are available
  • Compatibility of CL21 (defsystem my-cl21-app :defsystem-depends-on (:cl21) :class :cl21-system :components ((:file "src/myapp")))
  • Compatibility of CL21 (! defsystem my-cl21-app :defsystem-depends-on (:cl21) :class :cl21-system :components ((:file "src/myapp")))
  • Goal 4: Efficiency
  • Efficiency of CL21 • (less important in CL21, though) • Generic methods are slow • Compiler macros
  • Consistency Expressiveness 4 Goals of CL21 Compatibility Efficiency
  • Other topics: “syntax”
  • “syntax” • CL21 has “syntax” • “syntax” = readtable bound to a package
  • “syntax” (defsyntax cl21.process ((## #`) #'run-process-reader)) ! (export-syntax 'cl21.process) (use-package :cl21.process) ! #`ls -l /Users`
  • Other topics: Standard libraries
  • Batteries included (?) • cl21.re • cl21.process • cl21.lazy • cl21.os
  • Remember CL21 is 100% compatible with Common Lisp
  • You see how Common Lisp is expressive and growable?
  • Current status
  • Current status • Still in development • No backward-compatibility guaranteed • We’ll release in the 21st century • Not settled discussions • loop vs iterate vs series
  • WEB SITE: cl21.org ! GITHUB: github.com/cl21/cl21
  • Make Lisp the Premier Prototyping Language. — Richard P. Gabriel “Worse Is Better”
  • Thanks.
  • EITARO FUKAMACHI 8arrow.org @nitro_idiot fukamachi