#+TITLE: Seven Languages in Seven Weeks #+BEAMER_HEADER: \subtitle{Io} #+BEAMER_HEADER: \institute[INST]{Extreme Tech Seminar} #+AUTHOR: Correl Roush #+EMAIL: correl@gmail.com #+DATE: June 10, 2015 #+OPTIONS: H:2 toc:nil ^:nil #+STARTUP: beamer indent #+COLUMNS: %45ITEM %10BEAMER_env(Env) %10BEAMER_act(Act) %4BEAMER_col(Col) %8BEAMER_opt(Opt) #+PROPERTY: BEAMER_col_ALL 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 0.0 :ETC #+LaTeX_CLASS: beamer #+LaTeX_CLASS_OPTIONS: [presentation,aspectratio=169] * Introduction ** Introduction *** Io :BMCOL: :PROPERTIES: :BEAMER_col: 0.5 :END: - Created :: 2002 - Author :: Steve Dekorte An embeddable prototype language with a simple syntax and strong concurrency model. *** Ferris Bueller :BMCOL: :PROPERTIES: :BEAMER_col: 0.5 :END: #+ATTR_LATEX: width=\textwidth [[file:bueller.jpg]] ** Getting Io [[http://iolanguage.org/]] * Day 1 ** Day 1: Skipping School, Hanging Out - Prototypes - Sending messages - Objects, slots, and types - Methods - Collections - Singletons ** Objects, Prototypes, and Inheritance #+begin_src io Vehicle := Object clone Vehicle description := "Something to take you far away" Car := Vehicle clone Car description // "Something to take you far away" ferrari := Car clone #+end_src - Objects are just containers of slots. If the slot isn't there, Io calls the parent. - =ferrari= has no =type= slot. By convention, types in Io begin with uppercase letters. ** Methods #+begin_src io Car drive := method("Vroom" println) #+end_src - A method is an object. - Since a method is an object, we can assign it to a slot. - If a slot has a method, invoking the slot invokes the method. ** Lists and Maps #+begin_src io list(1, 2, 3, 4) sum // 10 elvis := Map clone elvis atPut("home", "Graceland") elvis at("home") // "Graceland" #+end_src - A list is an ordered collection of objects of any type. - A hash is a lot like an Io object in structure where the keys are slots that are tied to values. ** =true=, =false=, =nil=, and singletons #+begin_src io 4 < 5 // true 4 <= 3 // false true and false // false true or false // true true and 6 // true true and 0 // true true clone // true false clone // false nil clone // nil #+end_src =true=, =false=, and =nil= are *singletons*. ** Singletons #+begin_src io Highlander := Object clone Highlander clone := Highlander #+end_src We've simply redefined the =clone= method to return =Highlander=, rather than letting Io forward requests up the tree, eventually getting to =Object=. ** Exercises #+BEGIN_CENTER EXERCISES #+END_CENTER * Day 2 ** Day 2: The Sausage King - Loops & Conditionals - Operators - Messages - Reflection ** Loops *** Infinite loop #+begin_src io loop("getting dizzy..." println) #+end_src *** While loop #+begin_src io i := 1 while(i <= 11, i println; i = i + 1); "This one goes up to 11" println #+end_src *** For loop #+begin_src io for(i, 1, 11, i println); "This one goes up to 11" println #+end_src ** Conditionals The =if= control structure is implemented as a function with the form =if(condition, true code, false code)=. The function will execute =true code= if =condition= is =true=; otherwise, it will execute =false code=. ** Operators | 0 | ~? @ @@~ | | 1 | ~**~ | | 2 | ~% * /~ | | 3 | ~+ -~ | | 4 | ~<< >>~ | | 5 | ~< <= > >=~ | | 6 | ~!= ==~ | | 7 | ~&~ | | 8 | ~^~ | | 9 | ~\vert~ | | 10 | ~&& and~ | | 11 | ~or~ | | 12 | ~..~ | | 13 | ~%= &= *= += -= /= <<= >>= ^= \vert=~ | | 14 | ~return~ | ** Assign Operators | ~::=~ | ~newSlot~ | | ~:=~ | ~setSlot~ | | ~=~ | ~updateSlot~ | ** Add an Operator #+begin_src io OperatorTable addOperator("xor", 11) true xor := method(bool, if(bool, false, true)) false xor := method(bool, if(bool, true, false)) #+end_src ** Messages A message has three components: the =sender=, the =target=, and the =arguments=. The =call= method gives you access to the meta information about any message. ** Reflection #+begin_src io Object ancestors := method( prototype := self proto if(prototype != Object, writeln("Slots of ", prototype type, "\n---------------") prototype slotNames foreach(slotName, writeln(slotName)) writeln prototype ancestors)) Animal := Object clone Animal speak := method( "ambiguous animal noise" println) Duck := Animal clone Duck speak := method( "quack" println) Duck walk := method( "waddle" println) disco := Duck clone disco ancestors #+end_src ** Exercises #+BEGIN_CENTER EXERCISES #+END_CENTER * Day 3 ** Day 3: The Parade and Other Strange Places - DSLs - Metaprogramming - Concurrency ** Domain-Specific Languages #+begin_src io OperatorTable addAssignOperator(":", "atPutNumber") curlyBrackets := method( r := Map clone call message arguments foreach(arg, r doMessage(arg) ) r ) Map atPutNumber := method( self atPut( call evalArgAt(0) asMutable removePrefix("\"") removeSuffix("\""), call evalArgAt(1)) ) s := File with("phonebook.txt") openForReading contents phoneNumbers := doString(s) phoneNumbers keys println phoneNumbers values println #+end_src ** Io's =method_missing= #+begin_src io Builder := Object clone Builder forward := method( writeln("<", call message name, ">") call message arguments foreach( arg, content := self doMessage(arg); if(content type == "Sequence", writeln(content))) writeln("")) Builder ul( li("Io"), li("Lua"), li("JavaScript")) #+end_src ** Concurrency - Coroutines - Actors - Futures ** Exercises #+BEGIN_CENTER EXERCISES #+END_CENTER * Wrapping Up ** Wrapping Up: Strengths - Footprint - Simplicity - Flexibility - Concurrency ** Wrapping Up: Weaknesses - Syntax - Community - Performance ** Final Thoughts #+BEGIN_QUOTE Like Lisp, Io has a strong overriding philosophy of simplicity and flexibility. #+END_QUOTE