The Scheme Language -- Using it on the iPhone
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

The Scheme Language -- Using it on the iPhone

on

  • 11,336 views

An introduction to the Scheme programming language and some practical examples of why it's a cool languages (using it on the iPhone, for example).

An introduction to the Scheme programming language and some practical examples of why it's a cool languages (using it on the iPhone, for example).

Statistics

Views

Total Views
11,336
Views on SlideShare
11,152
Embed Views
184

Actions

Likes
5
Downloads
72
Comments
1

5 Embeds 184

http://jlongster.com 126
http://www.slideshare.net 30
http://amisai.posterous.com 23
http://www.techgig.com 4
http://www.slashdocs.com 1

Accessibility

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…
  • Some of the parts in 'Practical Examples' are explained more on my blog:

    Compiling Gambit Scheme for the iPhone and writing apps in Scheme: http://bit.ly/2c70JF

    Using a 'networked REPL' for debugging apps real-time:
    http://bit.ly/EkVf
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

The Scheme Language -- Using it on the iPhone Presentation Transcript

  • 1. Writing iPhone apps in Scheme λ
  • 2. What is Scheme? • Scheme is a dialect of Lisp, around since the 70s • Functional, although not “pure” • Extremely minimal, concise, and expressive • Fully defined in R5RS [1] • Build bigger parts from smaller parts λ
  • 3. Implementations • Scheme by itself is the language specification • There are many implementations of Scheme, each with different strengths: • Gambit-C: speed, portability • PLT: ease-of-use, libraries • Scheme48: modules, formal semantics • etc. λ
  • 4. Syntax • Uses S-expressions and prefix notation • (function arg1 arg2 ...) • (+ 5 5) • 10 • (- (foo 3 2) 1) •? • (+ 1 2 3 4 5) • 15 λ
  • 5. Syntax λ
  • 6. Functions • `define` declares functions • (define (multiply x y) (other-function x) (* x y)) • The last value is returned, so unless `other-function` has a side effect, that call is essentially ignored • `define` also create variables • (define foo 5) λ
  • 7. Functions • `lambda` creates an anonymous function • (lambda () (+ 1 2)) • (lambda (x y) (* x y)) • lambdas are ubiquitous in Scheme, too powerful to fully explain here, but it’s another dimension of Scheme’s expressiveness • Our “multiply” function could be defined as: • (define multiply (lambda (x y) (* x y))) λ
  • 8. Functions • Functions are full closures with tail- recursion where possible • (define (foo x y) (define z (get-z-axis)) (lambda () (+ x y z))) • (define (bar) (read-network-blocking-and-act) (bar)) λ
  • 9. Identifiers • The name of an identifier is very flexible; can contain almost any character • Very expressive • (define the-number 5) • (define !@#$%^&* 10) • (define (is-alive?) ...) λ
  • 10. Lists • The list is Scheme’s fundamental data structure • Special syntax for lists: • ‘(1 2 3 “foo”) • ‘(1 2 3 (4 5 6)) • `(1 2 3 ,data) (define data “foo”) • `(1 2 3 ,@data) (define data ‘(4 5 6)) λ
  • 11. Lists • Lists are made up of “cons cells” or pairs • Fundamental list functions: • car • (car ‘(1 2 3)) => 1 • cdr • (cdr ‘(1 2 3)) => (2 3) • cons • (cons 1 ‘(2 3)) => (1 2 3) λ
  • 12. Lists • Question: is a function not simply a list of elements? • ‘(define (foo x y) (* x y)) • Yes, it is. • In fact, any code in Scheme is data — simply a list of elements. λ
  • 13. Macros • Macros are Scheme functions that take arguments and expand into different code • Macros usually parse code, which is easy in Scheme because code is data! • (define-macro (my-define func . body) (let ((name (car func)) (args (cdr func))) `(define ,name (lambda ,args ,@body)))) • (my-define (foo x y) (* x y)) expands into • (define foo (lambda (x y) (* x y))) λ
  • 14. Macros • Macros are lazy • Macros allow an extremely powerful tool for extending the language for your needs • Any new construct can be integrated • You could redefine `if` • Other macro systems exist which integrate pattern matching and other features λ
  • 15. Say again? • Because of consistency and conciseness, it’s easy to write reusable, small bits of code in Scheme, which is good • Other libraries implement tons of stuff, such as object systems, vectors, etc. • SRFI’s • Not covered: continuations, eval, and more • Questions or comments? λ
  • 16. Practical Examples • It turns out that it’s easy to implement functional programming in an imperative language like C [3] • Gambit-C is a Scheme system which takes Scheme and compiles it to C [2] • Extremely fast and portable • Easy to interface to C/C++/Obj-C libraries λ
  • 17. Taking Scheme to the iPhone • Cross-compiled Gambit’s run-time library for the ARM architecture (for the iPhone) • Compiled my Scheme code to C • Linked everything together, and it ran fine! • Wasn’t that easy? [4] λ
  • 18. Example
  • 19. Benefits • Write iPhone apps in Scheme, of course • Garbage collector • Faster, real-time development • Load in Scheme files at run-time • Much more sane debugging λ
  • 20. Loading in Scheme at run-time • Scheme has a `load` procedure which takes a filename, loads in the code and evaluates it • In Gambit, this function loads code at run- time (`include` does the same thing at compile-time) • Compile an app with a `load` statement, install it once, and develop with interpreted code forever. λ
  • 21. Example
  • 22. Sane Debugging • What is a REPL? • Read-Eval-Print-Loop • A debugger is a REPL with special commands • Gambit comes with a nice command-line debugger, so we want this to work for our iPhone apps. λ
  • 23. Sane Debugging • Since code is simply S-expressions, it’s really easy to parse, pass around the network, etc. • We’ve created a “remote debugger” which implements the functionality of a networked REPL • Instead of reading from the console, the REPL reads and writes from/to a network port • A “debugging server” gives you access to REPLs running inside the application λ
  • 24. Example
  • 25. Optimizing • Compiling to C makes it easy to fine tune hotspots in your application • (define fast-sqrt (c-lambda (float) float “fast_sqrt”)) • Once you’ve written and debugged your app sanely, profile and optimize specific parts of your app • Re-write small pieces of code in C • Use `declare` in Gambit λ
  • 26. Paredit • Another benefit of concise syntax is more advanced text editing • Instead of thinking in terms of lines, think in terms of S-expressions • Paredit implements key-bindings in Emacs to manipulate S-expressions • Really powerful way of writing code λ
  • 27. Example
  • 28. [1] R5RS: http://schemers.org/Documents/Standards/R5RS/ [2] Gambit Scheme: http://dynamo.iro.umontreal.ca/~gambit/wiki/index.php/Main_Page [3] 90 Minute Scheme-to-C compiler http://lambda-the-ultimate.org/node/349 [4] Writing iPhone apps in Scheme: http://jlongster.com/blog/2009/06/17/write-apps-iphone-scheme/ For more info, check out my blog: http://jlongster.com/blog @jlongster