About Lectures Research Software Blog
Musical Site
MySpace
Facebook

Moods Blog

Dojo Shin Kaï

RSS Feed
Thank you!

XHTML 1.0 conformant
CSS 2.0 conformant
Didier Verna's scientific blog: Lisp, Emacs, LaTeX and random stuff.

Monday, January 28 2013

FiXme 4.2 is out

I'm pleased to announce that, after more than two years, I've managed to put up a very small release of FiXme (my collaborative annotations tool for LaTeX2e) in which I didn't even author the two included changes...

Keep the faith. FiXme is still alive !

New in this veresion (4.2):

** Improve Danish translation
thanks to Lars Madsen.
** Fix buglet in redefinition of \@wrindex
reported by Norman Gray.

Get it at the usual place.

Sunday, December 2 2012

ELS 2013

We are pleased to announce the next edition of the European Lisp Symposium: ELS 2013, to be held on June 3/4 2013 in Madrid, Spain.

This year we have the pleasure and honor of having Christian Queinnec and Manuel Serrano as co-chairs, and Juan-Jose "Juanjo" Garcia Ripoll, leader of the ECL project, as local organizer.

What's more, and for the first time, we are also delighted to announce that the symposium will be held in co-location with ECLM, the next European Common Lisp Meeting!

A couple of exciting days to come...

Tuesday, October 23 2012

Declt 1.0b15 "Kyoto" is out

This is Declt 1.0b15, the "Kyoto" release... Declt is a reference manual generator for Common Lisp libraries.

This version underwent a major internals overhaul, required by some of the new features described below:

  • Packages sections now advertise all definitions instead of just the symbols naming them. They also advertise their use-list and used-by-list, with cross-references.
  • Conditions, structures and classes now advertise their sub- and super-classes, direct methods, initargs and slots, with cross-references.
  • Slots documentation include docstring, type, initargs, initforms, readers and writers with cross-references.
  • Declt now documents symbol macros and compiler macros.
  • The *LINK-FILES* special is gone (M-x all-hail-purely-functional-style).
  • All ASDF components now advertise their descriptions and long descriptions, if any.
  • Docstrings are displayed in a more reader-friendly fashion.
  • Documentation entries for methods are nested within the corresponding generic function entry.

Grab it at the usual place.

The European Lisp Symposium website is back on (sort of)

In the recent months, the European Lisp Symposium steering committee has been seeking to improve its organization, notably on the financial level. To this aim, we created a non-profit organization in France (it's called ELSAA) which will help by providing a legal entity for all kinds of transactions.

A couple of days ago, I bought the domain name elsaa.org and started to re-install the ELS website that disappeared some time ago. I also took the opportunity to move the pages of the former European Lisp Workshop there (european-lisp-workshop.org now points to it). If you want to access the ELS pages, you can do so right now by using this URL: http://els.elsaa.org. The domain name european-lisp-symposium.org has not been redirected yet, but this will come soon I hope.

Sorry to all of you who asked for those pages recently...

Wednesday, September 26 2012

Clon 1.0b23 is out

A new version of Clon, the Command-Line Options Nuker is out.

Amongst other things, the following improvements have been made:

  • Support for ABCL has been updated, now that it provides a full MOP.
  • A workaround for SBCL's CC environment variable problem has been implemented. If the variable is not set (required for sb-grovel), Clon now switches to restricted mode instead of aborting.
  • The DUMP macro has been extend to accept a &rest argument that will be passed on to the underlying, implementation-specific, dumping facility.
  • A contrib directory has been added, for storing unapplied patches, suggestions etc.

Grab it at the usual place.

Tuesday, September 25 2012

Declt 1.0b14 is out

I've just released a new version of Declt, my reference manual generator for ASDF systems.

This release containts some improvements based on Sabra Crolleton's feedback. The most notable improvements are support for two new license types (MIT and LGPL), a new :DECLT-NOTICE keyword argument that gives you control on the "automatically generated by Declt" notice that appears in the reference manuals, and a bug fix (missing support for empty lists in lambda-lists).

Grab it at the usual place.

Thursday, July 12 2012

Language wars

Programming languages are tools. Just like hammers. There's nothing personal about them. They just help you build stuff. Yet, there are many religious wars about programming languages out there. Wars which despite being all about science, are much more related to emotions, beliefs and personal aggressions than about objective arguments.

This is funny because do you know of any religious wars about hammers? So what's the difference?

Here's a recent personal example. A guy explaining how the static typing of Common Lisp works (type declarations) and what kind of performance-oriented optimization can be achieved with it (C-like, static but weak typing in SBCL for instance). And then, there's inevitably the troll (whom I know knows better) in the audience who goes:

So, yeah, what you're doing is just C code, and you have to type manually, and it's ugly. So if it's just for writing C code, I don't see the point in using another language.

Hmmm. Let's see. So, yes indeed, static typing in Common Lisp is ugly. And yes, it's not even strong typing. And yes, it would be nicer to have run-time hotspot detection and automatic type-dependant optimization like what's found in some other languages or virtual machines, rather than having to do it by hand (BTW, that would make for a nice Ph.D. I think). But what does that really tell you? That no language is perfect? Wow, thank you very much, that's new. For as much as I think that Lisp The Idea™ is perfect, I don't think anyone ever pretended that Common Lisp (or any Lisp for that matter) was. But is that a reason for not using it at all and sticking to C? Any sane computer scientist knows that the choice of a language doesn't boil down to only one parameter. Any computer scientist who tells otherwise is a troll.

In spite of all its defects, I still have a gazillon reasons to prefer Common Lisp over C, C++, or any language that I know of currently (and this may very well change in the future). The flexibility of lambda lists, the macros, the MOP or more generally its structural and behavioral reflexivity. Its run-time compilation, debugging, introspection and intersession capabilities. These are just a few examples. Still, I don't deny anyone the right to prefer another language for whatever purpose and whatever reasons they may feel legitimate.

So, I normally just ignore those purposedly trollesque and completely idiotic remarks. Yet, sometimes like yesterday, I snap. It gets on my nerves and I become all upset and angry. Why? I never get angry when someone tells me that my hammer is a piece of crap (it's not). I do enough Aikido to know how to control my temper, but for some reason, it doesn't always work when it comes to programming languages. So what is it about them that in spite of all your efforts, you can't help from getting personally and emotionally involved once in a while?

I think the answer becomes apparent when you consider the artistic aspect in programming. When an artist creates a piece (music, theater, dance, painting, architecture, whatever you like), (s)he exposes a very intimate part of himself through his creation. The art "is" the artist, and the artist "is" his art. In doing so, he puts himself in danger. It's like yelling out to the whole world Hey, look, I'm vulnerable right here!!. It's a well know fact that many artists are very fragile, in the sense that they suffer from their creation not being liked. Because a piece of art is intrinsically a piece of the artist himself, when you say I don't like this piece of art, you're actually saying I don't like the artist. Then, it's up to artist to handle the fact of not being liked.

And that's the whole problem, which, as a musician, I know all too well. Where does the artistic fiber come from? It's an urge to express yourself. To express something that you can't express in any other way. A very deep and perpetual wound of some sort, a feeling of not really belonging. More importantly, it's a calling. Sometimes, the simple fact of creating is enough to heal you a bit, but more often, you create in order for your creation to be seen or heard. So yes, it's a calling to the Others. You expect them to answer your call by telling you that they like you (your art, but that is the same). Artists often have this urge to be liked by the Others. So when you dislike some artwork, you're also not liking the artist himself (the part of him that lives in his creation) and you're actually giving him the exact opposite of what he was looking for. And that hurts.

Back to programming languages. Why do we get all emotional about them, and not about hammers? The answer is in fact quite simple. Look at an architectural masterpiece. Do you see the hammer that was used to build it? Now look at a software masterpiece. Do you see the language that was used to write it? That's the crucial difference. You cannot decouple the language from the software, even once it has been written (the art is not in the executable; it's in the source code). The language itself will always be here for you to contemplate.

All in all, I think that's why there will always be language wars. Languages are not just tools, actually. They're not just like hammers. As soon as you care about the code you write, your software becomes artwork, you become an artist, and you start to be personally and emotionally involved. Your software becomes part of you. And contrary to the hammer, your sticky programming language, being intrinsically bound to the artwork, also becomes part of you. That's when the battle for objectivity is lost. By criticizing the language, the troll also criticizes your artwork, and in doing so, he tells you that he doesn't like you. That may hurt.

It's good to consider programming as art. Unfortunately, this also means that there will always be language wars.

Monday, June 4 2012

Declt 1.0b13 is out

I've just released a new version of Declt, my reference manual generator for ASDF systems. This release includes some uninteresting internals update, plus an important bug fix: there were two calls to FIND-METHOD missing an ERRORP flag set to nil, leading to Declt throwing an error where it shouldn't have.

Grab it at the usual place.

Tuesday, May 22 2012

Clon 1.0b22 is out

A new version of Clon, the Command-Line Options Nuker is out.

The most important change in this release is the support for LispWorks, which brings the number of supported implementations to 8. One left to go, and I may eventually switch to RC status. Thanks to Martin Simmons for providing a fully functionnal version of LW 6.1. As for CLISP and Allegro, there is an optional dependency on CFFI for LispWorks.

Two backward incompatible changes that may affect you:

  • Variables renamings: *current-context* has been renamed *context*, and *default-synopsis* has been renamed *synopsis*. This should remain transparent unless you're using Clon in a somewhat advanced way.
  • clon:exit has been upgraded to SBCL's new quitting protocol. If you use this function (or if you want to compile the demo programs), please upgrade to SBCL 1.0.57.

Finally, support for terminal autodetection and stream handling in general has been improved for all implementations.

Grab it at the usual place.

Call for Papers: ACM SAC'13 PL: ACM Symposium on Applied Computing, Programming Languages track

CALL FOR PAPERS

SAC'13 - ACM 2013 SYMPOSIUM ON APPLIED COMPUTING
Technical Track on "Programming Languages"
March 18-22, 2013
Coimbra, Portugal


SAC '13
Over the past 27 years, the ACM Symposium on Applied Computing has become a
primary forum for applied computer scientists,
computer engineers, software engineers, and application developers from around
the world to interact and present their work.
SAC 2013 is sponsored by the ACM Special Interest Group on Applied Computing
(SIGAPP). For additional information, please
check the SAC web page: http://www.acm.org/conferences/sac/sac2013/. This
document is also available at:
http://www.cse.unt.edu/~bryant/sac2013/PL-SAC13-CFP.pdf

PROGRAMMING LANGUAGES (PL) TRACK

A technical track on Programming Languages will be held at SAC'13. It will be
a forum for engineers, researchers and practitioners throughout the world to
share technical ideas and experiences relating to implementation and
application of programming languages. Original papers and experience reports
are invited in all areas of programming languages. Major topics of interest
include but are not limited to the following:
− Compiling Techniques,
− Domain-Specific Languages,
− Formal Semantics and Syntax,
− Garbage Collection,
− Language Design and Implementation,
− Languages for Modeling,
− Model-Driven Development and Model Transformation,
− New Programming Language Ideas and Concepts,
− New Programming Paradigms,
− Practical Experiences with Programming Languages,
− Program Analysis and Verification,
− Program Generation and Transformation,
− Programming Languages from All Paradigms (Agent-Oriented, Aspect-Oriented,
Functional, Logic, Object-Oriented, etc.),
− Visual Programming Languages.

GUIDELINES FOR SUBMISSION

Paper submissions must be original, unpublished work. Submissions should be in
electronic format, via the START site:
https://www.softconf.com/c/sac2013/.
Author(s) name(s) and address(es) must not appear in the body of the paper,
and self-reference should be avoided and made
in the third person. Submitted papers will undergo a blind review process. 
Authors of accepted papers should submit an
editorial revision of their papers that fits within six two-column pages (an
extra two pages, to a total of eight pages,
may be available at a charge). Please comply with this page limitation already
at submission time. For accepted papers,
registration for the conference is required and allows accepted papers to be
printed in the conference proceedings.
For each accepted paper, an author or a proxy attending SAC MUST present the
paper. This is a requirement for the paper
to be included in the ACM/IEEE digital library. A set of selected papers,
which did not get accepted as full papers,
will be accepted as poster papers and will be published as extended 2-page
abstracts in the symposium proceedings.
After the conference, selected accepted papers will be invited to a special
issue of the Computer Languages, Systems and
Structures journal
(http://www.journals.elsevier.com/computer-languages-systems-and-structures/).

IMPORTANT DATES
September 21, 2012: Full Paper Submissions
November 10, 2012: Author Notification
November 30, 2012: Camera-Ready Copy

The SAC 2013 Programming Language Track Program Committee Members
Vasco Amaral, Universidade Nova de Lisboa, Portugal
Roberto da Silva Bigonha, Universidade Federal de Minas Gerais, Brasil
Haiming Chen, Chinese Academy of Sciences, China
Johan Fabry, University of Chile, Chile
Sebastian Guenter, Vrije Universiteit Brussel, Belgium
Gopal Gupta, University of Texas at Dallas, USA
Christian Haack, University of Nijmegen, The Netherlands
Christian Hammer, Saarland University, Germany
Matthias Hauswirth, University of Lugano, Switzerland
Pedro Henriques, University of Minho, Portugal
Michael Hind, IBM, USA
Nigel Horspool, University of Victoria, Canada
Zoltan Horvath, Eotvos Lorand University, Hungary
Bo Huang, Intel, China
Geylani Kardas, Ege University, Turkey
Shih Hsi "Alex" Liu, California State University, Fresno, USA
Hanspeter Moessenboeck, Johannes Kepler Universitat Linz, Austria
Jesús García Molina, University of Murcia, Spain
Nikolaos Papaspyrou, National Technical University of Athens, Greece
Corneliu Popeea, Technical University of Munich, Germany
Andre Santos, Universidade Federal de Pernambuco, Brazil
Bostjan Slivnik, University of Ljubljana, Slovenia
Didier Verna, EPITA, France
Wuu Yang, National Chiao-Tung University, Taiwan
Youtao Zhang, University of Pittsburgh, USA

Track Chairs
Marjan Mernik, University of Maribor, Slovenia, marjan.mernik@uni-mb.si
Barrett Bryant, University of North Texas, USA, Barrett.Bryant@unt.edu

Monday, May 14 2012

Monday Troll: the syntax extension myth

Here's a little Monday Troll.

To my greatest disappointment, I discovered today that it is not possible to replace Lisp parenthesis by, say, ... curly braces. What a shame. Hell, it's not even possible to freely mix the two. Very naively, I had expected that:

(set-macro-character #\{ (get-macro-character #\())
(set-macro-character #\} (get-macro-character #\)))

would suffice, but no. All implementations that I have tested seem to agree on this, although the error messages may differ. For instance, trying to evaluate {and} gives you an "unmatched close parenthesis error" except for CMU-CL which chooses to ignore it, but then report an end-of-file error. The unmatched close parenthesis, of course, is the closing curly brace! So what is going on here?

When an opening curly brace is read, the original left paren macro function is called. In SBCL for instance, this is SB-IMPL::READ-LIST, which looks for a hardwired right paren on the stream. Yuck. It doesn't find one, but it finds my closing brace which triggers the "standalone" right paren behavior (spurious paren alert). In passing, it also surprised me that SB-IMPL::READ-LIST is not implemented in terms of READ-DELIMITED-LIST.

EDIT: as mentioned in several comments, we could use read-delimited-list to look for a closing curly brace, but even this won't work completely. The problem is with dotted lists (see Pascal's comment). SBCL hard-wires #\) in its dotted lists parsing procedures.

So it appears that dispatching macro characters are only shaky. What we miss is a true concept of syntactic categories (Common Lisp character syntax types are close, but not quite there yet). In fact, TeX, with its notion of catcodes (category codes), seems to be the only language that gets this right. Ideally, any character with associated status LIST TERMINATOR should do as good as a right paren (the problem is only with closing, not opening).

Instead of hard-wiring the right paren in the Lisp parser, a quick workaround would be to check whether the next character on the stream is a dispatching one, and in such a case, whether its macro function is the one originally associated with the right paren. If so, it should then simply stand as a list terminator. This is actually an interesting idea I think: could the built-in macro functions become equivalent to actual category codes, and could we completely remove hard-wired characters in Lisp parsers?

Anyway, this whole story is a true scandal because it ruined an otherwise cool live demo of mine. So much for syntax extensibility. I will immediately complain to the concerned authorities.

Looking for the concerned authorities to complain to... please wait.

Wednesday, March 21 2012

Star TeX, the Next Generation

I'm happy to announce that my contribution to TUG 2012, the next TeX Users Group International conference, has been accepted. Please find the title and abstract below.



Star TeX, the Next Generation

In 2010, I asked Donald Knuth why he chose to design and implement TeX as a macro-expansion system (as opposed to more traditional procedure calls). His answer was that:

  1. he wanted something relatively simple for his secretary who was not a computer scientist,
  2. the very limited computing resources at that time practically mandated the use of something much lighter than a true programming language.

The first part of the answer left me with a slight feeling of skepticism. It remains to be seen that TeX is simple to use, and when or where it is, its underlying implementation has hardly anything to do with it.

The second part of the answer, on the other hand, was both very convincing and arguably now obsolete as well. Time has passed and the situation today is very different from what it was 50 years ago. The available computing power has grown exponentially, and so has our overall skills in language design and implementation.

Several ideas on how to modernize TeX already exist. Some have been actually implemented. In this talk, I will present mine. Interestingly enough, it seems to me that modernizing TeX can start with grounding it in an old yet very modern programming language: Common Lisp. I will present the key features that make this language particularly well suited to the task, emphasizing on points such as extensibility, scriptability and multi-paradigm programming. The presentation will include reflections about the software engineering aspects (internals), as well as about the surface layer of TeX itself. Most notably, I will explore the possibilities of providing a more consistent syntax to the TeX API, while maintaining backward compatibility with the existing code base.

Monday, March 12 2012

Clon 1.0b21 is out

One year between b19 and b20. 4 days between b20 and b21...

This new version of Clon introduces support for a new compiler, Allegro Common Lisp, in both standard and modern form. Support for dumping is only rudimentary for ACL (although it's only a marginal feature of the library). The dump macro uses Allegro's dumplisp mechanism to dump a lisp image which is not directly executable (full application delivery is complicated and only available in the Enterprise edition). Apart from that, the rest should work fine. As in the case of CLISP, Allegro may benefit from the presence of CFFI in order to provide terminal autodetection. This is an optional dependency only.

Grab it at the usual place.

Thursday, March 8 2012

Clon 1.0b20 is out

I'm happy to announce a new release of Clon, the Command-Line Options Nuker for standalone Common Lisp executables. In addition to a lot of uninteresting code and infrastructure changes, this new release comes with several important improvements and new features.

At the end-user level

  • there is a new error handler available via the --clon-error-handler option, called "interactive". This error handler provides the same restarts as the one called "none" (which actually triggers the Lisp debugger), but in a less frightening way for end-users not knowing about Lisp at all. In particular, the error and restart messages are more readable and you don't see a Lisp stack anywhere. See the end-user manual and the user manual for more information.
  • there is a new option called --clon-lisp-information which, as its name suggests, provides information about the underlying Lisp (implementation type and version). This will in fact be more useful for developers than for end-users, but it's still and end-user level feature. See the end-user manual for not much more information.

At the user-level

  • Clon now provides a command-line polling API through the functions cmdline-options-p and cmdline-p. See the user manual for more information.
  • Support for using Clon interactively, that is, without dumping executables has been improved. This is mostly useful for debugging purposes. See the user manual for more information.
  • Clon now provides a compile-time / run-time unified configuration facility thanks to a variable named cl-user::com.dvlsoft.clon.configuration that is handled before the ASDF system is loaded. Thanks to this, Clon is now able to communicate its own indentation information to (X)Emacs directly (thanks to a process that I've previously described here), and also handles portability problems in a smoother way (see below).
  • One of the available configuration options is called :restricted mode. In this mode, Clon never attempts to communicate with ttys via ioctl calls, at the expense of terminal autodetection (size and highlighting). This is implemented by making a termio ASDF module conditionally loaded in the system definition. There are cases where Clon will switch to restricted mode automatically (e.g. when using CLISP compiled without FFI support). However, some other situations are more problematic, for instance when using SBCL under MinGW, in which case the SB-GROVEL module is available but doesn't work. In such situations, it is necessary to configure Clon explicitely for restricted mode before loading the system. See the user manual for more information.


That's it. Grab it at the usual place. Yesterday, I realized that it's been slightly more than a year since the b19 release. Gee, time flies like the wind...

Monday, February 13 2012

ILC 2012 (International Lisp Conference)

The next ILC has been announced. It's going to take place in my favorite city in the whole world. Here's the original call for papers with all the important deadlines.

+----------------------------------------------------------------------+
|                                                                      |
|                  INTERNATIONAL LISP CONFERENCE 2012                  |
|                                                                      |
|             http://www.international-lisp-conference.org             |
|                                                                      |
|       Campus Plaza Kyoto, Kyoto, Japan -  October 21-24, 2012        |
|                                                                      |
|            Sponsored by:  The Association of Lisp Users              |
|                                                                      |
+----------------------------------------------------------------------+

   General Information:

     The Association of Lisp Users is pleased to announce the 2012
     International Lisp Conference will be held in Kyoto, Japan at
     Campus Plaza Kyoto from October 21st to 24th, 2012.

     This year's program consists of tutorials at beginners' and
     advanced levels, prominent invited speakers from the Lisp
     communities, an excellent technical session, tours of
     Jidai-Matsuri: festival enjoyed by people of all ages,
     participating in its historical reenactment parade dressed in
     authentic costumes representing various periods, and characters
     in Japanese feudal history.

     General conference announcements are made on a very occasional
     basis to the low-volume mailing list
     ilc12-announce. http://www.alu.org/mailman/listinfo/ilc12-announce

   Technical Program:

     Original submissions in all areas related to the conference themes
     are invited for the following categories:

     Papers: Technical papers of up to 15 pages that describe original
     results.

     Demonstrations: Abstracts of up to 2 pages for demonstrations of
     tools, libraries and applications.

     Workshops: Abstracts of up to 2 pages for groups of people who
     intend to work on a focussed topic for half a day.

     Tutorials: Abstracts of up to 2 pages for indepth presentations
     about topics of special interest for 90 - 180 minutes.

     Panel discussions: Abstracts of up to 2 pages for discussions about
     current themes. Panel discussion proposals must mention panel
     member who are willing to partake in a discussion.

     Lightning talks: Abstracts of up to one page for talks to last
     for no more than 5 minutes.


   Important Dates:

     Please send contributions before the submission deadline, including
     abstracts of 4 pages for technical papers and abstracts of 2 pages
     for all other categories.

     Deadline for abstract submissions: July 15, 2012
     Notification of acceptance or rejection: July 31, 2012
     Deadline for final paper submissions: August 31, 2012

     Papers to be presented should be submitted electronically at
     easychair 
     (https://www.easychair.org/account/signin.cgi?conf=ilc2012)
     and need to use the ACM format
     (http://www.acm.org/sigs/publications/proceedings-templates)

   Scope:

    Lisp is one of the greatest ideas from computer science and a
    major influence for almost all programming languages and for all
    sufficiently complex software applications.

    The International Lisp Conference is a forum for the discussion of
    Lisp and, in particular, the design, implementation and
    application of any of the Lisp dialects.  We encourage everyone
    interested in Lisp to participate.

    We invite high quality submissions in all areas involving Lisp
    dialects and any other languages in the Lisp family, including,
    but not limited to, ACL2, AutoLisp, Clojure, Common Lisp,
    ECMAScript, Dylan, Emacs Lisp, ISLISP, Racket, Scheme, SKILL, etc.

    Topics may include any and all combinations of Lisp and:

      * Language design and implementation
      * Language integration, inter-operation and deployment
      * Applications (especially commercial)
      * Reflection, meta-object protocols, meta-programming
      * Domain-specific languages
      * Programming paradigms and environments
      * Parallel and distributed computing
      * Theorem proving
      * Scientific computing
      * Data mining
      * Semantic web


   Organizing Committee:

     General Chair: KURODA Hisao (Mathematical Systems Inc. / ALU)
     Members: Daniel Herring (ALU)
              Jon L White (ALU)
              Rusty Johnson (ALU)

     Program Chair: Hiroshi Okuno (Kyoto Univ.)
     Members: Keith Corbett (Clozure Associates)
              Alex Fukunaga (University of Tokyo)
              Antonio Leitao (INESC-ID)
              Joe Marshall (MIT)
              Scott Mckay (ITA software)
              Nancy Reed (University of Hawaii)
              Kent Pitman (nhplace.com)
              Duane Rettig (Franz Inc.)
              Didier Verna (EPITA)
              Takuo Watanabe (Tokyo Institute of Technology)
              Edi Weitz (weitz.de)
              Taiichi Yuasa (Kyoto University)

     Local chair: Tetsuya Ogata (Kyoto Univ.)
     Members: CHIBA Masaomi
              SANO Masatoshi

  Contacts:

    * General Questions: ilc12-organizing-committee at alu.org
    * Program Committee: ilc2012 at easychair.org

For more information, see http://www.international-lisp-conference.org

Tuesday, January 31 2012

JSPP: Morphing C++ into JavaScript

I'm happy to announce the publication of a new technical report entitled JSPP: Morphing C++ into JavaScript. The abstract is given below.

In a time where the differences between static and dynamic languages are starting to fade away, this report brings one more element to the "convergence" picture by showing that thanks to the novelties from its recent 0x standard, it is relatively easy to implement a JavaScript layer on top of C++. By that, we not only mean to implement the language features, but also to preserve as much of its original notation as possible. In doing so, we provide the programmer with a means to freely incorporate highly dynamic JavaScript-like code into a regular C++ program.

Tuesday, January 17 2012

Patcher 4.0 is released

I'm happy to announce the release of Patcher version 4.0. This is a major release introducing many new features and enhancements.

Patcher is a tool designed to automate and ease the maintenance of archive-based projects. It provides assistance in building, reporting and committing patches, as well as in handling the corresponding ChangeLog entries, for example by creating skeletons. Patcher is the official tool for XEmacs development.

NEW FEATURES

  • Support floating projects and temporary relocation allowing to use the same project descriptor for various directories.
  • Support for automatic detection of submodules via the :submodule-detection-function project option and the patcher-detect-submodules function. Currently supported RCS submodules are Mercurial and Git via the functions 'patcher-hg-detect-submodules.
  • Support ephemeral ChangeLogs thanks to a new :change-logs-status project option. Ephemeral ChangeLogs are not stored in ChangeLog files, but exist only temporarily for mail or log message insertion (See ChangeLogs Status in the documentation).
  • ChangeLog minor mode providing easy navigation through the mail/ChangeLog buffers cycle via C-c C-p n, C-c C-p p, C-c C-p N, C-c C-p P and C-c C-p m (See ChangeLogs Navigation in the documentation).
  • Support for switching to mail buffer and inserting ChangeLogs at once via C-c C-p l from ChangeLog buffers.
  • patcher-mail-insert-change-logs gets a prefix argument allowing to temporarily change the ChangeLogs appearance. It also supports inserting ChangeLogs even when the project is set not to.
  • Additional binding for patcher-logmsg-commit: C-c C-p c
  • Commit command buffer is now editable Commit is done via C-c C-p c or C-c C-c (patcher-cmtcmd-commit).
  • Fontification of commit command and log message buffers with comment syntax and initial informative help. See new Patcher faces.
  • Support for commit or log message canceling via C-c C-z.
  • Support for project abortion via C-c C-p k or C-c C-k in all relevant buffers, including ChangeLogs.
  • Support Subject: header modification in mail adaptation routines via a new project option :subject-rewrite-format.
  • Support project-wide dynamic subject modification via C-c C-p S in both mail and log message buffers.
  • Implement :kill-source-files-after-sending project option
  • Support for source file saving
  • Support for CVS diff's broken exit code policy via a new project option: :ignore-diff-status.

FIXES AND IMPROVEMENTS

  • Improved support for temporary subprojects making them behave like permanent ones (with a specific subdirectory and set of files).
  • Much better error handling including exit code checking for external processes.
  • Improved support for overlapping Patcher instances through buffer and file referencing for both ChangeLog and source files.
  • Documentation rewrite and sections organization cleanup
  • More checks for project consistency including missing or spurious ChangeLog entries, source diffs, undiffable and uncommittable projects etc.
  • Improved project rediffing including support for partially generated ChangeLog skeletons, and interactive prompting for skeleton un/re-generation.

BACKWARD INCOMPATIBLE CHANGES

  • Mercurial themes renamed from 'mercurial to 'hg in order to remain consistent with the other RCS theme names.
  • ChangeLogs insertion in mail buffers rebound to C-c C-p l
  • Compressed ChangeLogs insertion in logmsg buffers rebound to C-c C-p L
  • Removed directory-sep-char hacks until the need for it raises again. Probably better implemented via project options anyway.
  • Diff commands can no longer be changed from patcher-mail-adapt but instead, the prefix argument allows for temporary subproject specification.
  • patcher-*-subproject entry points removed since they are no longer needed (see above).
  • Removed :kill-source-file-after-diffing option
  • :kill-source-files-after-sending renamed to :kill-sources-after-sending
  • patcher-mail-check-change-logs-insertion is now a project option named :check-change-logs-insertion.
  • patcher-mail-check-commit-action is now a project option named :check-commit.
  • :change-logs-diff-command option now understands nil instead of 'diff
  • The 'packed ChangeLogs appearance has been renamed to 'pack

Tuesday, January 3 2012

ACCU 2012 session on language extensibility

I'm pleased to announce that I will hold a 90 minutes session on language extensibility at the next ACCU conference. A shortened abstract is given below (a longer one is available at the conference website).

Impact of Extensibility on Domain Specific Language Design and Implementation

Domain-specific languages (DSLs) are usually very different from the general purpose language (GPL) in which the embedding application is written. The need for designing a DSL as a completely new language often comes from the lack of extensibility of the chosen GPL. By imposing a rigid syntax, a set of predefined operators and data structures, the traditional GPL approach leaves no choice but to implement a DSL as a different language, with its own lexical and syntactic parser, semantic analyzer and possibly its own brand new interpreter or even compiler.

Some GPLs, however, are extensible or customizable enough to let one implement a DSL merely as either a subset or an extension of the original language. While the end-user does not see a difference with the traditional approach, the gain for the developer is substantial. Since the DSL is now just another entry point for the same original GPL, there is essentially only one application written in only one language to maintain. Moreover, no specific language infrastructure (parser, interpreter, compiler etc.) is required for the DSL anymore, since it is simply expressed in terms of the original GPL.

The purpose of this presentation is to illustrate the most important factors that make a language truly extensible, and to show how extensibility impacts the process of DSL design and implementation.

Tuesday, December 27 2011

XEmacs now has a "foreback" face property

The "foreback" face property at workHere's another new face property in XEmacs. This one is probably not going to be used ever, but still it fixes one particular problem. Until now, XEmacs used the background and foreground colors to display a face background bitmap (as opposed to a regular pixmap). This basically rendered the text unreadable.

The new face property is called "foreback" (I'm running short of sensible property names these days). It's the "foreground of the background" if you will. When a face has a background bitmap, it uses the regular background color for bitmap's background, but the foreback color for the bitmap's foreground. See the attached screenshot for a concrete example of the problem it fixes.

The bitmap I used for this example is X11's xsnow bitmap. Nice Christmas XEmacs screenshot, isn't it? :-)

In order to set a face's foreback color, either use the Custom interface, or the set-face-foreback function.

Thursday, December 22 2011

XEmacs now has a "flush" face property

The "flush" face property at workI have just implemented a new face property in XEmacs 21.5, called "flush". When some text is displayed in a face which has this property set to t (it's a Boolean property), then the face extends until the right border of the window instead of just the end of the actual line of text. The effect is only visible if the face has a non-default background color or pixmap and gives the text segment the appearance of a block instead of being ragged right. In fact (if that rings a bell to you), this is the equivalent of the block value for the HTML display property.

See the attached screenshot for an example. In that particular case, the buffer displays an article in Gnus and the concerned face is mm-uu-extract. You can see two versions of the same buffer, with and without the property set. There are a number of situations in which setting a face to flush is nicer visually. Probably the most obvious case is that of text selection. Below is a list of faces that I'm currently setting to flush. I'll be updating this list as needed. In order to set a face to flush, either use the Custom interface or the set-face-flush-p function directly.

zmacs-region
diff-nonexistent-face
gnus-summary-cancelled[-face]
mm-uu-extract
mmm-default-submode-face
mmm-code-submode-face

- page 4 of 9 -

French Flag English Flag
Copyright (C) 2008 -- 2018 Didier Verna didier@lrde.epita.fr