"I have an on-going project, to code the Collatz sequence in as many languages as I can.

This book introduces Emacs Lisp and tells you how to make the editor do whatever you want, whether it's altering the way text scrolls or inventing a whole new "major mode." Topics progress from simple to complex, from lists, symbols, and keyboard commands to syntax tables, macro templates, and error recovery.

Oldrunner is a remake of Broderbund's Loderunner which contains the 150 original game levels.

GNU CLISP is an ANSI Common Lisp implementation with an interpreter, compiler, debugger, object system , sockets, fast bignums, arbitrary precision floats, and a foreign language interface that runs on most Unix variants and Win32.

This is a software development position where the candidate will be responsible for helping add new platforms to an existing internal program. This person will be working with a piler program and must have experience with the programming language LISP.

In an extended video that begins with Radio City's Rockettes and kettle drum players, Stephen Ramsay explains a litany of technology's most elusive topics, in terms anyone could understand - no, really.

The AI center at SRI International is looking for a highly creative
research engineer to join a team of researchers building evaluation
driven knowledge based systems.  We are seeking an individual with
strong background in logic, knowledge representation and ontologies.
The backend code is written in Lisp, and therefore, we require
strong Lisp programming skills.

Duties:

Responsibilities will include dedicated work in software development
and maintenance of complex software systems in the following areas:
- knowledge acquisition
- truth maintenance
- automated reasoning
- natural language processing

The research engineer’s role will be to contribute
approaches, designs, applications, implementations, documentation,
and publications. Initial project work will be to implement and extend
several knowledge management tools in Lisp.  We anticipate applying
these techniques to problems that are of interest to both government
and business with an eye toward commercialization
opportunities.  The position requires excellent communication skills,
willingness and ability to work in a team and to undertake a significant
system building effort.
Experience:

Background and exposure to Artificial Intelligence, specifically,
knowledge representation.  Substantial common lisp programming
experience.  Thorough understanding of web-based technologies,
for example, XML, HTML, and Java, and user interface programming.
Experience in writing test suites for large complex systems.

Education/Discipline Preferred:

MS/Ph.D. in computer science or equivalent with specialization in
Artificial Intelligence. Five years experience building complex systems.

Title of Position:

Senior Research Engineer / Computer Scientist

To insert individual citation into a bibliography in a word-processor, select your preferred citation style below and drag-and-drop it into the document.

I love reading any blog post that includes both "ridiculously large Buddhabrot" and "Lisp source included."

Check out Johann Korndoerfer's article about how he made a 20,000×25,000 pixel rendering of the Buddhabrot suitable for printing as a poster.

(Thanks for the link, mgr!)

See: http://www.gold.ac.uk/computing/research/studentships/

Not Lisp positions per se, but Lisp use would be fine, and Lisp is used extensively there.

A Boston Lisp Meeting will take place on Monday, July 26th 2010 at 1800 at MIT 34-401B. Slava Pestov will speak about Factor: an interactive, dynamic, stack-based programming language.

Additionally, we will have two Lightning Talks. Speakers to be announced.

Note that lacking a sponsor, buffet is no longer being offered after our meetings.

Factor is a new dynamically-typed language. http://factorcode.org/ Factor's strengths include an extensive standard library, an interactive development environment, extensive meta-programming features, efficient support for operations on packed binary data, and interoperability with C. The presentation will cover the Factor language and environment, demonstrate some interesting features, and touch upon the history and motivations behind the project.

Slava Pestov started programming in elementary school using HyperCard, then moved on to Java. After getting a lot of useful work done in Java, he then moved on to study esoteric programming languages, and like any self-respecting language enthusiast, noticed that all existing ones were lacking and decided to write his own.

At every meeting, before the main talk, there are two slots for strictly timed 5-minute "Lightning Talks" each followed by 2 minutes for questions and answers.

The slots for next meeting are still open. Step up and come talk about your pet project! Contact me at fare at tunes.org.

The Lisp Meeting will take place on Monday, July 26th 2010 at 1800 (6pm) at MIT 34-401B.

Note that it's a new location.

MIT map: http://whereis.mit.edu/bin/map?selection=34

Google map: http://maps.google.com/maps?q=50+Vassar+St,+Cambridge,+MA+02139,+USA

Many thanks go to Alexey Radul for arranging for the room, and to MIT for welcoming us.

We haven't been able to renew sponsorship from our usual partners for 2010, and are not planning to have after-meeting buffet anymore at this point. An informal group will probably gather to have dinner within walking distance of the venue.

The previous Boston Lisp Meeting on Monday, May 24th 2010 had about 26 participants. Marc Battyani spoke about Leveraging Common Lisp and FPGAs for ultra high performance computing. http://fare.livejournal.com/156739.html

We're always looking for more speakers. The call for speakers and all the other details are at: http://fare.livejournal.com/120393.html Volunteers to give Lightning Talks are also sought. http://fare.livejournal.com/143723.html

For more information, see our web site http://boston-lisp.org/ For posts related to the Boston Lisp meetings in general, follow this link: http://fare.livejournal.com/tag/boston-lisp-meeting or subscribe to our RSS feed: http://fare.livejournal.com/data/rss?tag=boston-lisp-meeting

Please forward this information to people you think would be interested. Please accept my apologies for your receiving this message multiple times. My apologies if this announce gets posted to a list where it shouldn't, or fails to get posted to a list where it should. Feedback welcome by private email reply to fare at tunes.org.

Steel Bank Common Lisp is a development environment for Common Lisp, with excellent support for the ANSI standard: garbage collection, lexical closures, powerful macros, strong dynamic typing, incremental compilation, and the famous Common Lisp Object System .

I hope that by later in the month I will have time to participate in the 2010 International Lisp Games Expo.

David O'Tool has announced the 2010 International Lisp Games Expo:

The 2010 ILGE is month-long exploration of programming and playing games in Lisp. This "virtual conference expo" is relatively free-form and self-assembling, something like the community it serves.

All entries must be playable games written in some dialect of Lisp (Common Lisp, Scheme, Arc, Clojure, et cetera.) Multi-platform release is encouraged, but not required.

More info on his site.

Cisco announced a business-oriented pad somewhat similar to IPad. While intriguing, it's not the most intriguing new thing I learned today at networkers, so let me write briefly about LISP.

Disambiguation (disambiguation).

(via Making Light)

I’m Luis Sergio Oliveira and I work with the other Luis Oliveira at
SISCOG who informed you about the hiring we started about 2 months
ago. We are still hiring and the opportunities are the same (we have
an objective of at least 9 persons and we are under half) that the
other Luis Oliveira sent a while ago and which is published at
http://www.siscog.eu/subarea.asp?idSubArea=45&idArea=1.

I’m directly involved in the hiring process, so, any specific question
please send to my work email in Cc or publish my email as “luis dot
sign oliveira at character siscog . pt.

Uber Conf Day 4 started with yet another 10 miler with fellow attendees in 1 hr 18 mins and 7:49 pace.

An in-depth look at the new language from the man himself. This month's column diverges from the normal pattern of covering my struggles with technology.

To insert individual citation into a bibliography in a word-processor, select your preferred citation style below and drag-and-drop it into the document.

This is a software development position where the candidate will be responsible for helping add new platforms to an existing internal program. This person will be working with a piler program and must have experience with the programming language LISP.

Peter got in touch with me because he tried to follow my instructions how to convert a Symbolics keyboard to USB with his old-style keyboard and he failed. He assumed, and that was what I would have assumed, that the color coding of the internal cabling of the old and new keyboards would match, but they don't. Here is a table that shows the pinout for both keyboard types:

So, we cast our minds back to April. When I booked my flight to Lisbon, I deliberately chose not to fly with British Airways, on the basis that they were likely to strike. It turned out that the activities of British Airways cabin crew was going to be the least of the problems associated with getting to an international conference...

Yes, shortly after I booked my tickets, Eyjafjallajökull went *boom* and most of Europe's airspace closed for a week, with ongoing disruption for the best part of a month. There were moments during the disruption when I wondered whether there was an actual curse affecting ELS, but in the event things cleared up and there was only minimal disruption to delegates and speakers, both getting there and getting back.

But enough about transport! How was the symposium itself? Well, I enjoyed the programme – but given that I had as much control over it as events would allow me, perhaps that's not the most unbiased endorsement of quality. Still, I was entertained by all the keynote speakers, from the window into the business world opened by Jason Cornez of Ravenpack, via the practical philosophy and view on history afforded by Kent Pitman, to the language experimentation and development in PLT Scheme Racket described enthusiastically by Matthias Felleisen. Pascal Costanza's tutorial on parallel and concurrent programming was highly informative, and there was a good variety of technical talks.

It's often said, though, that the good stuff at conferences happens between the programme, and for that the local organization needs to be on the ball. I'm glad to say that António Leitão and Edgar Gonçalves, and their helpers, enabled a huge amount of interaction: lunch, coffee and tea breaks, evening meals (including a fabulous conference banquet, but also a more informal dinner and a meal punctuated by Fado. I gather the excursion to Sintra on the Saturday was interesting; by then I was at the airport, looking nervously at the departure boards...

I enjoyed meeting and talking with many of the attendees; some whose names I knew but whose faces I didn't (and some whose names I knew because they shared them with other people who I knew already: take a bow, both Luís Oliveiras); but with always one eye on the next thing that could go wrong, I didn't get to go very deeply into interesting conversations. Maybe next year, in Hamburg for ELS2011 (expect the paper deadline to be around 31st December 2010) – in the meantime, there's likely to be a journal special issue with an open call for papers, coming soon, and of course the ALU are holding an International Lisp Conference this year, whose call for papers is currently open. So get writing!

The first article I ever wrote about computer software was way back in -- I think -- 1977.

I made a lot of bad decisions early in my lisp coding days. Lately I've been trying to undo some of the most egregious mistakes. One of the big mistakes was that I had way too many dependencies between my various libraries. Everything I wrote depended on ch-util and ch-asdf. There was no need for this.

I've released new versions of clem and ch-image that don't depend on ch-util and ch-asdf. There may still be some references in the doc building stuff, but the core libraries and their associated tests no longer depend on these.

Hopefully you've read the docs and know that you can override settings and implement your own extensions rather easily: Create a Lisp file under ~/.emacs.d/ specific to your username or system that Emacs with emacs-starter-kit will load automatically at startup.

Steel Bank Common Lisp is a development environment for Common Lisp, with excellent support for the ANSI standard: garbage collection, lexical closures, powerful macros, strong dynamic typing, incremental compilation, and the famous Common Lisp Object System .

SWIG is a software development tool that connects programs written in C and C++ with a variety of high-level programming languages.

For others, LISP has a different meaning that is rooted in the future of Internet routing.

Personalize Layout Nick Harrison Thoughts on Design and Architecture Automatic Generalization I have been interested in functional programming since college.

• Introduction
• Drawing colored triangles and quadrilaterals
  • Drawing with vertex coloring
  • Drawing with flat coloring

Introduction

In the previous tutorial, we drew a plain triangle and quadrilateral on the screen. The next NeHe tutorial colors this triangle and quadrilateral.

We’re going to start with our simple-tutorial base.

Drawing colored triangles and quadrilaterals

In the base display code, we already cleared the color buffer and the depth buffer and reset the modelview matrix. Now, we’re going to translate the modelview matrix so that when we draw our triangle, it is going to be in front of our viewpoint and off to our left. Then, we’ll draw the triangle, translate over toward the right, and draw the quadrilateral.

The above is untouched from the previous tutorial.

Drawing with vertex coloring

Now that we’ve moved over to the side a little bit and back a ways, we’re going to draw a triangle. We open with the with-primitives call and then specify the vertexes.

Before, we simply listed the vertexes. Here, we are going to specify a color before each vertex.

The arguments to color are the red, green, and blue values (respectively). The values range from zero (for the darkest) to one (for the brightest). I have omitted here the optional fourth argument for the alpha channel. It defaults to 1.0.

It is important to note that we have set the global color to red. This vertex will be red because the global color was red at the time we created the vertex. If we failed to ever set the color again, everything would be red.

Here, however, we’re going to make the next vertex green.

We are going to make the final vertex blue for this triangle.

Note: the global color is now blue. We could leave it blue and it would be blue until we set it to some other color.

Drawing with flat coloring

Drawing quadrilaterals is much like drawing triangles. Here, of course, we need four vertexes. In this case, however, we’re going to color the whole quadrilateral the same color. So, we are just going to set the global color to a light blue and then draw the quadrilateral exactly as we did in the previous tutorial.

Now, the color is still this light blue. It will remain so until we reset the color to red when drawing the triangle during the next time our screen is redrawn.

• Introduction
• Drawing triangles and quadrilaterals
  • Drawing triangles
  • Drawing quadrilaterals
• Toggling Fullscreen mode
  • Switching based on keyboard event

Introduction

In the previous tutorial, we made a basic shell of a CL-OpenGL application. I have slightly modified it for this tutorial so that it has some hooks where we can add in code specific to this tutorial.

In this tutorial, we’re going to draw a triangle and a quadrilateral in our window. We’re going to start with our simple-tutorial base.

Here is the whole tut02.lisp.

Drawing triangles and quadrilaterals

In the base display code, we already cleared the color buffer and the depth buffer and reset the modelview matrix. Now, we’re going to translate the modelview matrix so that when we draw our triangle, it is going to be in front of our viewpoint and off to our left. Then, we’ll draw the triangle, translate over toward the right, and draw the quadrilateral.

The parameters to gl:translate are x, y, and z (respectively). After the gl:load-identity, the modelview matrix is centered at the origin with the positive x axis pointing to the right of your screen, the positive y axis pointing up your screen, and the positive z-axis pointing out of your screen.

With the way that we set up the projection matrix in the reshape method, the origin of the modelview space should be dead-center in our window.

Drawing triangles

Now that we’ve moved over to the side a little bit and back a ways, we’re going to draw a triangle. The CL-OpenGL code looks like this:

The with-primitives form lets OpenGL know how to use the vertexes we’re going to make. In this case, it’s going to make a triangle out of each set of three vertexes. If we had six vertexes there, we’d end up with two triangles.

Here, we drew the vertexes in clockwise order. By default, OpenGL considers this triangle to be facing away from us, then. With our current OpenGL settings, this does not make a difference since OpenGL will draw both front and back faces.

Each call to vertex gives the x, y, and z (respectively) coordinates in the modelview projection for the vertex. You will note that I used floating-point numbers here. I could have easily written them as integers like (gl:vertex 1 -1 0). CL-OpenGL would convert them to floating point numbers for me on the fly. I tend to use floating point constants when possible to try to save it the extra work. I should check, sometime, to be sure though that I don’t pay a boxing/unboxing penalty that negates the benefit.

Drawing quadrilaterals

Drawing quadrilaterals is much like drawing triangles. Here, of course, we need four vertexes.

In this case, we drew a square. We could draw any convex quadrilateral.

Again, we drew the vertexes in clockwise order. By default, OpenGL considers this triangle to be facing away from us, then. With our current OpenGL settings, this does not make a difference since OpenGL will draw both front and back faces.

Toggling Fullscreen mode

We’re also going to add a slot that keeps track of whether or not our window is full screen.

Then, before we display our window, we’re going to switch to fullscreen mode if this is true.

Switching based on keyboard event

Here, we add an extra case to the keypress handler. We destroy our window and create a new one with the fullscreen property toggled if we get an 'f' on the keyboard.

One of the things I have been missing in CL was convenient indexing for sub-arrays. Languages like R and Octave all have convenient sub-array indexing. I have experimented with various designs before (some of them I made public, eg AFFI and xarray), but none of them were entirely satisfactory and I kept searching for new solutions.

This is primarily an issue of syntactic convenience: I want to be able to select elements from arrays without writing (nested) loops. I also want to be able to copy elements from arrays to other arrays, similarly selected. Speed is welcome, but at this stage it is secondary: so far, profiling indicates that these operations comprise a tiny fraction of execution time in my programs, but having the ability to capture operations using (sub)arrays is an enormous timesaver and an invaluable semantic abstraction.

 CLNU> (defparameter *a* #2A((1 2 3 4) (5 6 7 8) (9 10 11 12)))
*A*
CLNU> *a*
#2A((1 2 3 4) (5 6 7 8) (9 10 11 12))
CLNU> (sub *a* 1 t) ; second row
#(5 6 7 8)
CLNU> (sub *a* '(1 . 2) t) ; second row as matrix
#2A((5 6 7 8))

 CLNU> (sub *a* t #(0 3)) ; first and last columns
#2A((1 4) (5 8) (9 12))
CLNU> (sub *a* t #(3 0)) ; last and first columns
#2A((4 1) (8 5) (12 9))

 CLNU> (sub *a* -1 t) ; last row
#(9 10 11 12)
CLNU> (sub *a* #(-2 -1) #(-2 -1)) ; bottom right 2x2 matrix
#2A((7 8) (11 12))

 CLNU> (sub *a* '(-2 . 0) t) ; last two rows
#2A((5 6 7 8) (9 10 11 12))

 CLNU> *a*
#2A((1 2 3 4) (5 6 7 8) (9 10 11 12))
CLNU> (setf (sub *a* 1 t) #(-1 -2 -3 -4)) ; replace second row
#(-1 -2 -3 -4)
CLNU> *a*
#2A((1 2 3 4) (-1 -2 -3 -4) (9 10 11 12))
CLNU> (setf (sub *a* 2 t) (map 'vector #'+ (sub *a* 0 t) (sub *a* 1 t)))
#(0 0 0 0)
CLNU> *a*
#2A((1 2 3 4) (-1 -2 -3 -4) (0 0 0 0))

 (defmethod sub ((array array) &rest ranges)
           (declare (optimize debug (speed 0)))
  (with-range-indexing (ranges (array-dimensions array) next-index
                               :end? end?
                               :range-dimensions dimensions)
    (let ((result (make-array (coerce dimensions 'list)
                              :element-type (array-element-type array))))
      (iter
        (until end?)
        (for result-index :from 0)
        (setf (row-major-aref result result-index)
              (row-major-aref array (next-index))))
      result)))

Reflecting upon my previous post , I am wondering why LISP triumphalists like Paul Graham annoy me so much? Perhaps it is because I used to be one myself, in spirit if not in syntax.

The Twin Cities Lisp Users Group meeting for May was last Tuesday.

Teaching Introductory Programming Using Scheme

Daniel Feldman gave this presentation at the TC Lispers meeting in May 2010.

• Presentation Slides
• Course Description page

Teaching Introductory Programming Using Scheme on Vimeo.

ASDF2

Robert Goldman gave this lightning talk to the TC Lispers meeting in May 2010.

• Presentation Slides
• ASDF home page

ASDF2 on Vimeo.

Programming Contest

Patrick Stein gave this lightning talk to the TC Lispers meeting in May 2010.

• Presentation Slides

Programming Contest on Vimeo.

Lightning talk by Patrick Stein to the Twin Cities Lisp Users Group about hosting a Programming Contest. This presentation was recorded on 2010-05-25.