Fexpr the Ultimate Lambda

[Dale Schumacher]

Fexpr the Ultimate Lambda (http://bit.ly/v6yTju) a treatise on
evaluation, in honor of John McCarthy.

John Shutt’s Kernel language, and its underlying Vau-calculus, is a
simplified reformulation of the foundations of the LISP/Scheme family
of languages. It is based on the notion that evaluation should be
explicit, patterned after Fexprs, rather than implicit, using Lambda.
The results is a powerful well-behaved platform for building
extensible languages. Not extensible in syntax, but in semantics. We
have implemented the key mechanisms of Vau-calculus using actors. The
actor-based evaluation strategy introduces inherent concurrency
prevasively throughout the evaluation process.

[Alan Kay]

Hi Dale

Check out "The Early History of Smalltalk" to see the same insight about Lisp and how it was used to think about and define and implement Smalltalk-72.

Cheers,

Alan

________________________________
Sent: Friday, November 25, 2011 10:05 AM
Subject: [fonc] Fexpr the Ultimate Lambda
Fexpr the Ultimate Lambda (http://bit.ly/v6yTju) a treatise on
evaluation, in honor of John McCarthy.
John Shutt’s Kernel language, and its underlying Vau-calculus, is a
simplified reformulation of the foundations of the LISP/Scheme family
of languages. It is based on the notion that evaluation should be
explicit, patterned after Fexprs, rather than implicit, using Lambda.
The results is a powerful well-behaved platform for building
extensible languages. Not extensible in syntax, but in semantics. We
have implemented the key mechanisms of Vau-calculus using actors. The
actor-based evaluation strategy introduces inherent concurrency
prevasively throughout the evaluation process.
_______________________________________________
fonc mailing list
http://vpri.org/mailman/listinfo/fonc

[Dale Schumacher]

Yes, absolutely! I've read that paper numerous times. Unfortunately,
I wasn't able to cite all of the branches of the LISP family tree.

I _did_ cite Piumarta's work on Maru. His extensible base is much
smaller Shutt's, but Kernel provided a better illustration of
actor-based evaluation techniques.

Post by Alan Kay
Hi Dale
Check out "The Early History of Smalltalk" to see the same insight about
Lisp and how it was used to think about and define and implement
Smalltalk-72.
Cheers,
Alan
________________________________
Sent: Friday, November 25, 2011 10:05 AM
Subject: [fonc] Fexpr the Ultimate Lambda
Fexpr the Ultimate Lambda (http://bit.ly/v6yTju) a treatise on
evaluation, in honor of John McCarthy.
John Shutt’s Kernel language, and its underlying Vau-calculus, is a
simplified reformulation of the foundations of the LISP/Scheme family
of languages. It is based on the notion that evaluation should be
explicit, patterned after Fexprs, rather than implicit, using Lambda.
The results is a powerful well-behaved platform for building
extensible languages. Not extensible in syntax, but in semantics. We
have implemented the key mechanisms of Vau-calculus using actors. The
actor-based evaluation strategy introduces inherent concurrency
prevasively throughout the evaluation process.
_______________________________________________
fonc mailing list
http://vpri.org/mailman/listinfo/fonc
_______________________________________________
fonc mailing list
http://vpri.org/mailman/listinfo/fonc

[Dale Schumacher]

Actually, I hope to cite the Smalltalk work when I write about
extensible syntax, rather than just extensible semantics.

On Fri, Nov 25, 2011 at 1:53 PM, Dale Schumacher

Yes, absolutely!  I've read that paper numerous times.  Unfortunately,
I wasn't able to cite all of the branches of the LISP family tree.
I _did_ cite Piumarta's work on Maru.  His extensible base is much
smaller Shutt's, but Kernel provided a better illustration of
actor-based evaluation techniques.

Post by Alan Kay
Hi Dale
Check out "The Early History of Smalltalk" to see the same insight about
Lisp and how it was used to think about and define and implement
Smalltalk-72.
Cheers,
Alan
________________________________
Sent: Friday, November 25, 2011 10:05 AM
Subject: [fonc] Fexpr the Ultimate Lambda
Fexpr the Ultimate Lambda (http://bit.ly/v6yTju) a treatise on
evaluation, in honor of John McCarthy.
John Shutt’s Kernel language, and its underlying Vau-calculus, is a
simplified reformulation of the foundations of the LISP/Scheme family
of languages. It is based on the notion that evaluation should be
explicit, patterned after Fexprs, rather than implicit, using Lambda.
The results is a powerful well-behaved platform for building
extensible languages. Not extensible in syntax, but in semantics. We
have implemented the key mechanisms of Vau-calculus using actors. The
actor-based evaluation strategy introduces inherent concurrency
prevasively throughout the evaluation process.
_______________________________________________
fonc mailing list
http://vpri.org/mailman/listinfo/fonc
_______________________________________________
fonc mailing list
http://vpri.org/mailman/listinfo/fonc

[Alan Kay]

Hi Carl

I've always wished that we had gotten around to doing Smalltalk-71 -- which in many ways was a more interesting approach because it was heavily influenced by Planner -- kind of a "Planner Logo" with objects -- it was more aimed at the child users we were thinking about. ST-72 did the job at a more primitive level.

P.S. The characterizations of ST-71 and ST-72 in your paper are not quite accurate  -- but this doesn't matter -- but it is certainly true that we did not put concurrency in at the lowest level, nor did we have a truly formal model (I wrote the first interpreter scheme using a McCarthy-like approach -- it was a short one-pager -- but I wrote it as a looped sequential program rather than metacircularly because I wanted to show how it could be implemented).

Cheers,

Alan

________________________________
Sent: Friday, November 25, 2011 12:11 PM
Subject: RE: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
I have started a discussion topic on Lambda the Ultimate so that others can participate here:  Actors all the way down
 
How SmallTalk-72 influenced the development of Actors is discussed in Actor Model of Computation: Scalable Robust Information Systems.
 
Cheers,
Carl
 
PS. Kristen Nygaard and I had some fascinating late night discussions over such matters in Aarhus lubricated with Linie aquavit :-)   I miss him dearly :-(
 
-----Original Message-----
Sent: Friday, November 25, 2011 11:54
To: Alan Kay; Fundamentals of New Computing
Cc: CAG; Programming Language Design; The Friday Morning Applied Complexity Coffee Group
Subject: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
 
Yes, absolutely!  I've read that paper numerous times.  Unfortunately, I wasn't able to cite all of the branches of the LISP family tree.
 
I _did_ cite Piumarta's work on Maru.  His extensible base is much smaller Shutt's, but Kernel provided a better illustration of actor-based evaluation techniques.
 

Post by Alan Kay
Hi Dale
Check out "The Early History of Smalltalk" to see the same insight
about Lisp and how it was used to think about and define and implement
Smalltalk-72.
Cheers,
Alan
 
________________________________
Sent: Friday, November 25, 2011 10:05 AM
Subject: [fonc] Fexpr the Ultimate Lambda
 
Fexpr the Ultimate Lambda (http://bit.ly/v6yTju) a treatise on
evaluation, in honor of John McCarthy.
 
John Shutt’s Kernel language, and its underlying Vau-calculus, is a
simplified reformulation of the foundations of the LISP/Scheme family
of languages. It is based on the notion that evaluation should be
explicit, patterned after Fexprs, rather than implicit, using Lambda.
The results is a powerful well-behaved platform for building
extensible languages. Not extensible in syntax, but in semantics. We
have implemented the key mechanisms of Vau-calculus using actors. The
actor-based evaluation strategy introduces inherent concurrency
prevasively throughout the evaluation process.
 
_______________________________________________
fonc mailing list
http://vpri.org/mailman/listinfo/fonc
 
 
 
_______________________________________________
fonc mailing list
http://vpri.org/mailman/listinfo/fonc
 
 

 
--
You received this message because you are subscribed to the Google Groups "Computational Actor's Guild" group.
For more options, visit this group at http://groups.google.com/group/computational-actors-guild?hl=en.
 

[Alan Kay]

Hi Carl

Yes, I have always felt that you got nowhere near the coverage and recognition you deserved for PLANNER (the whole enchilada) -- to me it was a real landmark of a set of very powerful insights and perspectives. Definitely one of the very top gems of the late 60s!


I recall there was lots of good wine at that Pajaro Dunes meeting! (And Jeff Rulifson helped me pull off that Beef Wellington with the three "must have" sauces). That was also a great group. Cordell Green was there, Richard Waldinger, Rulifson, (Bob Yates?), Bob Balzer, etc. Can you remember any of the others? That one must have been in 1970.

And it was indeed the "second -- and sequential -- evaluator" (from the Lisp 1.5 manual) that I had in mind when I did the ST-72 eval. Another influence on that scheme was the tiny Meta II parser-compiler that Val Shorre did at UCLA in 1963 (for an 8K byte 1401!). I loved that little system. This led to the ST-72 "eval" really being a kind of cascaded "apply" ...


And there's no question that once
you aim at "real objects" a distributed "eval" makes great sense.
Cheers,

Alan

________________________________
Sent: Saturday, November 26, 2011 9:24 AM
Subject: RE: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
Hi Alan,
 
Yes, Smalltalk-71 had lots of potential!  Unfortunately, the way it developed was that Kowalski picked up a subset of micro-Planner (backward chaining only along with backtracking only control structure) and PROLOG was made into something of an ideology.  I have published a history in ArXiv titled “Middle History of Logic Programming: Resolution, Planner, Edinburgh LCF, Prolog, and the Japanese Fifth Generation Project” at
http://arxiv.org/abs/0904.3036
 
I have fond memories of the Beef Wellington that you prepared at one of the Pajaro Dunes meetings of the “DARPA Junior Over-achievers” society!  Before McCarthy developed his meta-circular definition, the developers of Lisp 1 took a similar approach to yours by developing a looped sequential program that mimicked their assembly language implementation.
 
<<<”lambda” “(“ id|->Identifier “)” body|->Expression>>>   ~~   eval(env) --> (argument) --> body.eval(Environment(id,argument, env))
 
      where
 
           Environment(iden, value, enviro)   ~~   lookup(iden2) --> iden2=iden ?~ true --> value ?? false --> enviro.lookup(iden2) ~?
 
Cheers,
Carl
 
Sent: Friday, November 25, 2011 15:37
To: Carl Hewitt; Dale Schumacher
Subject: Re: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
 
Hi Carl
 
I've always wished that we had gotten around to doing Smalltalk-71 -- which in many ways was a more interesting approach because it was heavily influenced by Planner -- kind of a "Planner Logo" with objects -- it was more aimed at the child users we were thinking about. ST-72 did the job at a more primitive level.
 
P.S. The characterizations of ST-71 and ST-72 in your paper are not quite accurate  -- but this doesn't matter -- but it is certainly true that we did not put concurrency in at the lowest level, nor did we have a truly formal model (I wrote the first interpreter scheme using a McCarthy-like approach -- it was a short one-pager -- but I wrote it as a looped sequential program rather than metacircularly because I wanted to show how it could be implemented).
 
Cheers,
 
Alan
 
 

________________________________
Sent: Friday, November 25, 2011 12:11 PM
Subject: RE: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
I have started a discussion topic on Lambda the Ultimate so that others can participate here:  Actors all the way down
 
How SmallTalk-72 influenced the development of Actors is discussed in Actor Model of Computation: Scalable Robust Information Systems.
 
Cheers,
Carl
 
PS. Kristen Nygaard and I had some fascinating late night discussions over such matters in Aarhus lubricated with Linie aquavit :-)   I miss him dearly :-(
 
-----Original Message-----
Sent: Friday, November 25, 2011 11:54
To: Alan Kay; Fundamentals of New Computing
Cc: CAG; Programming Language Design; The Friday Morning Applied Complexity Coffee Group
Subject: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
 
Yes, absolutely!  I've read that paper numerous times.  Unfortunately, I wasn't able to cite all of the branches of the LISP family tree.
 
I _did_ cite Piumarta's work on Maru.  His extensible base is much smaller Shutt's, but Kernel provided a better illustration of actor-based evaluation techniques.
 

Post by Alan Kay
Hi Dale
Check out "The Early History of Smalltalk" to see the same insight
about Lisp and how it was used to think about and define and implement
Smalltalk-72.
Cheers,
Alan
 
________________________________
Sent: Friday, November 25, 2011 10:05 AM
Subject: [fonc] Fexpr the Ultimate Lambda
 
Fexpr the Ultimate Lambda (http://bit.ly/v6yTju) a treatise on
evaluation, in honor of John McCarthy.
 
John Shutt’s Kernel language, and its underlying Vau-calculus, is a
simplified reformulation of the foundations of the LISP/Scheme family
of languages. It is based on the notion that evaluation should be
explicit, patterned after Fexprs, rather than implicit, using Lambda.
The results is a powerful well-behaved platform for building
extensible languages. Not extensible in syntax, but in semantics. We
have implemented the key mechanisms of Vau-calculus using actors. The
actor-based evaluation strategy introduces inherent concurrency
prevasively throughout the evaluation process.
 
_______________________________________________
fonc mailing list
http://vpri.org/mailman/listinfo/fonc
 
 
 
_______________________________________________
fonc mailing list
http://vpri.org/mailman/listinfo/fonc
 
 

 
--
You received this message because you are subscribed to the Google Groups "Computational Actor's Guild" group.
For more options, visit this group at http://groups.google.com/group/computational-actors-guild?hl=en.
 
 

[Alan Kay]

Hi Carl

No question about Simula -- I was disgusted that ACM waited until both of them were almost dead before giving them an award they should have gotten years before. That was terrible, and ACM came close to making it egregious. But to me ACM also waited much too long for Ivan Sutherland and Doug Engelbart, etc.


I agree about resurrecting PLANNER. This was one of the things that occurred to me when LINDA came out -- that you could really do a "semantic broker" in a publish-subscribe communications system with higher level PLANNER-type matching. Each object could have two "billboards" one advertising what it could do, and the other expressing what it needed. This would be a very interesting loose coupling system (where in a sense, the objects are only receiving -- instead of "sending" they are "advertising").

Cheers,

Alan

________________________________
Sent: Saturday, November 26, 2011 10:54 AM
Subject: RE: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
Hi Alan,
 
Thanks for your kind words!
 
Also, it is sad that Simula didn’t received that credit that it deserved for a very long time :-(  Kristen and I discussed this issue at length.  At least, Ole-Johan and Kristen got the Turing before they died :-)
 
I recall that Stu Card, Jan Derksen, and Charles Forgy also showed up at Pajaro.
 
Cheers,
Carl
 
PS. The time is ripe for the resurrection of the Planner ideas!  Many-core architecture provides both the technology and the requirement.  We have few good paradigms for programming tens of thousands of cores in a general-purpose way :-(  The SIMD graphics architectures have a limited future, a la “Sinking Machines.”
 
Sent: Saturday, November 26, 2011 09:59
To: Carl Hewitt
Subject: Re: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
 
Hi Carl
 
Yes, I have always felt that you got nowhere near the coverage and recognition you deserved for PLANNER (the whole enchilada) -- to me it was a real landmark of a set of very powerful insights and perspectives. Definitely one of the very top gems of the late 60s!
 
I recall there was lots of good wine at that Pajaro Dunes meeting! (And Jeff Rulifson helped me pull off that Beef Wellington with the three "must have" sauces). That was also a great group. Cordell Green was there, Richard Waldinger, Rulifson, (Bob Yates?), Bob Balzer, etc. Can you remember any of the others? That one must have been in 1970.
 
And it was indeed the "second -- and sequential -- evaluator" (from the Lisp 1.5 manual) that I had in mind when I did the ST-72 eval. Another influence on that scheme was the tiny Meta II parser-compiler that Val Shorre did at UCLA in 1963 (for an 8K byte 1401!). I loved that little system. This led to the ST-72 "eval" really being a kind of cascaded "apply" ...
And there's no question that once you aim at "real objects" a distributed "eval" makes great sense.
 
Cheers,
 
Alan
 
 

________________________________
Sent: Saturday, November 26, 2011 9:24 AM
Subject: RE: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
Hi Alan,
 
Yes, Smalltalk-71 had lots of potential!  Unfortunately, the way it developed was that Kowalski picked up a subset of micro-Planner (backward chaining only along with backtracking only control structure) and PROLOG was made into something of an ideology.  I have published a history in ArXiv titled “Middle History of Logic Programming: Resolution, Planner, Edinburgh LCF, Prolog, and the Japanese Fifth Generation Project” at
http://arxiv.org/abs/0904.3036
 
I have fond memories of the Beef Wellington that you prepared at one of the Pajaro Dunes meetings of the “DARPA Junior Over-achievers” society!  Before McCarthy developed his meta-circular definition, the developers of Lisp 1 took a similar approach to yours by developing a looped sequential program that mimicked their assembly language implementation.
 
<<<”lambda” “(“ id|->Identifier “)” body|->Expression>>>   ~~   eval(env) --> (argument) --> body.eval(Environment(id,argument, env))
 
      where
 
           Environment(iden, value, enviro)   ~~   lookup(iden2) --> iden2=iden ?~ true --> value ?? false --> enviro.lookup(iden2) ~?
 
Cheers,
Carl
 
Sent: Friday, November 25, 2011 15:37
To: Carl Hewitt; Dale Schumacher
Subject: Re: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
 
Hi Carl
 
I've always wished that we had gotten around to doing Smalltalk-71 -- which in many ways was a more interesting approach because it was heavily influenced by Planner -- kind of a "Planner Logo" with objects -- it was more aimed at the child users we were thinking about. ST-72 did the job at a more primitive level.
 
P.S. The characterizations of ST-71 and ST-72 in your paper are not quite accurate  -- but this doesn't matter -- but it is certainly true that we did not put concurrency in at the lowest level, nor did we have a truly formal model (I wrote the first interpreter scheme using a McCarthy-like approach -- it was a short one-pager -- but I wrote it as a looped sequential program rather than metacircularly because I wanted to show how it could be implemented).
 
Cheers,
 
Alan
 
 

________________________________
Sent: Friday, November 25, 2011 12:11 PM
Subject: RE: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
I have started a discussion topic on Lambda the Ultimate so that others can participate here:  Actors all the way down
 
How SmallTalk-72 influenced the development of Actors is discussed in Actor Model of Computation: Scalable Robust Information Systems.
 
Cheers,
Carl
 
PS. Kristen Nygaard and I had some fascinating late night discussions over such matters in Aarhus lubricated with Linie aquavit :-)   I miss him dearly :-(
 
-----Original Message-----
Sent: Friday, November 25, 2011 11:54
To: Alan Kay; Fundamentals of New Computing
Cc: CAG; Programming Language Design; The Friday Morning Applied Complexity Coffee Group
Subject: [CAG] Re: [fonc] Fexpr the Ultimate Lambda
 
Yes, absolutely!  I've read that paper numerous times.  Unfortunately, I wasn't able to cite all of the branches of the LISP family tree.
 
I _did_ cite Piumarta's work on Maru.  His extensible base is much smaller Shutt's, but Kernel provided a better illustration of actor-based evaluation techniques.
 

Post by Alan Kay
Hi Dale
Check out "The Early History of Smalltalk" to see the same insight
about Lisp and how it was used to think about and define and implement
Smalltalk-72.
Cheers,
Alan
 
________________________________
Sent: Friday, November 25, 2011 10:05 AM
Subject: [fonc] Fexpr the Ultimate Lambda
 
Fexpr the Ultimate Lambda (http://bit.ly/v6yTju) a treatise on
evaluation, in honor of John McCarthy.
 
John Shutt’s Kernel language, and its underlying Vau-calculus, is a
simplified reformulation of the foundations of the LISP/Scheme family
of languages. It is based on the notion that evaluation should be
explicit, patterned after Fexprs, rather than implicit, using Lambda.
The results is a powerful well-behaved platform for building
extensible languages. Not extensible in syntax, but in semantics. We
have implemented the key mechanisms of Vau-calculus using actors. The
actor-based evaluation strategy introduces inherent concurrency
prevasively throughout the evaluation process.
 
_______________________________________________
fonc mailing list
http://vpri.org/mailman/listinfo/fonc
 
 
 
_______________________________________________
fonc mailing list
http://vpri.org/mailman/listinfo/fonc
 
 

 
--
You received this message because you are subscribed to the Google Groups "Computational Actor's Guild" group.
For more options, visit this group at http://groups.google.com/group/computational-actors-guild?hl=en.
 
 

 

[Andre van Delft]

This discussion mentions concurrency, the Meta II parser-compiler, Planner, and LINDA, which apply such concepts as non-determinism, parallelism and communication. These concepts are well described by the Algebra of Communicating Processes (ACP, also known as Process Algebra). This theory was initially developed in 1982 by Jan Bergstra and Jan Willem Klop. I find it very elegant, and it deserves much more attention than it currently gets. ACP treats input events conveniently on the same level as internal actions and output actions; something that only very few programming languages match.

There are two links between ACP and lambda calculus:

Stephen Cole Kleene did in the 1930s important work on lambda calculus; in 1956 he wrote the first paper on finite automata and regular expressions.
http://www.dlsi.ua.es/~mlf/nnafmc/papers/kleene56representation.pdf
http://www.cs.nmsu.edu/historical-projects/Projects/kleene.9.16.10.pdf
I think the paper Brief History of Process Algebra should have mentioned Kleene's work.
http://www.informatik.hs-mannheim.de/~schramm/CSP/files/historyProcessAlgebra.pdf

In 1989 Henk Goeman wrote "Towards a Theory of (Self) Applicative Communicating Processes: a Short Note". This vastly under-quoted paper unifies lambda calculus with a mixture of ACP and its close relative CCS.
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.55.8907 (free download)
Shortly thereafter CCS creator Robin Milner et al. presented the pi-calculus, which does something similar.
http://en.wikipedia.org/wiki/%CE%A0-calculus

I am myself working on an Subscript, a language extension to Scala with ACP. I claim (blurp) that this eases programming GUI controllers, parsers and simulations. The current implementation is as a DSL, with about 1700 lines of code; process communication is not supported yet. An executer gets parse tree information from "scripts", and uses that to maintain a call graph.
I hope to raise interest here, so that some of you will join the further development. Code, examples and documentation are at http://code.google.com/p/subscript/

[Andre van Delft]

[My first post on the FONC mailing list had a wrong layout. Therefore I retry]

This discussion mentions concurrency, the Meta II parser-compiler, Planner,
and LINDA, which apply such concepts as non-determinism, parallelism and
communication. These concepts are well described by the Algebra of
Communicating Processes (ACP, also known as Process Algebra).
This theory was initially developed in 1982 by Jan Bergstra and Jan Willem
Klop. I find it very elegant, and it deserves much more attention than it
currently gets. ACP treats input events conveniently on the same level as
internal actions and output actions; something that only very few
programming languages match.

There are two links between ACP and lambda calculus:

Stephen Cole Kleene did in the 1930s important work on lambda calculus;
in 1956 he wrote the first paper on finite automata and regular expressions.
http://www.dlsi.ua.es/~mlf/nnafmc/papers/kleene56representation.pdf
http://www.cs.nmsu.edu/historical-projects/Projects/kleene.9.16.10.pdf
I think the paper Brief History of Process Algebra should have mentioned
Kleene's work.
http://www.informatik.hs-mannheim.de/~schramm/CSP/files/historyProcessAlgebra.pdf

In 1989 Henk Goeman wrote "Towards a Theory of (Self) Applicative
Communicating Processes: a Short Note". This vastly under-quoted paper
unifies lambda calculus with a mixture of ACP and its close relative CCS.
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.55.8907 (free download)
Shortly thereafter CCS creator Robin Milner et al. presented the pi-calculus,
which does something similar.
http://en.wikipedia.org/wiki/%CE%A0-calculus

I am myself working on an Subscript, a language extension to Scala with ACP.
I claim (blurp) that this eases programming GUI controllers, parsers and
simulations. The current implementation is as a DSL, with about 1700 lines
of code; process communication is not supported yet. An executer gets parse
tree information from "scripts", and uses that to maintain a call graph.
I hope to raise interest here, so that some of you will join the further
development. Code, examples and documentation are at
http://code.google.com/p/subscript/