( 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
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:
[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.
Note: ilug-ny.org was previously by Kenny Tilton
TODO link 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.
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.
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
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.
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.
Lisp Resource Kit with Allegro Common Lisp
Lisp Resource Kit with CMU Common Lisp
Lisp Resource Kit with LispWorks
LispNYC's first business card
[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.
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
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.
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.
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/
* 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.
[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.
* 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.
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!
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.
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?"
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
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.
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
Mentored by Robert Brown and Kenny Tilton
Technical Advisor Perry Metzger
Mentored by Kenny Tilton and Robert Brown
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.
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.
LispNYC was mentioned in Slashdot. Our website did not crash and burn.
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
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/
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")
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
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.
"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.
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.
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.
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
CLAPPA by Andreas Fuchs has been funded privately by Clozure Associates
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.
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/
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/
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
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
LispNYC donates generously.
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.
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
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
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.
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]
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.
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.
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.
Michael Bohn presents ‘’Acheron, Common Lisp's Google Web Toolkit’’ at Google
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
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.
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.
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!
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.
As a preview to next month's meeting, "Jay the Experience", Mr. Sultzberger will gratefully accept your questions
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
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.
Topics of discussion SICP, homoiconicity and "ESR on Lisp"
Canceled due to weather, alternate location: Amsterdam Ale House
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
Rays Rooftop Redux BBQ
Memorial event for Daniel Weinreb
Topics of discussion ILC, Meta Object Protocol Poll and browser-based lisps.
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.
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
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.
LispNYC Box 425 New York, NY 10116
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.
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!
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!
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.
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.
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.
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.
LispNYC registers with the US federal government as an Unincorporated Nonprofit Voluntary Association.
Mahesh Paolini-Subramanya 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.
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.
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.
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!
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/
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.
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.
LispNYC is issued a bank account, checks can now be made.
Topics of discussion: Category theory vs Haskell, 2-lisp vs 1-lisp
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).
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.
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.
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).
The New York City Top Level Domains (dot NYC) go live, Marc Spitzer successfully purchases lisp.nyc and assigns it to our .org website.
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/
David Nolan presents ‘’Clojure‘’ at Meetup HQ
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
Bob Coyne presents ‘’Words Eye‘’ at Google
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.
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.
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.
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
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”  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 , 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.  http://www.cs.tufts.edu/~nr/cs257/archive/per-martin-lof/constructive-math.pdf  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.
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.
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.
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.
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