( History )

2002#

2002-11-02 Pre-history #

On the comp.lang.lisp Newsgroup, shortly after the after the San Francisco International Lisp Conference Dave Bakhash started a discussion with Kenny Tilton when Marc Spitzer suggests getting together:

Newsgroups: comp.lang.lisp

Subject: Re: some stuff about the 2002 International Lisp Conference in SF
From: Marc Spitzer <mspi...@optonline.net>
Date: Sat, 02 Nov 2002 05:50:19 GMT

Kenny Tilton <kti...@nyc.rr.com> wrote in
news:3DC35...@nyc.rr.com: 

> btw, IIRC the ALU voted fer sher to hold the next conference (next
> year) in my adopted home town, the Big "if you can make here, you'll
> make it anywhere" Apple, the city so great they named it twice, New
> Yawk, New Yawk. y'all can stay at my place.

Cool, I can pay for the conference and skip the hotel and airfair.

Now since there apears to be at least 3 people doing, or in my case trying 
to do, lisp in NYC area any chance of having a meeting and looking into 
starting a users group?  I did not see an chapters listed on the website.

marc

2002-11-19 First Lisp Meeting in Midtown Manhattan#

On the third Tuesday of the month, Dave Bakhash offers his office and sets up the lisp-nyc@portusgroup.com maling list.
I have a loose idea of some of the things we'll discuss.  They are:

 1) setting up a Web-based group (including mailing list, discussions,
    events calendar, etc...maybe Y! Groups?)

 2) setting up a schedule of when, where, and how often we meet

 3) basic goals of meetings...for example:

     o teaching and promoting CL locally
     o establishing a network to assist developers in finding
       work
     o discussing personal projects that we can start to work on
       collectively, in groups

Pierre's notes from the first meeting:

2003#

2003-01-14 Lisp Meeting in Midtown Manhattan#

[Dave Bakhash]: The list has increased in size since the last one, and
we were already at capacity.  So please don't repost this or invite
your friends, etc. until 9:00 PM or so, at which time the meeting will
leave the conference room.

People are more than welcome to bring snacks and drinks, as well as
laptops, things they want to discuss, etc.

2003-02-04 LispNYC Exists#

Other than LispNYC, optitons included: nyclisp.org nyc-lisp.org nyc-cl.org nyl.org nycl.org lispnation.org houseoflisp.org nyc.lisp.org

Note: ilug-ny.org was previously by Kenny Tilton

2003-02-11 LispNYC Presentation#

Marco Antoniotti presents The Language: Common Lisp his 'hostile audience' computer science presentation at Timeout.

TODO link presentation

2003-03-04 LispNYC Meeting#

Discuss website at Timeout

2003-03-11 LispNYC Meeting#

Discussion of setting up a server, creating a logo and finding a more perminant meeting space held at Timeout.

2003-03-26 LispNYC's First Computer#

NetBSD & portable-aserve running from Russel McMannus's DSL.

2003-04-01 LispNYC Web Mini-Meeting#

Web discussions at Timeout

2003-04-08 LispNYC Meeting#

Many of the same topics as the previous week at Timeout

2003-04-26 LispNYC First Website Goes Live#

https://web.archive.org/web/20030618052029/http://www.lispnyc.org/

2003-05-13 LispNYC Presentation#

Thomas Burdick presents Testa at Timeout

Testa is a software verification system, written in Common Lisp.  It
supports the Proof-Carrying Code model put forward by Necula, among
others.  Unlike current systems, which require special compiler
support, Testa operates directly on machine code, which not only
allows it to be used with systems written in arbitrary programming
languages, but also makes it robust in the face of compiler bugs.
Currently, Testa attempts to ensure the memory safety of Darwin (the
Mac OS X kernel) extensions.  In the future, we plan to have Testa
work with more complicated safety predicates, including various
definitions of thread safety.

Logo contest: announced vote and there was not enough responces to declare a winner.

2003-05-23 At NYLUG: Heow Goodman presents Lisp, A Fresh Look.#

2003-06-10 LispNYC Presentation#

Kenny Tilton presents BL on CL, or Bruce Lee would have like Common Lisp at Timeout

2003-07-08 LispNYC Meeting#

Robocup discussions at Timeout:
  • single-threaded dispatch mechanisms
  • low level features that lead to high level abstractions
  • prioritization of input
  • soccer strategies and team composition

2003-08-17 LispNYC Meeting#

Kenny Tilton in East Village:
A couple of weeks ago I dropped by a weekly gathering of Free
softwarians down in the east Village of NYC and Jay kindly shoved a
keyboard into my mitts and said "show them Lisp". I somehow ended up
talking about, on the one hand, using declarations to get lean-mean
compilation, and on the other, about the glory of macros. That range
in abstraction coinciding neatly with the range of my skill at each.

This Sunday, August 17th at 7PM marks my triumphant return (read
"chance for atonement") to that same occasional home of the Free
(deets below), armed this time with reading glasses and at least a few
hours experience on the cmucl platform under my belt. Possibly even
some working RoboCup code, the delightful soccer simulation which will
be fought out at ILC2003:
http://www.international-lisp-conference.org/

This second "Over the Shoulder" Talk will continue my answer to the
fat-pitch question asked last time, viz., Why Lisp? The focus will be
the interactive quality of Lisp development, and thus will be getting
down and dirty with things like Lisp-aware editors (Emacs or Hemlock)
and the cmucl debugger (with the instructor in accordance with
tradition just one step ahead of the audience).

The context will be live work on my MIT-licensed Lisp RoboCells
platform for aspiring virtual footballers, which (if the r/c platform
happens to be working at that time) we will also have great fun
programming. (turned loose in the server environment for autonomous
play, the players tend to do the darndest things.)

If my r/c platform is not behaving, we /really/ focus on the debugger
and editor and the nature of interactive development. <g>

Along the way expect to hear a lot also about macros, closures,
introspection, CLOS, and (duh) Cells (yes, Virginia, there is a silver
bullet). And anything else about which observers want to ask.

2003-09-13 LispNYC Presentation#

Anton van Straaten presents The Lambda Calculus at Kenny’s House
Anton is a consultant and software developer with a strong interest in
the design and development of programming languages.  He has developed
award-winning language products and tools, such as "Class(y)", which
added full object-oriented language capabilities to the Clipper
database language, complete with multiple inheritance and a
meta-object protocol.  Anton's research during this development led
him to study the formal foundations of programming languages,
including the lambda calculus, type theory, and denotational
semantics.  Anton considers these subjects to have much greater
relevance to practical programming than is commonly realized, and
enjoys sharing his perspective.

His Web site is: http://www.appsolutions.com/anton/lang.html

2003-10-12 LispNYC Talk at the 2003 International Lisp Conference#

2003-11-11 LispNYC Presentations#

Carl Shapiro presents his LISPM and Howard Elmer presents Lisp and Music at St. Sava’s:
This meeting is a large meeting and all students of music, of the
history of computing, and all artists who use a computer are
especially invited.  As always, beginners in programming are urged to
come and learn of the best systems for programming computers.

2003-12-09 LispNYC Holiday Party#

Celebrate the Holidays with Lisp at Serbian Orthodox Cathedral
Although this month we don't have a formal presentation prepared, there
will be plenty to talk about and discuss.

  * Presentations:  What do YOU want to see and what can you bring to
the table?
  * Events: Install fests and conferences galore.
  * Projects: MuSIG, RoboCup, Education CD, RoboCells...
  * LispNYC.org will soon be 1 year old.

2004#

2004-01-13 LispNYC Meeting#

Website and Linux Expo disucssions at Blondies Pub

2004-01-23 LispNYC MUSIG#

Meeting run by Howie 'Monk' Elmer at Harvestworks

2004-01-19 Heow Goodman completes the Lisp Resource Kit#

A self-booting lisp-education environment (CD), with multiple implementations in CL and Scheme as well as dozens of books and documentation.

2004-01-20 LispNYC Booth at Linux World Expo#

Heow and Marc at LWN

On display is:

  • Lisp Resource Kit running on laptop.
  • Stack of folders are all the books and tutorials, printed.
  • Trifold expounding the wonders of Lisp, for developers and managers.
  • LispNYC business cards.
  • Models of robots and probes that run lisp.
  • Giveaway pens.

Lisp Resource Kit with Allegro Common Lisp

Lisp Resource Kit with CMU Common Lisp

Lisp Resource Kit with LispWorks

LispNYC's first business card

2004-02-10 LispNYC Presentation#

Marco Antoniotti presents CLRFI: Common Lisp Request for Improvements One of the results of the ILC-2003, this project is ready to start ramping up for expansion. The Lisp Resource Kit also made its public debut at Westside

2004-02-20 LipsNYC MUSIG Meeting#

[Howard Elmer]'s demo of his latest Symbolic Composer work (getting
quite sophisticated now in his use of the tool) morphed into a nice
technology transfer from the code geeks to the music guys as we helped
get the code running. The big lesson here was that Lisp (SC is Lisp)
remembers stuff during a single session and if you exit and come back
in and reload the same source you are not necessarily in the same
environment as when you exited, especially after hours of development.

We got most of the way through Howards "metacloning" experiment and
got him to the point where he knew what to ask on the SC list.

Then I demonstrated Visual Text(tm) again, as applied to the
Schillinger stuff on to which Nick turned us, and at Marco
(Scoffier's) prompting I added a "tempo" variable on the fly to
demonstrate what it would be like to work with VT. Took a few whacks,
then up came the same gui but with a new tempo control.

I also took time to show off the lighting-panel demo of Cello, in
which I do for OpenGL what we want Lisp to do for Supercollider: I
dynamically reposition lights and adjust their many many parameters,
and the lighting of the scene changes as I drag the lights around. So
I have realtime control of OpenGL, and RSN we can do the same with
Supercollider because...

I just found the user guide for the Scheme->Supercollider package:
http://www.alphalink.com.au/~rd/. If any of you schemers are also on
Mac OS X it would be great if you could see if you could get that
working. I'll be trying it myself. It would be awesome to have this
working in a week when the supercollider meeting is held. I would
prefer Common Lisp, but the goal here is to help musicians, not settle
language wars, so Scheme it is for now.

I finished by simply demonstrating the code Alo set up for me on
Sunday at Open Air, which was a little "Hello world" for realtime
control of sound: we tick off a steady tone on the server, then start
and stop a procedure which jumps in and alters the frequency variable
to the tone function. The Scheme package cited above will of course do
this in spades.

2004-03-09 LispNYC Social#

At Westside

BTW [Kenny|Kenny Tilton], that was an awesome Cello + OpenGL demo you had
running all night!

Thanks for bringing it by and cluing us in, "dancing rabbits" go way far
in demo-land.

kenny: Yes, I am even going to great lengths to make an animated
"screen shot" for the common-lisp.net/projects/cello web page. I have
animated GIFs of the demo working, but they are needlessly hefty (most
of the screen does not change from frame to frame.I believe QuickTime
handles that stuff more intelligently, so tonight's project is to see
if I can get some compression on this thing. Anyway, back to my point:
a JPEG would be fine, a QT movie will be jazzier, and Agassi was
right: Image is everything.

You know, when i got into trouble with the CLIM crowd I was just
offering them some feedback: a better demo will help your project
grow. Somehow it turned into a kill-kenny fest, i guess because it
turns out they cannot make a better demo. The McCLIM people give zero
priority to dancing rabbits. It should not matter, but it do.

kt

2004-03-19 LispNYC MUSIG Meeting#

As per our previous meetings anything LISP music and multimedia related, plus computer arts in general is welcome for presentation, discussion, debate, development and workshop at Harvestworks.
kenny: can't wait! I got mad busy with my Cello project, have not had
a chance to think about metacloning. If we get time during the
meeting, maybe we can work on it there and do a little Lisp tutorial
at the same time. Macros! Perhaps the #1 cool thing about Lisp.

2004-04-13 LispNYC Meeting#

Zoran Lazarevic demonstrates lisp debugging at Westside

2004-04-24 LispNYC MUSIG Meeting#

Held at Harevestworks

2004-05-11 LispNYC Presentations#

Russ and Perry present Macros, Macros, Macros! at Trinity:
For the May 11th meeting we've got a nifty macro demo available
involving two people, and three sections:
  * Macro introduction by [Russ|Russell McManus]
  * Detailed macro case-study involving regex by [Russ|Russell McManus]
  * Hygenic macros by [Perry|Perry Metzger]

20 people attended the meeting Russ did a great job explaining how to develop macros and showed us his regular-expression engine which he wrote in 100 lines of lisp.

Marco then demoed how his 'definer' macro can be used to compare structures.

Resources:

Russ's Regexp: (it's also on the website, in RoboTrader) http://www.lispnyc.org/assets/regexp.lisp http://www.lispnyc.org/assets/regexp-test.lisp

Marco's Definer: http://www.common-lisp.net/project/definer/

2004-06-08 LispNYC Social at Westside#

2004-06-18 LispNYC MUSIG Meeting at Harvestworks#

2004-07-13 LispNYC Social at Westside#

2004-08-10 LispNYC Social#

At Westside the topic discussion is: _Lazy Evaluation vs Special Forms_

2004-09-14 LispNYC Presentation#

Mark McConnell presents Technologies Together: Java and Lisp at Trinity:
  * Learn how to write 100% Java in a lisp-like way.
  * See how the Lisp-to-Java-source compilers stack up.
  * Common-Lisp to Java bytecode?  t !
  * Scheme and Java, a case-study in concise coding.

Marc McConnell presents Technologies Together: Java and Lisp. Find out
how to write Java in a Lisp-like way, how the different Java source
and byte code compilers stack up and see a Java / Scheme case-study.

2004-09-24 LispNYC MUSIG at Harvestworks#

2004-10-05 LispNYC Special Meeting#

[Roger Corman], "the man the myth the s-expression" father and namesake of
the popular Corman Common Lisp ( http://www.cormanlisp.com ) will be
visting New York City and has generously offered an evening of his busy
schedule to meet and hang with the local lispnycs.

Spend an evening with Roger, bring your queries regarding running your
own successful Lisp business, talk shop or just swap pointers on the
most humane way to let down hundreds of Lisp groupies.

2004-10-12 LispNYC Presentation#

Rich Hickey presents Jfli - a Java Foreign Language Interface for Common Lisp at Trinity:
* Use Java libraries as if they were Lisp libraries.
* Allows for Lisp methods specialized on Java classes and interface
types.
* Automatic lifetime maintenance of Lisp-referenced Java objects.

2004-11-09 LispNYC Planning Party#

At Kenny’s House:
We're proud to officially announce LispNYC.org's YEAR THREE Planning
Session and Schmooze Fest!  

Following in the tradition of previous years, please bring your gripes
from this year and ideas for the next.  LispNYC is YOUR group, so feel
free to speak up regarding... well... everything Lisp in New York!

2004-12-04 LispNYC Roadtrip to MIT’s Lightweight Language Conference#

2004-12-15 LispNYC Holiday Party#

New York PHP and the New York City *BSD User Group are proud to announce
the first annual New York Technical Community Holiday Party.
Don't miss the opportunity to reach hundreds of IT professionals.

Keep the evening of Wednesday, December 15th, 2004 open for the first
holiday party to embrace and network the entire New York technical
community.

This is not a PHP or BSD only event, and will include participants from
many technology sectors, including Java, Linux, Perl, and .NET. We're
working hard to make this event embrace all technologies - not only open
source - and our goal is to combine free and commercial software in one
professional networking event.

Flagship sponsors New York PHP and NYC*BUG are bringing together
hundreds of technical professionals from the New York metropolitan area
for the New York Technical Community Holiday Party. By uniting diverse
skills and interests, open source professionals, IT managers, and top
authors and speakers, this event begins a new era in technical,
business, and social networking.

Participants from large corporations, small businesses, universities,
non-profits, and user groups are all invited to attend and bring
significant others, co-workers, and friends to this unique event.

Get a chance to connect with colleagues and share experiences with
others from your industry. Publishers, leading hardware / software
vendors, and local businesses and organizations will be there, providing
giveaways, presentations, and meetings. Enjoy a free night of
presentations from top authors and speakers, talking with vendors, and
networking in a relaxed social environment with food and drink.

Bring your business cards to exchange and for raffle opportunities.

Business casual attire is required.

2005#

2005-01-11 LispNYC Meeting#

CLRFI and website discussion at at Westside. Although a new box is in the works, the website could use some disucssion. The British Accent known as Nick Levine is visiting Friday Jan 28th and leaving Sunday.

Francois-Rene Rideau ( http://fare.tunes.org/ ) is in town this week!

"...would very much like to meet with Lispers and other Knights of the
Lambda Table while around there.  ....free on evenings of Jan 7, 8, 9,
and afternoon of Jan 8, 9.  What about some eats on Friday Jan 7 2005?"

2005-02-08 LispNYC Presentation#

Marco presents Perl Python enumerations in Lisp at Trinity where Drew demonstrated many new musical peices.

2005-03-08 LispNYC Social at Westside#

2005-04-07 MUSIG Meeting#

Ambient Mrainstorming and Lisp-ucation at Harvestworks
we'll be meeting in a new smaller room this month: if anybody has ideas
on topics - please post the the musig list, and bring them along, we
have audio and projection capabilities, though an adapter may be needed
if you do not have a female 15-pin vga port on your laptop

as per our previous meetings anything LISP music and multimedia related,
plus computer arts in general is welcome for presentation, discussion,
debate, development and workshop

2005-04-09 LispNYC Hosted now at Pilosoft#

2005-04-12 LispNYC Presentation#

Bob Coyne presents Words Eye at Trinity
    WordsEye: Creating 3D scenes from textual descriptions
        
    WordsEye   allows  untrained   users   to  spontaneously   and
    interactively create  3D scenes by simply  describing them. By
    using natural  language, ordinary users can  quickly create 3D
    scenes  without  having  to  learn special  software,  acquire
    artistic  skills,  or  even  touch a  desktop  window-oriented
    interface.   Creating graphics with  natural language  gives a
    new  sense of  power  to words  and  suggests applications  in
    education and creative play as  well as the creation of visual
    art itself. WordsEye  relies on a large database  of 3D models
    and images  to depict objects and  surface textures.  WordsEye
    is written in Common Lisp and runs on Linux.

2005-05-10 LispNYC Presentation at Trinity#

Timothy Daly presents Axiom
Timothy Daly, published author, academic researcher, open source
programmer and lead developer of Axiom will be presenting about his role
as the driving force behind Axiom.  With over 70 developers and 200
researchers worldwide it can best be described as:

    Axiom is a general purpose Computer Algebra system. It is useful
    for research and development of mathematical algorithms providing
    a very high level way to express abstract mathematical concepts.
    The Axiom Library defines over 1,000 strongly-typed mathematical
    domains and categories.

Axiom consists of an interpreter and compiler, a browser, a graphical
interface, and a new online wiki that allows users to create web pages
that inline computations.

Axiom is built upon Common Lisp.

For more Axiom information:

    http://savannah.nongnu.org/projects/axiom
    http://page.axiom-developer.org/
    http://page.axiom-developer.org/zope/mathaction/ReduceWiki

2005-06-02 LispNYC selected to be a Sponsoring Organization for Google’s Summer of Code 2005#

Projects funded:

  • Lisp Sockets - William Bendick is to create single socket library
with a standard interface for all Lisp implementations in all environments. This will be accomplished by using a portable OS FFI (Foreign Function Interface) to gain access to native C socket libraries.

Mentored by Robert Brown and Kenny Tilton

Technical Advisor Perry Metzger

  • FetterFfi - Rayiner Hashem creates a program will be created to automatically generate
foreign function interface (FFI) bindings directly from C++ header files. The program will implement this functionality using GCC-XML to parse C++ header files, giving it the ability to support a wide range of C++ features.

Mentored by Kenny Tilton and Robert Brown

  • AxiomUI - Kai Kaminski is to provide a platform
independent graphical user interface to the computer algebra system Axiom. Mentored by Tim Daly and Bill Page
  • GoDb - Samantha Klienberg’s project will build a new interface to the GO Database
(www.geneontology.org, www.godatabase.org/dev) that caches the queries one makes in order to improve speed. Mentored by MarcoAntoniotti and Matt Knox
  • Hello-C FFI Luis Olivira’s work is to fork of UFFI, or Universal Foreign
Function Interface. Hello-C adds support for callbacks from C, and is meant to allow UFFI to move forward, since UFFI's originator needs it to remain stable for his own work. Mentored by Kenny Tilton
  • PltStepper - John Clements will extend the PLT stepper Extend it to be a
general part of all of the language levels. Presently, the PLT scheme stepper only works with the beginner and intermediate levels of the language. Mentored by Joe Marshall and Dimitry Gashinsky
  • PltDb - Corey Sweeney There are a number of projects that have created database
drivers for PLT Scheme, but there is not yet a unified API. The project is to create a unified API and then adapt the existing drivers or create new ones as necessary to use this unified API. Mentored by Joe Marshal
  • Slime Stepper - Svein Ove Aas Although Slime is getting better everyday, it
still lacks some important debugging tools. The stepper is one of those tools. Mentored by Antonio Menezes Leitao and Heow Goodman
  • ErLisp - Eric Lavigne The Erlisp project aims at extending the most popular
Common Lisp implementations in order to make the concurrent programming features of Erlang available to them Mentored by Francois Rene Rideau Technical advise by Dirk Gerrits and Dimitry Gashinsky

2005-06-03 MUSIG Meeting at Harvestworks#

2005-06-14 LispNYC Presentation#

AntonvanStraaten re-presents Lisp and the Lambda Calculus at Trinity
In the first installment of the "LispNYC: Best Presentations" Anton van
Straaten re-presents "Lisp and the Lambda Calculus":

    Every Lisp programmer is familiar with the keyword LAMBDA.
    But what does it really mean, and where does it come from?
    When John McCarthy invented Lisp in 1958, he borrowed a
    notation for the representation of functions from a
    mathematical formalism known as lambda calculus.  But
    although McCarthy borrowed aspects of the syntax of lambda
    calculus, he didn't quite get the semantics right at first.
    This led to one of Lisp's most longstanding and famous bugs:
    the funarg problem, relating to the difficulty of
    implementing functions as first-class values in a language.
    
    This talk takes a wild ride through the history of human
    thought about logic and computation, through the invention
    of lambda calculus and the invention of Lisp, the discovery
    of the funarg problem, its ultimate solution in the lambda
    calculus, and the adoption of that solution by Lisp and
    Scheme.  Along the way, the lambda calculus will be
    explained and interactively demonstrated, in breathtaking
    clarity, using real code, showing the foundations of the
    basic logical constructs for which Lisp is famous.

This is a must-see for both Lisp aficionados as well as anyone with an
interest in programming language history.  Knowledge of Lisp is helpful,
but not necessary.

Anton van Straaten is a software developer and consultant with a strong
interest in the design and development of programming languages.  His
experience ranges from the development of successful programmer tools,
to complex financial services applications.  He has presented at MIT's
Lightweight Languages Conference and the International Lisp Conference. 
His work on programmer tools and interest in languages has led him to
study the formal foundations of programming languages.  As part of this
study, Anton developed SchemeDS (http://www.appsolutions.com/SchemeDS/),
an executable version of the formal semantics of the Scheme language,
the only such implementation publicly available.

2005-07-12 LispNYC Presnentation#

Raymond Puzio presents The Hyperreal Dictionary of Mathematics at Trinity
In last month's talk, we heard how Lisp is based upon certain ideas
from the foundations of the Lambda Calculus branch of mathematics.  In
this month's talk, Raymond Puzio will consider how Lisp can repay this
debt to mathematics:

      Lisp is the language of mathematics - but many people don't
      realize that!
      
      The Hyperreal Dictionary of Mathematics seeks to fulfill
      Lisp's mathematical promise, and greatly expand the
      usability and accessibility of mathematics for everyone.
      The core of this project is a comprehensive dictionary of
      mathematical knowledge in a formal language inspired by Lisp
      which will represent mathematical concepts formally at a
      higher level than symbolic logic and is comprehensible to
      both humans and machines.  To make sure that this language
      will indeed be capable of express any precise mathematical
      idea that can be expressed in mathematical notation, we have
      examined examples of mathematical proofs and definitions and
      studied the theoretical underpinnings of mathematical
      notation.
      
      Since few mathematicians are willing to adapt a new system
      of notation, no matter how well thought out, we are also
      writing programs to translate between our formalism and
      conventional mathematical notation.  In the future, we also
      hope to include natural language processing so that the
      program will be able to understand the mathematical
      litearture and produce output in a user friendly form.
      
      Simply translating a body of mathematics into a new
      formalism is relatively uninteresting by itself; one also
      need to do something with it.  To that end, we are working
      on programs which will perform such tasks as translate
      between different notations and verify mathematical proofs
      for correctness.  In particular, we are working on an
      approach to proof checking which treats logical and
      non-logical operations on an equal footing and views proofs
      as analogous to programs.  We believe that this approach is
      well suited to implementation in Lisp and captures the way
      mathematicians concieve of proofs better than an approach
      based upon reducing everything to formal logic.

This talk will be of interest to mathematicians, metamathematicians, and
lispers, and especially interesting to those who find themselves in the
intersection of these two sets.  Only a basic acquaintence with Lisp and
the foundations of mathematics is necessary in order to understand this
talk.

2005-08-09 LispNYC Social at Westside#

2005-08-11 First Slashdotting#

LispNYC was mentioned in Slashdot. Our website did not crash and burn.

2005-09-11 LispNYC Unveils New Website#

he web-committee has worked long and hard and would like to proudly
unveil the new LispNYC website! 

The new website, is temporarly at http://www.parenpower.com until DNS
gets switched over.


Technicals
----------

It runs 100% Lisp under CMUCL!

We use Portable Allegroserve and WebActions to render the site

CMUCL serves _hundreds_ of simultaneous connections under sustained load
without even breaking a sweat. 

We deliver the XHTML in under 1/4 of a second ...and on a computer
literally cobbled together from scrap off the streets of Manhattan.

CMS provided by CL-Wiki


Visuals
-------

The site is completely frameless.

It's valid XHTML (read: well-formed HTML)

Looks great at different browser resolutions!

Looks great at different zoom levels!

Works on a myriad of browsers such as Firefox 1.0.3, Internet Explorer
6.0, Netscape 7.02 and Opera 8.0


Content
-------

100% of the content is modifiable with CL-Wiki, here:

  http://parenpower.com:8001/cl-wiki/Home

MuSIG has their very own sub-site

We can support very large file uploads

2005-09-13 LispNYC Presentation#

Conrad Barski, M.D. presents How To Tell Stuff To A Computer, The Enigmatic Art of Knowledge Representation at Trinity:

    Conrad created this presentation in order to help demistify
    the science of knowledge representation (KR for short) for
    all who are interested in this still largely
    underappreciated scientific field. Representing knowledge,
    in itself, is not a very difficult thing to understand: It
    is no mystery that computers are a great way to store and
    retrieve information. But have you ever wondered where
    things currently stand with the science behind computer
    information?  Is the way we currently use information on
    computers about as good as it can be? ...Or, can we expect
    that there are major advancements still ahead of us?
    
    Anyone who looks closely at the way we currently store and
    use information with computers will find that our methods
    are, at best, still rather crude.

Conrad received his M.D. at the University of Miami School of
Medicine. He is now working at ProVation Medical Software developing
tools for procedure documentation, including DocuDiagrams, a novel
system of interactive diagrams for documenting cardiology procedures. In
a previous life, he was the lead developer on the video game "FlipOut!"
for the Atari Jaguar game console.


Resources:
  http://www.lisperati.com/

2005-10-11 LispNYC Social at Westside#

2005-11-08 LispNYC Presentation#

Joel Spolsky presents Next Generation of Language Design and Why Lisp is Relevant at Trinity
    Joel Spolsky of "Joel on Software" fame will be speaking on
    the next-generation of language design and why Lisp is
    relevant!
    
    Joel's area of expertise while working at Microsoft area was
    "programmability" where he replaced the Excel macro language
    (XLMs) with Excel Basic and provided an object-oriented
    interface to Excel.  Excel Basic thus became "Visual Basic
    for Applications" and it's OO interface became knows as OLE
    Automation, a.k.a. IDispatch.
    
    Joel has been writing about software development,
    management, and business the the CEO of Fog Creek Software
    and author of three books:
    
    *  User Interface Design for Programmers, Apress, 2001
       
    *  Joel on Software: And on Diverse and Occasionally Related
       Matters That Will Prove of Interest to Software Developers,
       Designers, and Managers, and to Those Who, Whether by Good
       Fortune or Ill Luck, Work with Them in Some Capacity,
       Apress, 2004
       
    *  The Best Software Writing I: Selected and Introduced by Joel
       Spolsky, Apress, 2005
    
    References:
    
       http://www.joelonsoftware.com
       http://www.fogcreek.com
       http://www.amazon.com (search on "Spolsky")

2005-11-13 LispNYC Holiday Party#

At Heow’s House It's that time of year again! Already it's time for LispNYC's annual Holiday Meeting and our Year Four Planning Session! Additionally Bob "Santa" Brown has purchased, for your hacking pleasure at LispNYC, a: ____ _ _ _ / ___| _ _ _ __ ___ | |__ ___ | (_) ___ ___ \___ \| | | | '_ ` _ \| '_ \ / _ \| | |/ __/ __| ___) | |_| | | | | | | |_) | (_) | | | (__\__ \ |____/ \__, |_| |_| |_|_.__/ \___/|_|_|\___|___/ |___/ _____ __ ____ ___ |___ / / /_|___ \ / _ \ |_ \| '_ \ __) | | | | ___) | (_) / __/| |_| | |____/ \___/_____|\___/ Yes, a real, live Lisp Machine will be available to you, during the party!!!! http://en.wikipedia.org/wiki/Symbolics http://www.frobenius.com/symbolics.htm

2005-11-29 MUSIG Meeting#

Richard Stallman, author of Emacs and Founder of Project GNU, will speak on Copyright vs Community at Cooper Union.

2006#

2006-01-10 LispNYC Presentation#

Joe Corneli presents The Hyperreal Dictionary of Mathematics, Part II at Trinity
    The goal of the Hyperreal Dictionary of Mathematics project
    is to do to math what the GNU project did to UNIX by creating
    a free and comprehensive database of mathematics along with a
    suite of tools.
    
    Joe Corneli, the "other half" of the HDM project, will
    demonstrate HDM's new hypertext and AI authoring tool
    Arxana, also known as "the scholium system".
    
    Arxana is no ordinary hypertext tool, it draws heavily on
    the ideas from Ted Nelson's Project Xanadu combining them
    with an AI semantic network strategy and is implemented as a
    a GNU emacs package.

Joe Corneli received his undergraduate degree from New College of
Florida in 2002, after which he enrolled in the mathematics Ph. D.
program at the University of Texas (Austin) where he became increasingly
involved in the alternative mathematics community that has grown up
around the PlanetMath.org website.

His publication credits include the co-authorship of two papers in
differential geometry and an editing credit for the Free Encyclopedia of
Mathematics.  

For the last three years Joe has been working full-time on the HDM
project.

Resources:
http://planetmath.org/
http://planetx.cc.vt.edu/AsteroidMeta/The_Hyperreal_Dictionary_of_Mathematics

2006-02-14 LispNYC Social at Westside#

2006-03-14 LispNYC Presentation#

Matt Knox presents nyclisp: An Urban(e) Lisp for the Lazy and Static at Trinity
    nyclisp (pronounced "Nice Lisp") is an interesting language
    falling squarely between Scheme and Common Lisp in it's
    avoidance of collisions when combining lazy evaluation and
    side-effects.
    
    In a nutshell, it has:
      * 13 primitives
      * no special-forms
      * both macros and types are first-class objects
      * utilizes Algo-like thunking by separating argument
         handling from evaluation for function dispatch
    
    This results in a language that is both more static AND more
    dynamic than both Common Lisp and Scheme.

Matt Knox is a polyglot developer who has been active in LispNYC for 2
years, and is pretty sure he enjoys being in way over his head.

2006-04-11 LispNYC Social at Westside#

2006-05-09 LispNYC Presentation#

Peter Seibel presents: Practical Common Lisp at Trinity
    "Should we vacation in Bali or Monaco?"  ....is the query
    put forth to Miss September.  "Well Peter," she says with
    perfect lips "Bali has better food, but Monaco has the
    'Sushi-Girl Backrub Team'".  

Indeed life can be a chore, for these are the daily tortures of the
Productivity Winners of the 16th Annual Jolt Product Excellence Award in
Technical Books!

    Miss September giggles: "What were you thinking when you
    decided to write a book on Lisp ...in 2005?"   
    
    "I wasn't thinking that it would be the #1 top selling Lisp
    book on Amazon." 
    
    "Nor was I thinking that it would go as high as #2 in the
    Languages & Tools category, #4 in Programming, #11 in
    Computers & Internet, and #543 in all books." 
    
    "I also wasn't thinking that Apress would have to do a 2nd
    printing, they were really grumpy about that."
    
    "...and I never dreamed I'd have such a deep appreciation
    for backrubs and Balinese food." 

Peter Seibel is an ex-Java programmer who quit his job to buckle down
and finally learn Lisp, shortly thereafter he completed "Practical
Common Lisp".  Having finished the book, Peter is now available for
consulting projects--Lisp and otherwise--as the chief monkey of
Gigamonkeys Consulting.  He is currently serving on he Board of
Directors of the Association of Lisp Users.

2006-06-13 LispNYC Social#

Summer of Code planning session at Westside

2006-06-25 LispNYC selected as a Sponsoring Organization for Google’s Summer of Code 2006#

  • CLARITY by Samantha Kleinberg, mentored by Carl Shapiro and Marco Antonioti.
  • Wispy Lisp by Howard Yeh, mentored by Edward Marco Baringer.
  • CL-STM by Cam-Hoan Ton-That, mentored by Robert Swindells.

2006-07-11 LispNYC Social at Westside#

2006-08-08 LispNYC Social#

CELLS discussion at Westside

2006-09-12 LispNYC Presentation#

Samantha Kleinberg presents CLARITY: A Common Lisp Data Alignment Repository at Trinity
Samantha, for the second year in a row, won and accepted a Google Summer
of Code grant to extend her previous work of CL-GoDB and to:

    Create a system where people upload their data files and fill out
    a form with as much information as they know about the data via a
    simple for or series of checkboxes. Then, when the data is
    inserted into the database, it gets placed into a
    phylogenetic-type tree of all diseases. The lengths of edges in
    the tree represent the distance of nodes from one another. So, in
    the case of disease, specific breast cancer cell lines are a
    subset of breast cancer and then all cancers. Thus, distance in
    the tree between those cell lines would be less than that between
    breast cancer cell lines and prostate cancer cell lines. Every set
    number (maybe 100, maybe 500) of inserts, the tree gets
    re-optimized. In this way, the tree is continually learning and
    re-grouping patients, but each individual insert is quick.

Hear about both CL-GoDB and CLARITY, her winning-experiences with Lisp
and about Google's Summer of Code project.

2006-10-05 LispNYC Special Event: 2nd Biannual Meet Roger Corman#

2006-10-10 LispNYC Social at Westside#

2006-11-14 Presentation#

Kenny Tilton presents a live demo of his new algebra tutor at Trinity:
The software is due to be released in three to six months, but the core 
capabilities are there and I want to start now to round up possible 
alpha and beta test sites, so it will be previewed at the Lisp-NYC
meeting. First, some background:

    Math for America (http://www.mathforamerica.org) says: "To
    teach mathematics effectively, one needs strong knowledge of
    mathematics, solid pedagogical skills and a disposition well
    suited for the classroom." I like that because one of my
    mantras is that good teaching /software/ must be expert at
    its subject. Few Algebra products include an embedded expert
    system capable of solving Algebra. Instead they rely on
    hard-coded solutions to set examples. This prevents them:
    
      * From working with the student's own homework or
        classwork;
      
      * From helping with intermediate steps in a solution
        entered by the student;
      
      * Worst of all means they do not recognize and will mark
        as incorrect answers in mathematically correct but
        unconventional form, such as 3yx instead of 3xy.
    
With MfA, I also like to say good educational software must be expert at
teaching, giving neither too little help (frustrating) nor too much help
(no learning). The design principle of my software is simply to
replicate as well as possible the things I did working as a private
tutor. The key features of the software are:
    
  1. "Old school" Algebra I content and explication.
  
  2. One-of-a-kind student-friendly WYSYIWYG math editor. No
     cryptic ASCII encoding such as (x2-1)/(x+1)
  
  3. Enter any problem. Not limited to built-in
     examples. Use with any textbook. But no cheating. The
     software will help with but not solve problems entered
     by the student.
  
  4. Step-by-step assistance as if a private tutor where by
     the student's side:
  
    * Progressively more helpful hints suggesting the next
      step in the solution
    
    * Solved examples similar to the student's work,
      randomly generated on the fly. The tutor offers
      textual annotations and/or visual highlighting to
      explain and illustrate its work as it proceeds. This
      is similar to solved examples in a textbook, but the
      software lets the student control the tutor
      interactively and have it explain or illustrate
      specific parts or steps of a larger problem as they
      see fit.
    
    * Incorrect steps (not just the final answer) are
      flagged immediately and must be corrected before
      continuing. The flip side is that, when an
      intermediate step is correct, the student knows so at
      once, reducing math anxiety.
    
    * The software awards points and penalties for each
      correct step and mistake, providing an incentive for
      students to wean themselves of automatic checking and
      hints (which reduce the points earned).

No, it is not a game. Another guiding principle for is that no one who
does not enjoy mathematics for itself should be teaching mathematics. A
game format tells students "we know math is boring and painful, so we
have sugar-coated it". The best math teacher appreciates and convey the
beauty of math to their students. And math is fun, as any successful
math student will tell you. Are they oddballs? No. One needs look no
farther than the current suduko craze or the popular puzzle page of
tabloid dailys to know that people simply enjoy solving things--aslong
as they can. I believe the learning aids offered by my software --
feedback, hints, solved examples -- will put success within the reach of
vastly more students. 

Past experience confirms this. Having sold a similar product called
Algebra I HomeworkTutor back in the 1980's and 90's, under the company
name Missing Link Software. Here are some review sound bites (I have the
full reviews somewhere if you would like to see those):

  * "The best algebra tutorial program I have seen."
    Macworld, 4/1991
  
  * "For students requesting extra assistance in Algebra, a
    useful software alternative to the human tutor." Math &
    Computer Education, Fall, 1990
  
  * "An interactive tool to help a student solve homework or
    practice problems...unobtrusive monitor correcting
    errors...several levels of excellent instructional
    hints." MacGuide, August 1989

With MfA I agree great teachers can always teach Algebra effectively. My
software hopes to be at least a good tutor itself, but -- unlike even 
the best teacher -- always be there to work with students one-on-one, in
the classroom, computer lab, or at home. Perhaps software like mine is 
another way to make more good teaching available to students?

Come see a live demo of the software, which should be on the market as a
commercial product (for Windows, Mac OS X, or Linux) within six months,
covering the first half of a conventional Algebra I course. 

The full Algebra I curriculum should be in place by summer. The focus of
the presentation will be on math education, not programming, but it
looks like the audience will be all programmers so I would be delighted
to discuss Cells and Cello if anyone asks. The software is pretty far
along and I want to start the process now of finding folks interested in
trying the software out on real students, or at least in trying out the
software themselves and offering feedback.

2006-12-12 LispNYC Holiday Party#

The beginning of LispNYC's 5th year, our annual Holiday Meeting and Year Five Planning Session at Heow’s House where you and your loved one along to revel in the soft CRT glow of the Symbolics 3620.

2007#

2007-01-09 LispNYC Social#

Discussion topic: cellular automata at Westside

2007-02-13 LispNYC Presentation#

Pinku Surana presents Meta-Compilation of Language Abstractions at Trinity
Dr. Surana discusses his dissertation of the benefits of user-written compiler
extensions.  This leads to simple APIs, optimizations, and the clean
embedding of domain-specific languages:

    High-level programming languages are currently transformed
    into efficient low-level code using optimizations that are
    encoded directly into the compiler. Libraries, which are
    semantically rich user-level abstractions, are largely
    ignored by the compiler. Consequently, library writers often
    provide a complex, low-level interface to which programmers
    "manually compile" their high-level ideas. If library
    writers provide a high-level interface, it generally comes
    at the cost of performance. Ideally, library writers should
    provide a high-level interface and a means to compile it
    efficiently.
    
    This dissertation demonstrates that a compiler can be
    dynamically extended to support user-level abstractions. The
    Sausage meta-compilation system is an extensible
    source-to-source compiler for a subset of the Scheme
    programming language. Since the source language lacks nearly
    all the abstractions found in popular languages, new
    abstractions are implemented by a library and a compiler
    extension. In fact, Sausage implements all its
    general-purpose optimizations for functional languages as
    compiler extensions. A meta-compiler, therefore, is merely a
    shell that coordinates the execution of many external
    extensions to compile a single module. Sausage demonstrates
    that a compiler designed to be extended can evolve and adapt
    to new domains without a loss of efficiency.

Dr. Surana received his Doctorate in Computer Science from Northwestern
University.  He has spent several years working at Motorola's Software
Research Center and has completed internships at Microsoft Research.
His thesis is available here:

  * ftp://lispnyc.org/meeting-assets/2007-01-14_surana/SuranaThesis.pdf

2007-03-13 LispNYC Social#

Topic discussion: 2007 SOC and ILC at Westside

2007—03-15 LispNYC selected as a Sponsoring Organization for Google’s Summer of Code 2007#

Projects funded:

  • IOLib by Luis Manuel Borges de Oliveira
  • CL-ObjC by Luigi Panzeri
  • Purely Functional Data Structures in Common Lisp by Andrew Longfellow Baine
  • Gsharp Music interchange format support by Brian Gruber
  • NXTLisp - a Common Lisp library for the NXT Mindstorms Platform by Milan Cermak

CLAPPA by Andreas Fuchs has been funded privately by Clozure Associates

2007-04-10 LispNYC Social#

Topic discussion: 2007 SOC and ILC at Westside

2007-05-08 LispNYC Social at Westside#

2007-06-12 LispNYC Presentation#

Anton van Straaten presents Anton Unplugged: Pontifications of the R6RS Process at Trinity
Anton van Straaten, a member of the Scheme Steering Committee, will host
an unscripted free-form presentation/discussion on this groundbreaking
work.

Anton van Straaten is a consultant and software developer with a strong
interest in the design and development of programming languages. He
developed the award-winning software product Class(y), an
object-oriented language extension to the Clipper database language.
Class(y) extended the Clipper language by adding the ability to create
user-defined classes, creating a true object-oriented language, with
features such as multiple inheritance and a Smalltalk-style meta-object
protocol, based on metaclasses.  He also co-developed ExoSpace, a
protected-mode linker for Clipper which eliminated memory limitations.
ExoSpace was subsequently acquired by Computer Associates, a major
software vendor, and bundled with CA-Clipper.

Anton developed SchemeDS, an executable version of the formal
denotational semantics for the Scheme language, the only such
implementation publicly available and currently serves on the Scheme
Editors Committee, which is developing the Revised6 Report on the
Algorithmic Language Scheme (R6RS), a standard for the Scheme
programming language.

Anton hosts the programming languages community weblog Lambda the
Ultimate, founded by Ehud Lamm. He also hosts the Schematics Scheme
Cookbook, and the Community Scheme Wiki.

2007-07-10 LispNYC Social at Westside#

2007-08-14 LispNYC Presentation#

Perry Metzger presents Otter, a new dialect of Lisp at Trinity
    Otter is strongly influenced by Scheme and Python, with some
    bits of inspiration from Common Lisp, Perl and other
    languages thrown in, as well as some strange ideas Perry
    came up up with on his own.  The results may be pleasing to
    some and are guaranteed to be repulsive to others. If you're
    tired of waiting for Paul Graham to release Arc, you may
    find Otter interesting. If you don't care if Paul Graham
    ever releases Arc, you may also find Otter interesting. In
    the unlikely event that all goes according to plan, a
    prototype Otter interpreter.

Perry Metzger is a long time ne'er-do-well and agent provocateur. He
subsists largely on cruciferous vegetables, and rarely turns down a
chance to nap. Besides designing Otter, he is currently learning how to
distinguish different organic solvents by scent alone. He lives in New
York with a purple haired woman and many elderly computers whom he cares
for in their golden years.

Resources:

  http://www.otterlang.org/

2007-09-11 LispNYC Presentation#

Vladimir Sedach presents ParenScript, a Rich Internet Application Lisp-to-Javascript Compiler at Trinity
    ParenScript is a Lisp-to-Javascript compiler for building
    rich Internet applications.  Vladimir will highlight the
    advanced web server/framework integration and macro-magic
    that a Lisp-to-Javascript compiler enables.
    
    ParenScript's philosophy of producing maximally readable
    Javascript code with the absolute minimum overhead for
    advanced Lisp features enables straightforward, painless
    integration with Javascript libraries and tools such as
    Prototype and Firebug.

Vladimir is a Lisp hacker, consultant and organizer of the Calgary Lisp
User's Croup.

2007-10-09 LispNYC Social at Westside#

2007-11-13 LispNYC Presentation#

Rich Hickey presents Clojure - A Dynamic Programming Language for the JVM at Trinity
    Clojure is a dynamic programming language that targets the
    Java Virtual Machine. It combines the approachability and
    interactive development of a scripting language with an
    efficient and robust infrastructure for multithreaded
    programming.
    
    Clojure is a compiled language - it compiles directly to JVM
    bytecode, yet remains completely dynamic. Every feature
    supported by Clojure is supported at runtime. It provides
    easy access to the Java frameworks, with optional type hints
    and type inference, to ensure that calls to Java can avoid
    reflection.
    
    Clojure is a dialect of Lisp, and shares with Lisp the
    code-as-data philosophy and a powerful macro system. But
    Clojure is predominantly a functional programming language
    and features a rich set of immutable, persistent data
    structures. When mutable state is needed, Clojure offers a
    software transactional memory system that ensures clean,
    correct, multithreaded designs.

Rich is the author of the Lisp-related projects jFli, Foil and
Lisplets.  He has over 20 years experience developing sophisticated
scheduling, automation and analysis systems in a variety of programming
languages.

Resources:

  http://clojure.sourceforge.net/

2007-12-13 LispNYC Holiday Party#

The Holiday Party this year, will be in conjunction with the New York Technical Community at Suspenders

2008#

2008-01-08 LispNYC Social at Westside#

2008-02-12 LispNYC Social at Westside#

2008-03-11 LispNYC Meeting at Westside#

Summer of Code planning session

2008-03-17 LispNYC selected to be a Sponsoring Organization for Google’s Summer of Code 2008#

    Lexicons First-Class Global Lexical Environments for Common Lisp. Mentorship and sponsorship by Ron Garret.
    Erlang-in-Lisp Implement the Erlang concurrency model in Lisp, including the most important correct/safe handling of asynchronous events related to process termination. Mentorship and sponsorship by Francois-Rene Rideau

TODO more details

TODO

2009#

TODO

2009-05-12 LispNYC Social at the Cow#

2009-06-09 LispNYC Presentation#

Stuart Sierra

2009-06-20 Erik Naggum RIP#

https://twitter.com/kjetilv/status/2251766884

2009-07-14 LispNYC Social#

TODO

2009-08-26 Yacht Club Outing#

TODO

2009-11-03 LispNYC Presentation#

Gersholm Bazerman presents ‘’Simple Scheme for Tricky Differentials’’ at Trinity

Gershom Bazerman demonstrates an novel and elegant approach to modeling 
differential equations in functional languages.

Lazy splines can provide a clean way of expressing ordinary differential 
equations and deriving numeric solutions.  Unlike standard solvers, 
equations can be expressed simply and declaratively, as first class data 
in the target language (Scheme, Lisp, Haskell, etc.).  Differential 
equations can thus be turned directly into  easily readable and 
maintainable programs.

Differential equations have wide applicability -- from finance to 
physics to computer games. This presentation will be of interest to 
those who deal with calculus every day, as well as those who haven't 
seen an integral since high school. A short primer/review of 
differential equations will be included, as well as a discussion of the 
power of lazy evaluation and infinite streams in general.

Gershom is a Haskell developer in New York City, working in the finance 
sector.

http://en.wikipedia.org/wiki/Ordinary_differential_equation

2009-12-08 LispNYC Holiday Party#

At Heow’s House

2009-12-14 Clojure Fund Drive#

LispNYC donates generously.

2010#

2010-01-12 LispNYC Social at P&Gs#

TODO

2010-06-08 LispNYC Social at P&Gs#

2010-07-13 LispNYC Social at P&Gs#

2010-08-10 LispNYC Social at P&Gs#

2010-09-21 LispNYC Presentation#

Gary Warren King presents ‘’The AllegroGraph RDF Datastore Internals ’’ at Google

Graph Databases have become a hot topic within the growing NoSQL
movement because they provide Scalability, Flexibility, Social Network
Analytics, Event Processing, GeoSpatial Reasoning, and more.

AllegroGraph has emerged as an industry leading high-performance,
persistent graph database that scales beyond billions of
triples. AllegroGraph provides unique Event Processing capabilities
that are being incorporated into new Semantic Web applications such as
Amdocs' AIDA platform.

Gary Warren King describes AllegroGraph's, path finding, Social
Networking Analytics, GeoSpatial Reasoning and type inference details
all of which work together in AllegroGraph's novel scalability
strategy. There will be also be some speculative discussion about use
cases for Google's July 2010 acquisition of the largest Semantic
Technology Company - Metaweb/Freebase.

2010-10-12 LispNYC Social at Sunburnt Cow#

(presentation cancelled at last minute)

2010-10-22 Clojure Conj#

Marc Spitzer

Stuart Sierra

2010-11-01 Land of Lisp by Conrad Barski Published#

Program Lisp one Game at a Time, with music video

"Turns out the border between genius and insanity is a pretty cheery place" - Paul Graham

2010-11-09 LispNYC Presentation#

Hank Williams presents ‘’Death of the Relational Database’’ at Trinity

    People have begun to realize the enormous gap between the
    relational database abstraction and the way people actually
    think about information. To be clear, I am not suggesting
    that relational databases will stop being used or that they
    are going to go away, but that developers are going to stop
    thinking of their data in relational database terms.

    Everyone from regular users to sophisticated developers
    thinks about information in a pretty simple way. There are
    objects, and there are connections or relationships between
    objects. For example if you have two objects, a cup and a
    table, the relationship between them might be "sitting on",
    indicating that the cup is sitting on the table. What makes
    this model so sturdy is that we can continuously add new
    objects: tables, cups, chairs, floors, table cloths,
    etc. And we can add infinite relationships, such as sitting
    on, sitting under, covering, etc. Computer scientists, and
    now, thanks to Facebook, everybody else, refers to this
    structure as a graph.

    New data models such as the graph provide new ways to think
    about persisting data. The death of the relational database
    means the death of the relational database *abstraction* as
    a way that programmers think about data. What programmers
    need is to model data in the most natural way possible, and
    we are starting to see storage abstractions that are closer
    to how humans think instead of how computers need to.

    1. What is wrong with the relational database model.

    2. What are some of the important differences between
       databases in the non-relational landscape (mongoDB,
       flockDB, couchDB, cassandra, hbase etc)

    3. What are some examples of new types of applications made
       possible by the non-relational model and specifically the
       graph database approach.

    4. When can you not get away from relational technology just
       yet

    5. How does the Semantic Web relate to the issue of
       non-relational databases, and why hasn't it become
       successful yet.

    Listen to Hank Williams describe his Lisp system that
    natively supports these higher level abstractions such
    as authorization, event notification and user-executable
    code inside the traditional domain of what used to be
    called "the database".


Hank Williams has spent his professional career making products,
including Clickradio, an early Internet music service, and DayMaker,
one of the first personal information managers (address book,
scheduling, task, notes, etc.)  for the Mac.

He is now working on a new data and web development platform that will
change humanity as we know it.

Resources:

  http://whydoeseverythingsuck.com

2010-12-14 LispNYC Holiday Party#

http://www.meetup.com/LispNYC/events/15687518/

Help celebrate another year of Lisp! Our annual holiday party will be held in the back room of P&G's Lounge, food will be provided.

2011#

2011-01-11 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/15753170/

Tamreen Khan presents ‘’Pharen, a Lisp to PHP Compiler’’ at Google

Pharen, a Lisp to PHP compiler. PHP has been criticized for being bad,
among other things. Pharen is a Lisp to PHP compiler that tries to
solve the syntactic side of this issue, taking code in the lispy
dialect and spitting out the PHP equivalent of what you wanted to
do. Tamreen Khan covers more on the rationale of the project, features
that make it lispy (parentheses, tail recursion optimization, macros),
features that make it work with PHP, and other stuff. Tamreen Khan is
a student studying computer science at NYU. He usually works with PHP
or Python, sometimes professionally, and has occasionally made some
even worse languages. more info: See [Pharen Project
(github)|http://scriptor.github.com/pharen]

2011-02-01 New LispNYC Website#

In addition to a very exciting presentation this month, we're going to
be celebrating our upcoming new decade with the third major rewrite of
LispNYC!  The new site is sporting:

    * updated GUI
    * dynamic updates from Meetup
    * blogs ( http://lispnyc.org/blog-signup )  
    * SEO friendly
    * backward compatible with our old landing points

Being written in Clojure, it allows us to easily leverage the interals
of our new blog system to display recent updates.   Also behind the
scenes, we're using Meetup's API to display the most recent meeting and
Enlive for both templating AND parsing Meetup's API response.

LispNYC goes to WAR

The website is packaged as a Java Web Application aRchive.   This means
LispNYC is just another webapp.   It's as simple as dropping it into a
servlet container such as Tomcat or Jetty and watching it go.   Actually
the site is comprised of TWO webapps, one for the blog system and one
for the main site, both happily working together.

2011-02-08 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/15753263/

Bob Coyne presents ‘’Word's Eye: Converting Simple English Into 3D Scenes’’ at Google

3D graphics scenes are difficult to create, requiring users to learn
and utilize a series of complex menus and often tedious direct
manipulation techniques. WordsEye however, allows untrained users to
spontaneously and interactively create 3D scenes by simply describing
them. By giving up this level of detailed control, natural language
offers an attractive method to quickly and easily create a wide
variety of 3D scenes.

WordsEye has been used by several thousand users on the web to create
over 10,000 scenes and has been tested recently in a middle school
summer program at HEAF (Harlem Education Activities Fund) as an aid to
story understanding. WordsEye is written in Common Lisp and runs on
Linux. The current work in WordsEye is funded by NSF IIS-0904361.

Bob Coyne has worked at Symbolics Graphics Division, Nichimen
Graphics, and AT&T Research and is currently pursuing a PhD in
computational linguistics at Columbia University.

http://www.wordseye.com/

2011-03-08 LispNYC Meeting#

Summer of Code planning session!

Come and discuss ideas and plans for summer of code. Along with proposal ideas, we'll be looking for qualified mentors in a variety of domains at P&Gs.

2011-04-12 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/16755846/

Michael Bohn presents ‘’Acheron, Common Lisp's Google Web Toolkit’’ at Google

Acheron compiles [a subset of] Common Lisp directly to JavaScript
where it can be executed natively in nearly any web browser.

Similar to the strategy implemented by the Google Web Toolkit, Acheron
allows you to avoid the perils of JavaScript and use tools such as a
REPL in this interesting new JavaScript compiler.

Michael Bohn studied computer science at the Trier University of
Applied Sciences, Germany and he now works there as a researcher of
real-time systems and static program analysis.  Michael dedicated both
his bachelor and masters thesis to Lisp topics: Dandelion (a
Eclipse-based editor for Common Lisp) and Acheron.

This is our first presentation webcast live at 7:00 EST, 11:00 UTC at
http://bbb.brandorr.com/ (no webcast registration needed)


More info:
  http://lispnyc.org/blog/acheron
  http://sourceforge.net/projects/acheron/

Webcast:
  http://bbb.brandorr.com/

2011-05-10 LispNYC Social at P&Gs#

2011-06-04 LispNYC Summer Sailing Social
#

http://www.meetup.com/LispNYC/events/16771181/ (see photos)
We will hold our June 14th social meeting at the Manhattan Sailing
Club floating clubhouse, which is anchored off of Ellis Island.

There is a bar at the clubhouse, and a great view of New York Harbor.

Launches start departing from North Cove marina (located on the Hudson
behind the world financial center) at 6:00 pm, and leave on the half
hour. The cost is $10 for a round trip. If the weather is bad, then
the meeting will be moved to PJ Clarke's in the world financial
center.

If you have any questions, you can call Paddy at (917)488-4377

2011-07-12 LispNYC Social at P&Gs#

2011-08-09 LispNYC Presentation
#

http://www.meetup.com/LispNYC/events/17577440/

Stuart Sierra presents ‘’The Expression Problem’’ at MeetupHQ

Direct from ÜberConf, Stuart Sierra talks about the Expression Problem
and how Clojure provides tools for solving it.

Pizza and beer courtesy Meetup.

What is the Expression Problem? The question is far from academic: any
programmer working in mainstream object-oriented languages is bound to
encounter it. As a young language on the JVM, Clojure has the
opportunity to step back from mainstream approaches to object-oriented
design, and get back to core concepts like type and polymorphism. As a
Lisp, Clojure can offer features to achieve the goals of OOP with far
greater flexibility than a traditional Object Oriented language ever
could.

Stuart Sierra is an actor/writer/coder who lives in New York City. He
is a member of the Clojure/core team at Relevance, Inc. Stuart is the
co-author of Practical Clojure (Apress, 2010). He received an M.S. in
Computer Science from Columbia University and a B.F.A. in Theatre from
New York University.

2011-09-13 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/18481411/

John Cowan presents ‘’What’s new in R7RS’’ at MeetupHQ

Scheme is undergoing another revision cycle. Because of widespread
dissatisfaction with and resistance to R6RS, the Scheme Steering
Committee (Will Clinger, Marc Feeley, Chris Hanson, Jonathan Rees, and
Olin Shivers) decided to standardize two Schemes: a small language,
the direct successor to R5RS; and a large language, potentially larger
than R6RS or even ANSI Common Lisp.

Two Working Groups called WG1 and WG2 respectively were selected by
the Committee from volunteers. WG1 has been working busily, enhancing
R5RS with new features and improvements on existing features, with
reference to the consistency of the language and consistency with
existing implementations. The completion of that process is now in
sight with the publication of the third working draft of the small
language.

John Cowan is a member of both WGs and the chair of WG2. His talk will
discuss the goals of small Scheme, what WG1 has done, what it has left
to do, and (time permitting) something of WG2's work and plans to
date.

Pizza and beer (and soft drinks) provided, courtesy of Meetup.

2011-10-11 LispNYC Social at Malachy’s#

2011-11-08 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/35412312/

Scott Oltler presents ‘’Dump.fm’’ at Google

dump.fm is a live image chatroom for visual conversations, written in
Clojure by Scott Ostler and Tim Baker. Since its start in late 2009,
it's become a home for internet artists and their work. It was
presented at the NYTM, used as a live image feed for concerts, and
showcased by dump irl, an exhibit of art pieces made by dump users.

Scott will give an experience report of building and running a web
site with Clojure. Topics will include what worked and what didn't,
Clojure as a prototyping language, growing a community on custom
software, and keeping a side project healthy.

Bring your favorite gifs!

2011-12-13 LispNYC Holiday Party#

http://www.meetup.com/LispNYC/events/40491242/
We're entering our 10th year, so come out and help LispNYC celebrate
the holiday in style!

In collaboration with like-minded geek compatriots and longstanding
good friends NYLUG ( http://nylug.org ), it should be a party to
remember.

There will be food, drinks and many lambda-inspired surprises in the
big back-room of Suspenders (111 Broadway) starting at 7:00 and ending
debauchedly late.

2012-01-07 Internatonal Lisp Conference in Japan#

2012-01-10 LispNYC Social
#

http://www.meetup.com/LispNYC/events/43431292/

As a preview to next month's meeting, "Jay the Experience", Mr. Sultzberger will gratefully accept your questions

2012-02-14 LispNYC Social#

2012-03-07 Outing to see Peter Norvig#

2012-03-13 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/47373592/

Jay Sulzberger presents ‘’Jay Sulzberger, The Experience’’ at Google

The illustrious Jay will lead us on a first-class tour of his thoughts
regarding, but not limited to: distributed computation, database
schemata, quantum weirdness and the second half of Boole's Laws of
Thought.

Bell's Theorem will be stated as a limitation on what a certain lambda
expression can compute.  The main hypothesis in this version of the
theorem is that all functions in sight be classical, and not quantum.

It is recommended the gentle reader pack a healthy appetite for bad
jokes.

References:
http://www.hippiessavedphysics.com/
http://en.wikipedia.org/wiki/The_Laws_of_Thought
http://bayes.cs.ucla.edu/BOOK-2K/index.html
http://web.cecs.pdx.edu/~maier/TheoryBook/TRD.html
http://www.panix.com/~jays/Boole.four.page.summary.for.1.August.2006.Cork.conference.Sulzberger.v.5.pdf

2012-04-10 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/47373722/

Rocky Bernstein presents ‘’Large Scale Software Development with Elisp’’ at Meetup HQ

He lives in relative obscurity yet his software is used daily by
millions. Rocky Bernstein, former IBM Researcher, Chaitin co-author
and 30 year developer walks us through a mosaic of development
techniques focusing on personal software scalability.

The long time Free Software developer is best known for his decade of
debugger development using Emacs Grand Unified Debugger as a front-end
for his other works:

    Ruby Debugger (ruby-debug)
    Python Debugger (pydb)
    Perl Debugger
    POSIX Shell Debuggers for bash, Korn Shell, zsh and GNU Make

Additionally, Rocky is the author of libcdio: the GNU CD I/O and
ControlLibrary. Allowing multimedia assessing of CD-images
(includingISO-9660) in an OS and device-independent way, it is used in
FreeBSD, NetBSD and nearly every Linux distribution.

2012-04-27 New server CONS Commissioned at NYI#

2012-05-08 LispNYC Social#

http://www.meetup.com/LispNYC/events/56182362/ (photos)

Topics of discussion SICP, homoiconicity and "ESR on Lisp"

2012-06-12 LispNYC Summer Rooftop BBQ#

http://www.meetup.com/LispNYC/events/60123642/

Canceled due to weather, alternate location: Amsterdam Ale House

2012-07-10 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/60123742/ (photos)

Raymond de Lacaze presents ‘’Knowledge Extraction’’

Raymond describes his independent Lisp research project intended to
extract knowledge from the Wikipedia website.

His project combines natural language processing techniques, knowledge
representation paradigms and machine learning algorithms that creates
a semantic model of the information contained in Wikipedia.

This presents an algorithm for the automatic generation of topic
taxonomies and suggests how such a model can be used to implement
contextually relevant web searches. In doing so, Raymond provides a
brief overview of the following topics and algorithms:

    Natural Language Processing
    Semantic Nets
    Similarity Metrics
    Clustering Algorithms

2012-08-14 LispNYC Summer Rooftop BBQ#

http://www.meetup.com/LispNYC/events/60123782/ (photos)

Rays Rooftop Redux BBQ

2012-09-11 LispNYC Social#

http://www.meetup.com/LispNYC/events/67027682/

Memorial event for Daniel Weinreb

Topics of discussion ILC, Meta Object Protocol Poll and browser-based lisps.

2012-10-09 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/67586592/ (photos)

Heow Goodman presents ‘’Mining the Social Web’’ at Meetup HQ

Discussions about your company or organization are increasingly
happening on places other than your website. Learn by example how
LispNYC harnesses the community's collaborative and filtering power
using simple Clojure-based webapps.

2012-11-13 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/67586642/ (photos)

Drew Krause presents ‘’Introduction ot Algorithmic Composition’’

Drew Krause (wordecho.org) presents an introduction to algorithmic
composition using Lisp, including several currently available Lisp
music applications.  Additionally he discusses his own music work in
Lisp, which includes search, constraint programming, random processes
and other techniques.

Drew has been using Lisp for over 10 years to compose chamber,
orchestral, electronic and choral works. He is the author of the
Common Lisp Composer’s Library for algorithmic music composition and
is on the music faculty of New York University.

2012-12-11 LispNYC Holiday Party http://www.meetup.com/LispNYC/events/67586702/

LispNYC, NYLUG, PuppetNYC, LOPSA-NYC, NYCBUG, the NY Haskellers, 7
Languages, UNIGROUP, NYCDevOps Meetup Group, NY PostgreSQL User Group,
and the NY Functional Programmers Meetup Group are joining forces to
have a holiday party to remember.

All folks of all technical levels and interests are welcome. There is
no fixed agenda; just having a good time with fellow geeks.

We have lined up some sponsorship for appetizers and beer, but it will
not be a full open bar. If your company is interested in being a
co-sponsor please feel free to reach out to the organizers.

We would like to thank the following sponsors of the party:

    Addison Wesley
    Baynard Rock
    Brandorr Group
    Continuum Analytics
    CyberXDesigns
    NYI
    Opsdivina.com
    Puppetlabs
    Tumblr

2013-01-08 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/78022072/ (photos)

Raymond Puzio presents ‘’A Hyperreal Dictionary of Mathematics’’ at Meetup HQ

PlanetMath is a virtual community that aims to make mathematics more
accessible. Over the years, some of the PlanetMath contributors have
been doing research on how to improve PlanetMath's software–on the one
hand, adding new features to the user interface, and on the other,
adding artificial intelligence features in the backend.

One of the branches of the project that overlaps both of these areas
is a new hypertext system, which will not only be useful for storing
and editing the PlanetMath database but also for representing
mathematical knowledge in a form which is suitable for intelligent
manipulation by computer, such as verifying proofs and answering
questions. We call this "Arxana"; the name is loosely inspired by Ted
Nelson's Project Xanadu.

The main areas of current development which I will discuss are:

    Separation of front, middle and back-end by devising a standard
    interface. This makes the codebase more modular and makes it
    easier to reuse our earlier code. I'm focusing on the "middle end"
    so that we don't get lost in the details!  Representing literate
    programs as hypertext, with dependencies indicated by links, so
    that programs can be run as networks in situ or compiled down to
    standard code.  A hypergraph search facility which allows for
    semantic search, as well as implementing logical inference rules.

Raymond Puzio obtained his Bachelor's degree in Physics at Columbia,
where he had his first introduction to LISP in the basement of the
math building, followed by a doctorate at Yale.  After a few years in
academia, he became involved with PlanetMath, originally as a
contributor, later also becoming involved in organizational aspects of
the project as well. Shortly, after joining PlanetMath, he met Joe
Corneli, with whom he has since been collaborating on the projects
about which he will speak.

2013-02-08 Official Mailing Address by the US Postal Service#

    LispNYC
    Box 425
    New York, NY 10116 

2013-02-12 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/78022112/ (photos)

Brian Hurt presents ‘’Type Systems’’ at Meetup HQ

Although Lisp is generally known for its flexibility and dynamic
typing, it can certainly be made to accommodate static typing, which
is exactly what this presentation is not about.

The first in a series of talks, functional software guru and type
aficionado Brian Hurt discusses his personal philosophy of type
systems with the goals of writing more software, more quickly,
delivering it to market with fewer bugs.

In a language agnostic way, Brian discusses:

    An antagonistic history of type systems
    Static vs. dynamic types?  You're doing it wrong.
    Software guarantees
    Software Transactional Memory and concurrency
    Bug hunt: it's not even sporting anymore
    How and why C# failed
    The many benefits of functional software
    How to make Lisp even better

Pizza and beer provided by Meetup.

About our speaker:

It has been said that a programmer should learn three languages:
assembly language, Lisp, and Haskell. Brian has been paid to program
in assembly language, Ocaml, and Clojure, and declares this "close
enough." He's also been known to program in C, C++, Java, SQL, and
many other languages as need arises, but claims that BASIC programming
was only when he was young and foolish. "C'mon, man-I learned Pascal
and ditched BASIC when I was 12. Give me a break!" he replied.

2013-03-12 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/78022182/ (photos)

Arthur Smyles presents ‘’Haskell Data Types in Scheme’’ at Meetup HQ

This talk demonstrates how to build your own data type library
resulting in a simple/functional/extensible record system.

Similar to the way Haskell handles data types, included are: value
constructors, pattern matching, sum types, recursive types and some
thoughts on building type classes ...all in Scheme!

2013-04-09 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/78458392/ (photos)

Chris Shea presents ‘’Clojure West‘’ at Meetup HQ

Chris will provide us with the highlights of the Clojure West
conference which was held March 18-20th in Portland, OR. Chris will
give us with details of some of the more interesting presentations and
latest Clojure projects.

More specifically Chris will cover the following exciting new
developments in the Clojure community:

    Pedestal (http://pedestal.io/)
    ClojureScript-in-ClojureScript (https://github.com/kanaka/clojurescript)
    synthread (https://github.com/LonoCloud/synthread)

He will also give us an overall synopsis of the event as well as brief
us on the current trends and directions happening in the Clojure
community and give us as many interesting links as he can find!

2013-05-14 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/78458432/ (photos)

David Nolan presents ‘’Lisp is too Powerful‘’ at Meetup HQ

Lisp is simply too powerful.

Looking at concrete examples in Clojure and ClojureScript David
demonstrates the unsuitability of using a modern Lisp to solve
real world problems.

By the end of the talk you'll be convinced that less flexible
languages and weaker abstractions are better suited to meet
today's software engineering problems.

2013-06-11 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/78458492/ (photos)

Raymond de Lacaze presents ‘’Metaprogramming, Metaclasses and Metaobject Protocols‘’ at Meetup HQ

In three distinct but related sections, Raymond de Lacaze presents and
describes metaprogramming, metaclasses and the metaobject protocol.

Metaprogramming, is today somewhat synomous with the notion of
programming with macros.  Ray describes in detail what macros are, how
to write them correctly so that they are hygienic, how to debug them
and when to use them. Examples are provided in Common Lisp. He also
briefly describes what meta-programming looks like in other less
homoiconic languages.

Metaclasses are described along with what they are used for and can
accomplish. A specific use-case is examined in depth. This is done in
the context of the Common Lisp Object System (CLOS) and a brief
introduction to CLOS is provided.

Metaobject protocol leverages material from the seminal book "The Art
of the Metaobject Protocol" (AMOP) and describes the problems that
MOP's were designed to solve.  Ray explains how to design and
implement a metaobject protocol for CLOS.  Specifically he examines
code that implements the 'defclass' macro which is CLOS's class
definition mechanism, and extends the implementation to support
metaobject protocol functionality.

Finally, time permitting, Ray shares his personal ideas on what it
means to have a meta protocol for Clojure and how it might be useful.

2013-07-16 LispNYC Summer BBQ#

http://www.meetup.com/LispNYC/events/96126162/ (photos)

Burgers, Hot Dogs, Tofu, Chips and an initial amount of beer will be provided. You are strongly encouraged to bring along whatever else you'd like to grill and/or drink. Think potluck.

You will enjoy a great view of the sun setting on the Hudson river and over the New Jersey shoreline. A good time will be had by all and their will be much bickering and rejoicing.

This year we invited our friends from Clojure NYC and Haskell NYC. The menu and activities below have been updated to reflect this.

2013-08-13 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/96126232/ (photos)

Aysylu Biktimirova presents ‘’LOOM‘’ at Meetup HQ

Graph algorithms are cool and fascinating. We'll look at a graph
algorithms and visualization library, Loom, which is written in
Clojure. We will discuss the graph API, look at implementation of the
algorithms and learn about the integration of Loom with Titanium,
which allows us to run the algorithms on and visualize data in graph
databases.

Aysylu is a Software Engineer in NYC area. She graduated from MIT with
degree in Electrical Engineering and Computer Science. Coming from the
Java world, she found paradise in the Clojure land. Aysylu's interests
are in performance engineering, compiler design and optimization. In
her spare time, she also does oil painting and composes music. Follow
her on Twitter @aysylu22; personal website on http://aysy.lu; github
http://github.com/aysylu.

2013-09-10 Federal TaxID Issued#

LispNYC registers with the US federal government as an Unincorporated Nonprofit Voluntary Association.

2013-09-10 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/96126262/ (photos)

Mahesh Paolini-Su​bramanya presents ‘’Erlang‘’ at Meetup HQ

People get so caught up in the syntactical sugar of languages that
they never actually grok the semantics, let alone the context and
philosophy underlying the whole environment.  It doesn't really matter
whether we're talking about something 'old' like Java/Python/Ruby, or
'new' like Dart/Go/F# - any discussion about the merits tends to boil
down to either simplistic stuff like "The syntax sucks! Hrrr!", or
something"advanced" like "Garbage collection <redacted>".

In the case of Erlang - theres the bit about concurrency and scaling,
and functional programming and actors and stuff, but what most people
don't get is that it is really very simple

Erlang begins and ends with Fault Tolerance.

Fault Tolerance is - formally! - baked into the very genes of
Erlang/OTP - something that ends up being amazingly useful when you
are building any kind of system.  Remember, your clients (and
co-workers!) will find new ways to break things, ways that you could
never have imagined in your wildest dreams.

This, this is the reason to use Erlang. Once you get it, it completely
changes the way you approach development, and you will find yourself
writing "erlang" in whatever language you happen to be using (Mind
you, writing tail-recursive code in java is a recipe for disaster, but
thats another story…)

In this talk, I'll get into this buddha-nature of Erlang/OTP, pointing
out how the various features of the language tie together into one
seamless Fault Tolerant whole.  It'll probably run 45 minutes or so,
not counting questions…

Mahesh Paolini-Subramanya is the V.P. of R&D at Ubiquiti Networks - a
manufacturer of disruptive technology platforms for emerging
markets. He has been involved in ‘Internet Stuff’ since Day Zero
(remember Gopher?), and has spent the recent past building out
Erlang-based massively concurrent Cloud Services and VoIP platforms.

He has the - dubious -honor of being involved in creating the first
web/e-commerce system, the first Java based financial services
platform, as well as the first Erlang-based cloud PBX, three products
he may never live down.

He was previously the CTO of Vocalocity after its merger with Aptela
(where he was a founder and CTO). Before that, he was V.P. of
Development at Neoglyphics Inc, and CTO of Proxicom where he also led
the Technology practice. He holds a B. Tech from the Indian Institute
of Technology - Kanpur, and an M.S. in Electrical Engineering from the
University of Notre Dame.

2013-10-08 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/96126302/ (photos)

Dustin Mulcahey presents ‘’Lambda Calculus‘’ at Meetup HQ

A Friendly Introduction to the Lambda Calculus

LISP has its syntactic roots in a formal system called the lambda
calculus. After a brief discussion of formal systems and logic in
general, I will dive in to the lambda calculus and make enough
constructions to convince you that it really is capable of expressing
anything that is "computable". Time permitting, I will talk about the
simply typed lambda calculus and the Curry-Howard-Lambek
correspondence, which asserts that programs and mathematical proofs
are "the same thing".

Dr. Dustin Mulcahey holds a PhD in Mathematics with a specialization
in Homotopy Theory.

2013-11-12 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/96126342/ (photos)

Rich Hickey presents ‘’Datomic‘’ at Meetup HQ

Rich Hickey will present Datomic as a functional database, with some
hands on use from Clojure, and lots of time for Q&A.

2013-12-09 LispNYC Holiday Party#

http://www.meetup.com/LispNYC/events/96126362/ (photos)
This year's Holiday party will be held in conjunction with our friends
at NYLUG at our usual spot: Suspenders bar and grill in downtown
Manhattan!

We've also invited most of the functional language meetup community
including Clojure NYC, Erlang NYC, Haskell NYC, OCaml NYC, NY-Scala
and the N-Languages-in-N-Months meetup groups to join us in our
festivities!

This promises to a very interesting event with genuinely stimulating
conversations and a truly unique diversity of characters of all sorts!

2014-01-14 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/122950632/

François-René Rideau presents ‘’LIL: Lisp Interface Library‘’ at Meetup HQ

LIL: CLOS reaches higher-order, sheds identity, and has a
transformative experience

LIL, the Lisp Interface Library, is a data structure library based on
Interface-Passing Style. This programming style allows both parametric
polymorphism (like ML functors) and ad hoc polymorphism (inheritance
and mixins): CLOS generic functions take as first argument a
first-class interface object, and plain data structures as other
arguments. As compared to traditional object-oriented programming,
interfaces typically lack identity and state, while they manipulate
data structures without intrinsic behavior. It becomes as easy to use
pure functional persistent data structures without identity or state
as to use stateful imperative ephemeral data structures.


Judicious Lisp macros allow developers to avoid boilerplate and to
abstract away interface objects to expose classic-looking Lisp
APIs. Using only a very simple linear type system to model the
side-effects of methods, it is even possible to transform pure
interfaces into stateful interfaces or the other way around, or to
transform a stateful interface into a traditional object-oriented
API. The result is a library that really feels like the right way to
specify data structures, and that compares favorably with equivalent
libraries in Scala, F#, and other non-blub languages.

This presentation will be an update of a presentation given in October
2012 at ILC'2012.

https://github.com/fare/lil-ilc2012/

https://github.com/fare/lisp-interface-library

 

François-René Rideau is a cybernetician: one who thinks in terms of
the dynamics of human and computer systems, what is conserved when
change happens, and what varies according to what evolutionary
pressures. His first software organization principle is that he who
writes the code, he who knows the topic, and he who cares about the
results should be the same person — otherwise the software and the
people both are badly organized. He worked at ITA Software where he
became the Common Lisp build guy and notably rewrote ASDF and curated
QITAB; he recently joined the build team at Google. But he never
forgot his old TUNES project to reinvent computing.


http://fare.tunes.org/

http://fare.livejournal.com/

http://twitter.com/fare

http://www.facebook.com/fahree

http://tunes.org/

http://common-lisp.net/projects/asdf/

http://common-lisp.net/projects/qitab/

2014-02-11 LispNYC Social at The Iguana#

2014-03-11 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/122950762/

Tom LaGatta presents ‘’Category Theory‘’ at Meetup HQ

Tom LaGatta presents a basic introduction to category theory, namely,
some of the basic definitions and concepts.  More importantly,
emphasizing the role of abstract, categorical thinking in both
research and application. Just about anything you care about can be
faithfully represented using categories-- even the concept of
"representation" itself.  Understand how to use categories in your own
work, no background is necessary for the talk, questions and comments
throughout are welcome.

Tom LaGattaLa has a PhD in Mathematics from the University of Arizona,
and until recently was a postdoc at the Courant Institute at NYU. Tom
is currently transitioning to a career in the tech sector.

2014-04-21 NY Charitable Organization#

LispNYC is registered with the New York State Office of the Attorney General as a charitable organization.

2014-04-21 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/122950722/

Dr Eric E Moore presents ‘’A Work Reaction Calculaton‘’ at Meetup HQ

Dr. Eric E. Moore holds a PhD in Theoretical Chemistry. In grad school
the group's favorite saying was: "In theory there's no difference
between theory and practice. In practice there is."

In theory, this talk is about a program to generate "work reactions"
for use in computational chemistry. In practice it's a talk about
translating high level, poorly specified functional requirements into
working code, graph algorithms, and program design.

2014-05-05 Bank Account#

LispNYC is issued a bank account, checks can now be made.

2014-05-13 LispNYC Social#

Topics of discussion: Category theory vs Haskell, 2-lisp vs 1-lisp

2014-06-10 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/170683392/ (photos)

Stuart Sierra presents ‘’Components in Clojure‘’ at Meetup HQ

Functional programming with immutable values is wonderful, but sooner
or later every program has to deal with mutable, stateful, imperative
tasks. A large program may need to manage dozens of stateful services:
database connections, thread pools, network services, scheduled tasks,
and caches. How do we do this in a functional programming model? All
too often we fall back, almost by accident, into global mutable state,
promiscuous sharing, and imperative spaghetti code. To escape this
quagmire, we need to recall some basic principles of both functional
and object-oriented programming: referential transparency, immutable
values, message-passing, encapsulation, and interface contracts. The
Component pattern and its library implementation offer a minimal way
to structure the stateful dependencies of a functional program. This
talk will cover the motivation for the Component pattern, its benefits
and downsides, comparisons with other approaches, and how to use it in
Clojure programs. This presentation is a follow-up to my Clojure/West
talk, "Components: Just Enough Structure,"

https://www.youtube.com/watch?v=13cmHf_kt-Q

Bio: Stuart Sierra is a programmer, actor, musician, and writer. He
lives in New York City and works for Cognitect. He is the co-author,
with Luke VanderHart, of ClojureScript: Up and Running (O'Reilly) and
Practical Clojure (Apress).

2014-07-08 LispNYC Invitational Summer Party#

This is an annual LispNYC major social event in which we get together
with several other programming meetup groups to share food and spirits
and stimulating company and conversations.

This year, unfortunately, we will not be able to actually
BBQ. Therefore we encourage you to all to bring pre-cooked food and
pre-fermented beverages to the annual summer social.

The party on the roofdeck will run from 6:00PM untll 10:00PM at which
point some brave subset of us will head over to a cool local
neighborhood bar. So,from 10:00PM on, please join us at Cleopatra's
Needle, conveniently located a block away from the roofdeck on
Broadway between 92nd and 93rd Streets on the west side of the street
and head towards the back room there.

This an awesome yearly event and we look forward to seeing as many of
you as possible.

LispNYC will generously provide some initial quantity of Pizza, Beer
and Soda in order to bootstrap the event.

2014-08-12 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/171996212/

John Cowan presents ‘’Comparators: A Dynamic Type Class for Scheme‘’ at Meetup HQ

Haskell type classes such as Eq and Ord provide an escape hatch from
ML-style polymorphic static typing, allowing ad-hoc polymorphism of
the functions defined in a type class.  They are implemented by GHC
using a record of functions, one for each function declared in the
type class.  While developing Scheme libraries for the ongoing
R7RS-large standard, I found a need to parameterize collections such
as sets and hash tables with appropriate monomorphic procedures
applicable to their elements.  The implementation method evolved over
time to converge on the same solution, made directly accessible to the
Scheme programmer using a new data type: comparators, which are a
dynamically typed equivalent of type class Ord.

2014-09-09 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/171996572/ (photos)

Brian Hurt presents ‘’Derivatives of Regular Expressions‘’ at Meetup HQ

Brian introduces the notion of a partial derivative of a regular
expression, and demonstrate an implementation (in clojure), and show
how it can easily allow for capabilities not normally provided in most
regex libraries.

Note: there will be no math, only code.

This talk is based on the paper "Regular expression derivatives
re-examined" by Owens, Reppy, and Turon.

Slides and source code will be available before the talk- URLs posted
to the list when they're available (need to finish writing them
first).


2014-10-14 lisp.nyc Domain#

The New York City Top Level Domains (dot NYC) go live, Marc Spitzer successfully purchases lisp.nyc and assigns it to our .org website.

2014-10-14 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/171997342/ (photos)

François-René Rideau presents ‘’From Creationism to Evolutionism in Computer Programming‘’ at Meetup HQ

Abstract

Human brains are attuned to stories as the most powerful way to
communicate about the world. The most powerful stories are
cosmogonies, that tell the origin of the Universe (usually created by
a God or Gods, if any), and theodicies (or cosmodicies), that explain
why evil exists, despite (or because of) these Gods if any. These
stories are powerful precisely because they are not "just so", but
affect the very structure of how individuals set their purposes,
behave and organize.

In this talk I will explore logogonies, stories that tell the origin
of Software (usually created by a Man or Men), and anthropodicies (or
logodicies), that explain why bugs occur, despite (or because of)
these Men.

In a first part, I will explore such stories, from the simplest
version of Creationism to the most elaborate variants of Evolutionism,
and illustrate what they tell us about the way we write software, or
fail to write it.

In a second part, I will step back and discuss the use of such stories
themselves as tools, how they shape our behavior, and how we may shape
them to improve ourselves.


Notice Biographique

François-René Đặng-Vũ Bân Rideau is a Lisp Hacker and Libertarian
Writer who enjoys working where the structure of ideas (including
software) affects the structure of human interaction. He went to the
very best Schools in France, where he learned that schools mostly
don't matter, except for the great people you may meet. He failed at
reinventing computing with his TUNES project, and is only known for
reinventing ASDF, the build system of Common Lisp, eventually turning
Common Lisp into an Acceptable Scripting Language. He is currently
wasting his time at Google, working on a better extension language for
its massively scalable build system.

His Common Lisp code is at:
http://cliki.net/Fare%20Rideau and some 

more code is at:
http://github.com/fare/

you may also read his  Cybernethics blog at
http://fare.livejournal.com/ 

or follow his quips on:
http://twitter.com/fare 

his webpage is webpage at:
http://fare.tunes.org/ 

is only slightly less outdated than the TUNES project at:
http://tunes.org/

2014-11-25 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/171997582/ (photos)

David Nolan presents ‘’Clojure‘’ at Meetup HQ

David will be giving an exciting talk on some of the latest evolving
technology paradigms in the Clojure community. His presentation will
include insightful views into this rapidly spreading nouveau art of
functional excellence. While part of the presentation promises to be
visionary, there will also be a copious amount of actual code examples
and legendary live coding adventures.

David Nolen is a software engineer for Cognitect. He enjoys making
music, writing JavaScript, writing ClojureScript, and exploring new
approaches to user interface programming.

Twitter: @swannodette

This will actually be the last LispNYC meetup to be held at Meetup
HQ. Next year we will changing venues. We are extremely grateful to
Brian Gruber and Meetup HQ for generously hosting our multi-year stint
at Meetup HQ!

2014-12-01 LispNYC Holiday Party#

(photos)
LispNYC & NYC technical user groups are joining forces to hold another
holiday party to remember!

Groups include: 

- AWSNewYork (for users of Amazon Web Services) 
- CFSG (Community Free Software Group) 
- ChefNYC (for users of Chef) 
- DebianNYC (New York Debian Local Group) 
- DigitalOceanNYC (for users of Digital Ocean) 
- DockerNewYork (for users of Docker) 
- DrupalNYC (Drupal New York City) 
- Lopsa-NYC (League of Professional System Administrators New York City Chapter) 
- LispNYC (New York City Lisp User Group) 
- NYC*BUG (New York City *BSD User Group) 
- NYCCloudFoundry (users of Cloud Foundry PaaS) 
- nycdevops (New York City Devops Meetup Group) 
- NYC-Clojure (NYC Clojure Users Group) 
- NYC-OCaml (The NYC OCaml Meetup) 
- NYCPUG (NYC PostgreSQL User Group) 
- NYC PyLadies (Mentoring women in Python) 
- NY-Haskell (New York Haskell Users Group) 
- NYLUG (New York Linux Users Group) 
- NYPHP (New York PHP User Group) 
- PuppetNYC (New York Puppet User Group) 
- TA3M (Techo Activist Third Mondays) 
- UNIGROUP (New York City's Unix User's Group)

Everyone of all types of expertise and interests are welcome.  The
party starts at 7 PM and will continue until at least 10 PM.  It is
the ideal networking opportunity of the season, and a chance to
connect with old friends and make new ones.

Our generous sponsors are covering drinks and hors d'oeuvres for the
evening.  (Until the funds run out, at which point everyone is welcome
to stay and partake of the cash bar.)

The current list of sponsors includes:

- New York Internet (NYI) 
- InformIT (Imprints include Addison-Wesley, Prentice Hall, SAMS & more!) 
- Brandorr Group 
- LispNYC 
- Amazon Web Services 
- Digital Ocean 
- Chef 
- 2U, Inc 
- Jane Street 
- NYC PostgreSQL User Group 
- Serverfault.com / StackOverflow.com
    (Stack Exchange's sites for sysadmins and developers) 
- New York Times

2015-01-13 LispNYC Presentation#

(photos)

Bob Coyne presents ‘’Words Eye‘’ at Google
http://www.meetup.com/LispNYC/events/188535042/

WordsEye is a web application (in beta test) written in Common Lisp
that lets a user create rendered 3D scenes by describing them using
simple natural language. In this talk I will demo the system and
describe how it converts text to syntactic structure to semantic
representation to graphical constraints and finally to a 3D scene
graph that gets ray-traced in the cloud. I will also discuss some of
the user interaction issues as well as its potential in social media
and education. Parts of the WordsEye project were funded by NSF
IIS-0904361.

https://www.wordseye.com/

Bob Coyne has worked at Symbolics Graphics Division, Nichimen
Graphics, and AT&T Research. Bob is currently co-founder and CTO of
WordsEye, a fledgling web startup, and is finishing a PhD in
computational linguistics at Columbia University.

2015-02-10 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/188542282/ (photos)

Brandon Bloom presents ‘’Term Rewriting‘’ at Google

"Rewriting" is a powerful, but seemingly forgotten, programming
paradigm. This talk will shed some light on what rewriting is and what
it can do. We'll explore the past, present, and future of term
rewriting. In the process, we'll have some fun with Mathematica as
well as play with some toy Racket implementations of pattern matching
and StrategoXT-style rewriting strategies.

Brandon Bloom is performing a beam search through computer science and
the software industry. He's worked on systems from embedded to
distributed, frontend user experiences to backend core infrastructure,
and everything in between. Some of his more interesting projects
include Code.org's learning platform, Xbox's dev tools, and a social
enterprise startup. When not coding for hire, he's hacking on various
projects that only a programming languages geek could love.

2015-03-10 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/203087212/ (photos)

Lou Thrall presents ‘’Set Theory‘’ at Google

This talk will consist of both the theory of sets as well the 
description of a concrete implementation of Set Theory in Racket.

2015-04-14 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/213408062/ (photos)

Brian Hurt presents ‘’Monads Without Metaphors‘’ at Google

It has been said that monad tutorials are a cottage industry among
Haskellers.  Brian attempts to improve the state of the art of monad
tutorials by replacing the traditional bad metaphors and category
theory with motivating examples all programmers have encountered, and
actual code.

Slides for the talk are available on my github repo here:

https://github.com/bhurt/presentations/blob/master/monads.odp

I reference two blog posts in the talk- they are:

“Abstract Intuition and Monad Tutorial Fallacy”
https://byorgey.wordpress.com/2009/01/12/abstraction-intuition-and-the-monad-tutorial-fallacy/

“You could have invented monads! (And maybe you already have)”
http://blog.sigfpe.com/2006/08/you-could-have-invented-monads-and.html

2015-05-12 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/217730802/ (photos)

Gershom Bazerman presents ‘’From Scheme to Dependent Type Theory in 100 Lines‘’ at Google

From Scheme to Dependent Type Theory in 100 Lines

a.k.a. Lambda: The Ultimate Realizer

a.k.a. Homotopy Spaces: The Ultimate Extensional Realizer?

In this talk we will introduce Dependent Type Theory through the one
of the typically nicest ways to understand anything at all —
implementing it in Scheme! As it turns out, the untyped lambda
calculus provides excellent raw material over which to construct a
proof theory, based on the notion that a proposition may be verified
through the construction of a lambda-term which realizes its meaning.

A dependent type theory can also be thought of as a programming
language, and the system we develop, following Martin-Löf’s 1979
“Constructive Mathematics and Computer Programming” [1] can be thought
of as a “little language” embedded in Scheme that comes with a system
of judgments by which we can verify properties of our programs, and
which includes a foreign function interface to the whole of
mathematics.

We will point towards some questions that immediately arise when
asking “what does it mean for some value to be equal to some other
value” and “what does it mean for some type to be equal to some other
type,” and consider some of the approaches to answering these sorts of
questions. This invariably leads to the Univalence Axiom -- the
proposition that equality is equivalent to equivalence.

We will then proceed to a sketch of the homotopy interpretation of
type theory [2], in which the univalence axiom is validated. Finally,
we will conclude some ideas of how we can understand the homotopy
interpretation (and implement it) in light of the system presented.

The talk will be conducted using the racket variant of the Scheme
language, making frequent use of pattern matching.

[1] http://www.cs.tufts.edu/~nr/cs257/archive/per-martin-lof/constructive-math.pdf

[2] http://homotopytypetheory.org/book/

Biography: Gershom Bazerman is an organizer of the NY Haskell Users
Group and the NY Homotopy Type Theory Reading Group, which has now
been studying Homotopy Type Theory for over a year. He has given a
fair number of talks on programming and mathematics, and enjoys trying
to make apparently complicated things understandable.

2015-06-09 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/218893287/ (photos)

Raymond de Lacaze presents ‘’Logic Programming‘’ at Sharablee

This talk will cover various aspects of Logic Programming. We examine
Logic Programming in the contexts of Programming Languages,
Mathematical Logic and Machine Learning.

We will we start with an introduction to Prolog and metaprogramming in
Prolog. We will also discuss how miniKanren and Core.Logic differ from
Prolog while maintaining the paradigms of logic programming.

We will then cover the Unification Algorithm in depth and examine the
mathematical motivations which are rooted in Skolem Normal Form. We
will describe the process of converting a statement in first order
logic to clausal form logic. We will also discuss the applications of
the Unification Algorithm to automated theorem proving and type
inferencing.

Finally we will look at the role of Prolog in the context of Machine
Learning. This is known as Inductive Logic Programming. In that
context we will briefly review Decision Tree Learning and it's
relationship to ILP. We will then examine Sequential Covering
Algorithms for learning clauses in Propositional Calculus and then the
more general FOIL algorithm for learning sets of Horn clauses in First
Order Predicate Calculus. Examples will be given in both Common Lisp
and Clojure for these algorithms.

Pierre de Lacaze has over 20 years’ experience with Lisp and AI based
technologies. He holds a Bachelor of Science in Applied Mathematics
and Computer Science and a Master’s Degree in Computer Science. He is
one of the Director's of LispNYC.org and is currently a Senior
Developer at Shareablee.

2015-07-14 LispNYC Interjectional Summer Party#

http://www.meetup.com/LispNYC/events/218893270/ (photos)
Welcome to the Lisp Interjectional Summer Party!

This is an annual LispNYC major social event in which we get together
with several other programming meetup groups to share food and spirits
and stimulating company and conversations. We have invited the
following meetup groups:

Clojure NYC
Haskell NYC
OCaml NYC
Erlang NYC
F# NYC
N Languages

This year, unfortunately, we will not be able to actually
BBQ. Therefore we encourage you to all to bring pre-cooked food and
pre-fermented beverages to the annual summer social.

The party on the roofdeck will run from 6:00PM untll 10:00PM at which
point some brave subset of us will head over to a cool local
neighborhood bar.

So,from 10:00PM on, please join us at Cleopatra's Needle, conveniently
located a block away from the roofdeck on Broadway between 92nd and
93rd Streets on the west side of the street and head towards the back
room there.

This an awesome yearly event and we look forward to seeing as many of
you as possible. LispNYC will generously provide some initial quantity
of hors d'oevres and cocktails in the form of pizza & beer in order to
bootstrap the event.

2015-08-11 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/218893039/ (photos)

Christian Schafmeister presents ‘’CLASP‘’ at Google

Clasp: Common Lisp using LLVM and C++ for Molecular Metaprogramming

Abstract

I will present Clasp, a new implementation of Common Lisp that uses
LLVM as its backend and interoperates with C++ (available at
https://github.com/drmeister/clasp). I will also present the
motivations behind developing Clasp, which is to develop software that
will enable the design of sophisticated molecular devices that mimic
and rival the proteins that are the machines that build the natural
world.

A goal of Clasp is to become a performant Common Lisp that can use C++
libraries and interoperate with LLVM-based tools and languages. The
first sophisticated C++ library with which Clasp interoperates is the
Clang C/C++ compiler front end. Using the Clang library, Common Lisp
programs can be written that parse and carry out static analysis and
automatic refactoring of C/C++ code. This facility is used to
automatically analyze the Clasp C++ source code and construct an
interface to the Memory Pool System compacting garbage collector.

The primary purpose of Clasp is to act as a performant language for
scientific computing that will be used to design sophisticated new
molecular devices, catalysts and therapeutic molecules based on our
"Molecular Lego" technology. Clasp is a general programming language
that will support many other applications. About the Speaker:
Christian Schafmeister visited Google’s Cambridge, MA office to
deliver the talk "Clasp: Common Lisp using LLVM and C++ for Molecular
Metaprogramming”.

Bio

Christian is Associate Professor of Chemistry at Temple
University. Research projects within his group will use the tools of
synthetic chemistry, molecular biology, and X-ray crystallography to
develop a universal molecular scaffold that would allow the systematic
design, construction, and investigation of macromolecules that display
chemical functionality in three-dimensional space. A scaffold like
this will allow the design and synthesis of new catalysts, molecular
sensors, and ultimately molecular machines. His group will use
synthetic chemistry to synthesize molecular building blocks that they
will couple to each other through pairs of bonds to construct rigid
macromolecules with diverse and programmable shapes. His group has
developed computer software that allows the computer-aided design of
these molecules to carry out specific functions.

2015-09-08 LispNYC Presentation#

http://www.meetup.com/LispNYC/events/218915081/ (photos)

Alex Kehayias presents ‘’Functional Game Engine Design‘’ at Shareablee

Alex Kehayias will be exploring the challenges of building a game
engine using a (mostly!) functional style in Clojure/ClojureScript.

https://github.com/alexkehayias/chocolatier.

He has been actively working on it for over a year and has
experimented with numerous approaches that have revealed many benefits
and tradeoffs. We'll be seeing how to use data and functions to build
a game and how to play nice with the imperative world.

About the Presenter

Alex Kehayias is the CTO at Shareablee and works on biggish data
problems to help brands and publishers win the social web. Clojure and
Python are his weapons of choice by day and by night. He is an active
musician, tech community organizer (ClojureNYC), and helps mentor
people learning to code.

Twitter: @alexkehayias

GitHub:

http://github.com/alexkehayias

LispNYC is a nonprofit unincorporated association dedicated to the advocacy and advancement of Lisp-based software and development technologies such as Common Lisp, Clojure and Scheme.

We focus on education, outreach, regular monthly meetings and development projects.

Meetings are the second Tuesday of every month, are free and open to all.

Providing parentheses to NYC since 2002