You can subscribe to this list here.
2001 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}
(3) 
_{Oct}
(6) 
_{Nov}
(4) 
_{Dec}
(12) 

2002 
_{Jan}
(12) 
_{Feb}
(8) 
_{Mar}
(4) 
_{Apr}
(12) 
_{May}
(13) 
_{Jun}
(2) 
_{Jul}

_{Aug}
(16) 
_{Sep}
(16) 
_{Oct}
(8) 
_{Nov}
(19) 
_{Dec}
(12) 
2003 
_{Jan}
(26) 
_{Feb}
(22) 
_{Mar}
(8) 
_{Apr}
(8) 
_{May}
(11) 
_{Jun}
(22) 
_{Jul}
(38) 
_{Aug}
(12) 
_{Sep}
(5) 
_{Oct}
(22) 
_{Nov}
(2) 
_{Dec}
(11) 
2004 
_{Jan}
(8) 
_{Feb}
(1) 
_{Mar}
(2) 
_{Apr}
(13) 
_{May}
(5) 
_{Jun}
(9) 
_{Jul}
(19) 
_{Aug}
(3) 
_{Sep}
(1) 
_{Oct}
(4) 
_{Nov}
(20) 
_{Dec}
(22) 
2005 
_{Jan}
(20) 
_{Feb}
(16) 
_{Mar}
(16) 
_{Apr}
(3) 
_{May}
(3) 
_{Jun}
(5) 
_{Jul}
(3) 
_{Aug}
(6) 
_{Sep}
(7) 
_{Oct}
(2) 
_{Nov}

_{Dec}
(8) 
2006 
_{Jan}
(2) 
_{Feb}
(6) 
_{Mar}
(2) 
_{Apr}

_{May}
(15) 
_{Jun}
(3) 
_{Jul}
(6) 
_{Aug}

_{Sep}
(10) 
_{Oct}
(3) 
_{Nov}
(1) 
_{Dec}
(13) 
2007 
_{Jan}
(5) 
_{Feb}
(4) 
_{Mar}
(3) 
_{Apr}
(7) 
_{May}
(4) 
_{Jun}
(2) 
_{Jul}
(1) 
_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

2008 
_{Jan}

_{Feb}
(1) 
_{Mar}

_{Apr}
(1) 
_{May}

_{Jun}
(15) 
_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

2009 
_{Jan}
(1) 
_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}
(2) 
_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}
(1) 
2011 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}
(7) 
_{Sep}

_{Oct}

_{Nov}

_{Dec}

2013 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}
(1) 
_{Jul}

_{Aug}

_{Sep}
(5) 
_{Oct}

_{Nov}

_{Dec}

2014 
_{Jan}

_{Feb}

_{Mar}
(7) 
_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}
(1) 
2015 
_{Jan}
(2) 
_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 






1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19
(2) 
20

21

22

23

24

25

26
(1) 
27

28

29

30

From: <oleg@po...>  20050426 23:06:22

Hello! I'd like to point out a fairly nontrivial example of writing a theoretical computer science paper in SXML. SXML helped not only in transcribing (handwritten) mathematical notation. The proofs themselves were conducted in Emacs/SXML, rather than on a piece of paper. The paper in question is a technical report How to remove a dynamic prompt: static and dynamic delimited continuation operators are equally expressible http://www.cs.indiana.edu/cgibin/techreports/TRNNN.cgi?trnum=TR611 It concerns with proving propositions about delimited continuations. Rigorous proofs are indispensable as the intuition often fails when it comes to delimited continuations. The ``master file'' of that paper can be found at http://pobox.com/~oleg/ftp/Scheme/impromptushifttr.scm The first part of the file is the SXML source for the report. The second part is the formatter, from SXML to LaTeX (from which PDF was eventually built). As common with theoretical papers, TR includes a fair amount of greek, various squiggles, superscripts, subscripts, and arrows of several kinds. It's instructive to compare pieces of SXML code with the corresponding places of the printed/viewed technical report. Here's one example of SXML vs. LaTeX, the formulation and the proof of Lemma 2: SXML source: (p "Lemma 2.") (peq #f ($ (red* (B (C (shift g (H (compose h' g f') (lambda (f) e))))) (shift g (H (lambda (x) (h' (g (B (C (f' x)))))) (lambda (f) e))))) ) (pn "Informally, the translation image of " ($ (control f e)) " can be lifted out of " ($ (B (C))) " with the latter context fragment added to the captured continuation. Indeed,") (peq #f (alignleft ($ (B (C (shift g (H (compose h' g f') (lambda (f) e)))))) (explain "Definition of " ($ (B))) ($ (equiv "" (h' (reset (HV (C (shift g (H (compose h' g f') (lambda (f) e))))))))) (explain "(S2), along with the fact " ($ (HV e)) " may be subsumed ") (explain "as a part of a nonresetcrossing context " ($ (C))) ($ (red "" (h' (reset (let ((g (lambda (x) (reset (HV (C x)))))) (H (compose h' g f') (lambda (f) e))))))) (explain ($ (H a b)) " is a value, apply (S1) and then (H')") ($ (red* "" (let ((g (lambda (x) (reset (HV (C x)))))) (shift g' (H (compose h' g' h' g f') (lambda (f) e)))))) ($ (equiv "" (shift g' (H (lambda (x) (h' (g' (h' (reset (HV (C (f' x)))))))) (lambda (f) e))))) ($ (equiv "" (shift g' (H (lambda (x) (h' (g' (B (C (f' x)))))) (lambda (f) e))))) )) Here's the generated LaTeX code: Lemma 2. \addvspace{\smallskipamount}\par\noindent{}\begin{tabular}{cr} \parbox{4.4in}{\centering{}$\mathcal{B}\!\left[\mathcal{C}\!\left[\mathbf{shift}\;g.\mathsf{H}\,(h'\,\cdot\,g\,\cdot\,f')(\lambda f.e)\right]\right]\,\vartriangleright^{*}\,\mathbf{shift}\;g.\mathsf{H}\,(\lambda x.h'(g(\mathcal{B}\!\left[\mathcal{C}\!\left[f'x\right]\right])))(\lambda f.e)$} & \\\end{tabular} \addvspace{\smallskipamount}\noindent{}Informally, the translation image of $\mathbf{control}\;f.e$ can be lifted out of $\mathcal{B}\!\left[\mathcal{C}\!\left[\right]\right]$ with the latter context fragment added to the captured continuation. Indeed, \addvspace{\smallskipamount}\par\noindent{}\begin{tabular}{cr} \parbox{4.4in}{\centering{}\parbox[t]{8in}{\vspace{\smallskipamount}\begin{tabbing} $\mathcal{B}\!\left[\mathcal{C}\!\left[\mathbf{shift}\;g.\mathsf{H}\,(h'\,\cdot\,g\,\cdot\,f')(\lambda f.e)\right]\right]$\\\{ Definition of $\mathcal{B}\!\left[\right]$ \}\\$\,\equiv\,h'(\mathbf{reset}\;\mathsf{HV}\,(\mathcal{C}\!\left[\mathbf{shift}\;g.\mathsf{H}\,(h'\,\cdot\,g\,\cdot\,f')(\lambda f.e)\right]))$\\\{ (S2), along with the fact $\mathsf{HV}\,e$ may be subsumed \}\\\{ as a part of a nonresetcrossing context $\mathcal{C}\!\left[\right]$ \}\\$\,\vartriangleright\,h'(\mathbf{reset}\;\mathrm{let}\,g\!=\!\lambda x.\mathbf{reset}\;\mathsf{HV}\,(\mathcal{C}\!\left[x\right])\,\mathrm{in}\,\mathsf{H}\,(h'\,\cdot\,g\,\cdot\,f')(\lambda f.e))$\\\{ $\mathsf{H}\,ab$ is a value, apply (S1) and then (H') \}\\$\,\vartriangleright^{*}\,\mathrm{let}\,g\!=\!\lambda x.\mathbf{reset}\;\mathsf{HV}\,(\mathcal{C}\!\left[x\right])\,\mathrm{in}\,\mathbf{shift}\;g'.\mathsf{H}\,(h'\,\cdot\,g'\,\cdot\,h'\,\cdot\,g\,\cdot\,f')(\lambda f.e)$\\$\,\equiv\,\mathbf{shift}\;g'.\mathsf{H}\,(\la mbda x.h'(g'(h'(\mathbf{reset}\;\mathsf{HV}\,(\mathcal{C}\!\left[f'x\right])))))(\lambda f.e)$\\$\,\equiv\,\mathbf{shift}\;g'.\mathsf{H}\,(\lambda x.h'(g'(\mathcal{B}\!\left[\mathcal{C}\!\left[f'x\right]\right])))(\lambda f.e)$\end{tabbing} \vspace{\medskipamount}}} & \\\end{tabular} The SXML>LaTeX formatter is quite distinct from SLaTeX. We are not concerned with the typesetting of the Scheme code. Rather, our aim is to use Scheme notation as an easytotype and easytomanipulate realization of the mathematical notation. The end result must be conventional mathematical notation, with (lambda (x) (f g)) typeset as $\lambda x. f g$, (compose f g h) as $f\,\cdot\,g\,\cdot\,h$, (let ((x 1)) body) as $\mathrm{let}\,x=1 \mathrm{in} body$, and the reduction of transformed A to transformed B, (red* *A *B), as $\overline{A} \vartriangleright^{*} \overline{B}$. The proof of Lemma 2 wasn't merely transcribed in SXML. The proof was _conducted_ in SXML. Indeed, many proofs in computer science are based on equivalence transformations: we start with the source expression, replace some part of it with another expression, etc. until we reach the target expression. In other words, we take the source expression, make a copy of it, change it, copy it again, change another part of it, etc. It is of great benefit that the SXML notation clearly shows the structure of expressions and that Emacs lets us highlight parenthesized subexpressions and to cut and paste it them. The nontrivial part of the SXML>LaTeX formatter deals with parentheses. For example, we would like to typeset an application of `f' to `g', written (f g), as $f g$ at the top level. We don't want extra parentheses. However, if that application appears within another application, e.g., (h (f g)), the result must look like $h (f g)$. The parentheses are required now. Still, (C (f g)) should be typeset as $\mathcal{C}\left[f g\right]$ with no parenthesis around `f g' because the context `C' has its own brackets. The typesetting rule then is that a complex expression within a complex context must be surrounded by parentheses. Otherwise, it should not. To decide if we need parentheses or not, we, therefore, need to know the properties of both the context and the expression. Contexts are classified into simple and complex: the toplevel context is simple, the context `(h \hole)' is complex. Expressions are too classified into simple and complex: `(f g)' is complex, `f' is simple. The classification is not actually straightforward: for example, `(overbar (sub f "1"))' is also a _simple_ expression. Decorations such as indices, superscripts, transform marks may make an expression look complex but they don't affect the classification. There is another subtle point: we typeset "reset0" as "\\mathbf{reset_0}", with the subscript within the decoration. OTH, we typeset `(M1 x)' as "\\mathcal{M}_1[x]": the subscript must be outside of the `mathcal' scope, or it gets mangled. The typesetting of a mathematical expression is done by the function `typesetexp tag exp', defined in the second half of the file impromptushifttr.scm. The function handles many formatting chores, like lowering a numerical index at the end of a name into the subscript. The leading character '*', the mark of the transform, is automatically translated into the overline. Thus, `(*M1 x)' is typeset into $\overline{\mathcal{M}_{1}}[x]$ with only a single rule for 'M'. I almost used shift/reset  but then eventually decided on a simple environment passing. As shown in Ariola, Herbelin, Sabry (ICFP04), dynamic scoping is inherent in delimited continuations. The function typesetexp relies thus on dynamic scoping implemented conventionally via environment passing. We use two dynamicallyscoped variables: &paren (a boolean flag telling if the context suggests we need enclosing parentheses) and &decor (the list of decorations). The rewriting rules are also a part of the environment, the constant part of it. Here's the procedure that formats an application `(a b ...)'. (define (handleapp envp app) (let ((env (extparen envp #t))) ; use paren (let ((hd (handle env (car app)))) (if (procedure? hd) (apply hd envp (cdr app)) (addparen envp (cons hd (map (lambda (x) (handle env x)) (cdr app)))))))) It receives the current environment (envp  the parent environment) and `app', which is a list `(a b ...)'. The procedure extends `envp' with the binding of `&paren' to #t  meaning that the context of an application is complex and so `a', `b', etc. expressions need to be enclosed into parentheses, if they are complex too. Then we format each of `a', `b', etc. within thus extended environment, and enclose the result in parentheses if the _parent_ context envp requires that. One complication stems from the fact that `a' may be a ``macro''. For example, `(let ((x 1)) body)', although might look like an application, is actually a macro. In the current environment, `let' is resolved to the procedure: (let . ,(lambda (_) (lambda (envp bindings body) (let ((env (extparen envp #f))) (addparen envp (list "\\mathrm{let}\\," (handle env (caar bindings)) "\\!=\\!" (handle env (cadar bindings)) "\\,\\mathrm{in}\\," (handle env body))))))) We pass the rest of the arguments to that procedure and let it do the formatting. The `let' macro specifically sets the &paren dynamic binding to #f: the body of `let' is formatted without enclosing parentheses. 
From: <oleg@po...>  20050419 19:01:22

Hello! > There is one version of prepostorder defined in > SSAX/lib/SXMLtreetrans.scm, and another version defined in > SSAX/examples/sxmltosxml.scm. I would like to use both versions in > the same environment The file `SSAX/lib/SXMLtreetrans.scm' is a part of the library, and so it can be included as it is. The file `SSAX/examples/sxmltosxml.scm' is a standalone example; one cannot just `import' it; one has to use the editor to move the relevant pieces of code from that. While we're doing that, we might as well rename the functions we are pasting. Speaking of prepostorder specifically, I would not have expected any conflicts: both versions are compatible. That is, the code that works with the version in `SSAX/lib' should work with the version in `SSAX/examples'  perhaps a bit slower. I'm not sure how much slower; the difference in performance might be imperceptible, depending on the application and the Scheme system used. Perhaps the function in `SSAX/examples' should be used all the time, and the other one deprecated. Cheers, Oleg 
From: <johnwrussell@co...>  20050419 14:43:04

There is one version of prepostorder defined in SSAX/lib/SXMLtreetrans.scm, and another version defined in SSAX/examples/sxmltosxml.scm. I would like to use both versions in the same environment, but they are both named prepostorder. What to do? 