Past Meetings‎ > ‎

Discussion meeting (May 2012)

* Attending
Paul T
Doug H

This time out, the Lisp user group had fewer old guys (as a percentage, and as an absolute value) than the Linux user group. I was surprised.

* Notes

** FFIs
   Leo shows off a trivial example of Erlang FFI using the basic port protocol
   Common Lisp can do the exact same thing (which is unsurprising, given what the Erlang "FFI" is)
   `open-pipe`; opens a posix process and grabs `stdin` - This is in [lispworks](
   SBCL also has something like this in the form of `sb-ext:run-program`

** Let Over Lambda writer in the house
   Spiritual successor to On Lisp
   Tries to take macros into the practical realm

** Paul T
   On github. VSH and Grash (visual sh, graph shell - self-compiling, diagrammatic shell ~800loc).

** Special forms in lisp
   27 special forms
   How many can you eliminate? (Plenty, but if you go too far you get Scheme

** Essentials of Programming Languages (Friedman is associated with this, of course)

** Maxima (no, not Macsyma, though they are related)
   Matlab-style math program
   Once you've derived an equation, there's an option to compile it to Common Lisp

** Old Mathematical Programs
   "Most of them were written in Fortran, and no one's bothered to port them to C"
   "No, they've ported them to C, but Fortran had such harsh constraints in the compiler that the compiled code is much faster, so no one bothers to use the C version"

** Compiler Macro vs regular macro  
*** Compiler Macro
    It's at the compilers discretion whether to apply it
*** Macro
    Always expanded if it's evaluated
*** For Example
    Format strings being compiled
    You still need to keep the interpreted version around in case of an apply, but the compiled version is faster
*** Let Over Lambda - optimizing keyword arguments
    Ariel and Doug discussing how effectively keyword parsing overhead can be avoided
    Very! (Except when you apply the keyword function to a set of arguments, at which point there's no opportunity to apply compiler optimizations)
    "Compilers do lots of things"

** Feasibility of Unicode processing in Common Lisp
   Unicode is much more than just another character set; it's a character set plus a bunch of additional metadata about character context/accents/ligatures
   Because part of the language spec is that a string is a vector (you need to be able to get the nth character in constant time), unicode support is non-trivial
*** Unicode Characters! Holy Fuck!
    Ok, so a character is represented by the base character in addition to (for example) accent information
    There is a canonical order to that additional information, but it's variable per letter
    An unaccented character is actually smaller in memory than an accented character, which means that when dealing with Unicode a single
      character can be a pretty wide range of actual sizes in memory.
    It gets even worse when dealing with (for example) regexes, because while there is a canonical order to the metadata, it can vary subtly across platforms
      (there is apparently also a decent chance of running into raw forms where the metadata might be in the wrong order)

** Erlang Bit Syntax
   It's good!
   One of the good ideas put forth in a Joe Armstrong talk about the history of Erlang (history first, reflection in the second half)

** Clojure in Clojure
   How close is it?
   Not very; they've gotten as far as Clojurescript
   Clojurescript is written in Clojure (I'm assuming anyone reading this knows what Clojure is)
   Clojurescript is supposed to be good for commandline work (since it's very small and fast)
   Ali is using an instance of the JVM in client/server mode to communicate with a front end of Clojure  

** cmsg (sendmsg is the system call)
** IBM comissioned project to compile to performant C code
** NACL by DJ Bernstein (DJB
   It's a DSL for cryptographic code that avoids side channel attacks by restricting indexing using secret key values
   "Code generation is pretty awesome"
** Joe's Natural Language Processing project (NEO)
   Still no details (patents will shortly be filed)
   Technology that competes with [Swype]( and [Siri]( for user input
   "Pretty ambitious, but I'm lucky enough to stumble upon some areas that researchers completely missed..." in speech recognition/natural language processing
   Initially, this is going to be a B2C company providing an implememtation and some applications of the technique
   The plan is to then start targetting the enterprise market with APIs
   It doesn't necessarily need training. The math isn't necessarily difficult, it's a fundamentally different approach
   Mentioned: and

** Hawkins with HTMs
   Apparently they have a thing open right now called Grok Beta

** Conversation branches (my fault, sorry)
*** Ravi, Leo, Ali
    Talking about comparisons between neural networks and HTMs
*** Rest
    Talking about arbitrary searching algorithms and going back to the NEO project

** Joe
   "I don't want to support artificial intelligence, I want to support humanistic intelligence"
   Worked for Innovation Foundation, trying to commercialize various AI programs, but they were very limited and theoretical
   Also, lots of bureaucracy

** Back to Machine learning/brain science
   Gifford Gazzaniga lectures
   The research he's doing points to there being an interpreter
   (asked whether this is comparable to a cartesian theatre; dualism. Didn't get a clear answer, but not about to derail conversation)

** End of meeting
   Everyone was surprised that 8:00 rolled around so fast, some ended up heading to a nearby Korean restaurant.

*** Highlights
    Toronto Amateur Radio Club is doing some cool stuff shortly (I hope this is the right URL)
    textsecure; an automatically encrypting SMS Android app that keeps track of your contacts' public keys
    Also, no one mentioned it, but I'm going to abuse my privilege as note-taker to point out
      that next Tuesday week Jim Van Meggelen is talking about Asterisk at the
      Linux User Group
* Link Digest
** Projects/repos - Paul T is finally on GitHub - Maxima official site - clojurescript git repo - Ali's project providing a bridge between a running JVM and a Clojure repl - network cryptography DSL project - OpenFST project - CMU Sphinx (voice recognition engine) project - automatically encrypting SMS Android

** Books - Let Over Lambda book site - Essentials of Programming Languages book

** Talks - Joe Armstrong on the history and lessons of Erlang - things we know about the brain

** Other - Erlang bit syntax documentation - DJ Bernstein's website - Hawkins' latest; Hierarchical Temporal Memory originator - Toronto Amateur Radio Club - Greater Toronto Area Linux User Group