Past meetings

Past Meetings‎ > ‎

Presentation & Discussion (January 2013)


* Attendees
  Doug
  Paul
  Andrei
  Dann
  Richard (May have gotten that wrong)
  Quiet guy (Don't know him, he didn't talk much. Red shirt, really thick hair.)
  Leo

* Apologies
  in advance. These notes are far from complete and not in the right order; the conversation was too interesting for any of us to keep running written records, so these were put toghether the next day.
  Note to self: Ask if it's ok with everyone to start recording these meetings for the purposes of transcription.

* Presentation - Doug on Unliner
  Unliner is a utility that tries to bridge the gap between giant ad-hoc pipe chains and "real" programs.
  It does various cool things including eval flags (so you can write the programette in something other than bash if you want)
  It doesn't call a shell at any given point. Literally all you need to run an unliner program is perl (unless you call shell as part of your program)
  [github repo](https://github.com/hoytech/unliner)

* Discussions
  - Quick notes from the Code Retreat last year
    - Smalltalk has ruined TDD for Leo forever by doing it so awesomely that anything less seems inelegant
      - as usual, it might be possible to do something 95% like it in Lisp
  - Regular expressions are awesome
    - Modifier modifiers: The commonly known one is "greedy", the question mark in (\w*?), but a lesser known is "no backtrack", the second plus in (\s++)
    - There's an addon to regexes that gives them the capability to easily specify recursive descent parsing and matching (unescaped) start/end elements
  - Leo's been working on an async server in Common Lisp because he's building a web-app that needs to handle lots of event-source connections
    - Hunchentoot doesn't fit because it starts a thread per connection, and event-sources need to be long-lived. This, shall we say, doesn't scale
  - Quick thumbnail of the gridless Life approach
    - We got into a pretty deep discussion of cellular automata and the life sub-culture here
    - The Haskell version is extremely elegant (4-7 lines, depending on how readable/efficient you want to be), but takes a further ~30 lines to print a grid
    - The Clojure version is almost as elegant, and prints relatively elegantly too
    - Life is just one set of rules for cellular automata; chosen because Conway wanted something that would produce reasonably stable patterns with simple rules
    - Dann demonstrates a browser-based game based on cellular automata that follow different rules
      - The player is an exterminator trying to kill all spores on a given field
      - There are two types of spores; ones that grow fairly stably and homogenously, and ones that grow sporadically
      - The spore-killer that the player fires also obeys rules; it looks for adjacent spore squares to consume and dies when there are none
      - Because of the game rules, and because the sporadically growing spores tend to have more interspersed gaps between clusters, they are actually much harder to kill
      - The stable spores are easy to destroy in large numbers because they form large, contiguous shapes
  - Online games in general are pretty interesting
    - Dann is working on a DSL that would allow foreign code to be run in safety
    - The end goal is to create a multiplayer game-type wherein each web client contributes resources to running the game, while mitigating cheating and discontinuities
  - Further notes courtesy of Dann
    - flow-based programming
    - visual programming languages
    - short conversation about profiling Haskell
      - Leo: it's very annoying, but necessary
    - Profiling Haskell requires you to install the profiling version of each library. Profiling libraries AREN'T installed by default, and don't automatically resolve dependencies (if anyone here's tried manually installing Hunchentoot from tarballs, that's basically what you're looking at)
    - Because Haskell is a lazy language, cost centers aren't intuitively obvious from the structure of a given function, you actually need to see how the final program runs
    - 2D cellular automata discussion in various languages
    - modular synthesizers, pipelines, data flow, max msp, quartz composer
    - stream ciphers, cryptographically strong PRNGs, tortoise and hare algorithm for general cycle detection
    - multiplayer games and client-based persistent worlds
    - trust issues: bitcoin algorithms, byzantine generals, rejecting inconsistent peers, games with a purpose

* If that sounded like an interesting conversation, drop by the next Lisp group meeting

Comments