Luca Cardelli • Scientific Biography • May 2012Research CareerThere are many intersecting and overlapping threads in my research over the years: denotational and operational semantics, concurrency, type theory, logic, compilers, user interfaces, systems biology, and molecular programming. However, these all center around aspects of formal languages: programming languages for computing, modeling languages for science, and engineering languages for nanotechnology. There are three main distinct areas of activity: from 1982 to 1996 in programming languages and type theory, from 1993 to 2005 in distributed systems and concurrency theory, and from 2001 on in computational biology and nanotechnology. Programming Languages and Type Theory (19821996)As an undergraduate in Pisa, I was exposed to various programming systems, and to the semantics, pragmatics, type theory, and design of programming languages. These were to be strong influences on my later work, both separately and jointly. My favorite programming language at the time was Simula 67, and I spent some effort trying to describe, unsuccessfully, the semantics of Simula classes: this issue would come back again later as a central theme. During my Ph.D. years in Edinburgh, I implemented the first compiler for the ML programming language (which was originally a part of Milner's LCF proof assistant). ML was the first of a popular family of languages that now includes F# from Microsoft. This was the first system to be widely used in teaching ML as a programming language. The system included a then novel abstract machine for lexicallyscoped functional languages [ 129 ]. In Edinburgh I also studied early process calculi (Milner's CCS and SCCS), and proposed some new ones [ 52 ], but this activity would come to fruition only much later. My thesis advisor was Gordon Plotkin, from whom I learned advanced concepts in denotational and operational semantics. After graduation, I was attracted to AT&T Bell Laboratories by Dave MacQueen, to keep working on languages and semantics. As a result, however, I found myself also working in the original Unix operating system group, where I wrote several thousand lines of userinterface C code and where, because of the unpredictable behavior of C programs, I gained a much greater appreciation for the strongly typed languages I had previously been using: Simula and ML. Within the Unix group, I cooperated with Rob Pike to design a language for more easily programming concurrent user interfaces, which was based on ideas from process calculi [ 127 ]. At Bell Labs, Dave MacQueen was then working with Ravi Sethi and Gordon Plotkin on a semantic model for polymorphism and recursive types. I noticed that, somewhat accidentally, this was a very good model for subtyping, particularly for describing the subtyping relationships between Simulastyle record types (i.e. objects). Further, the model supported generalizations of subtyping to variant types (i.e. discriminated unions) and to function types. Out of this realization were coined the now widespread terms of "subsumption" (the notion of a uniform subtyping property that applies to all different kinds of types), "contravariance" (the basis for the correct subtyping rule for function types  not unknown to category theorists, but the subject of great confusion in objectoriented programming), and "structural subtyping" (the notion that only the structure of types, and not their names, determines their subtyping properties  unlike Simula). The early paper on this work [ 55 ] contains the first formal type systems for subtyping, along with a proof of typing soundness. Subtyping in computer science is subtly different from ordinary set inclusion (although it can be modeled as such, if done appropriately). For example, integers are usually considered to be a subset of the reals, but this is not true on computers, which use different representations for integers and reals. Conversely, it is common in computer science to consider a record with 3 fields also as a valid record with 2 fields, while in math a 3tuple is not a 2tuple. The implications of this notion have generated a whole software industry dedicated to ‘objectoriented’ programming, which was inspired largely at first from pragmatics rather than mathematics. Generalizing subtyping from record types to other type structures found in programming languages became a theme of mine in the following years, and only at the end, with the book coauthored with Martin Abadi (discussed later), I came back full circle to the object types of Simula. The generalization of subtyping to variant types turned out to be important in database areas, where a lot of attention must be paid to missing or varying information. The proper way to capture this in schemas (i.e. types) was the subject of debate at the time. Collaborating with former teachers and colleagues from Pisa, this resulted in the design of the Galileo language [ 54 ]: an MLlike language, with subtyping, for socalled "conceptual modeling" in database areas. The generalization of subtyping to function types was at that time not a feature of any language, although there was a lot of discussion about the proper typing rules for "methods" in objectoriented languages. To investigate this issue, I designed and implemented a small functional language called Amber [ R ], which was the first to incorporate structural subtyping as an orthogonal feature in a type system. Not much of interest can be expressed without recursive types, and this led to implementing a subtyping algorithm for recursive types in Amber. A proper understanding of this topic would wait until later. The generalization of subtyping to polymorphic types resulted in the notion of "bounded quantification". [Quantification over types is used to model polymorphic function, i.e., functions that can operate uniformly on a variety of types.] A paper written with Peter Wegner on the topic [ 55 ] is still my mostcited paper: it details the notion of bounded quantification, its use in programming, and an early collection of type rules that is still popular because it leads to decidable typecheckers. In 1985 I moved to Palo Alto, California, to join a newly established research lab, the Digital Systems Research Center (SRC), founded by former members of Xerox PARC. The first few years at SRC saw a continuation and strengthening of my theoretical work in type theory [ 45 ], now inspired by early work by the logicians Per MartinLoef and JeanYves Girard. This was interspersed with systems research in user interfaces [ 123 ], and a return to the daily use of objectoriented languages. One topic that took considerable effort was understanding the interaction between subtyping and recursive types. Recursive types can describe inductively defined types such as list and trees, but can also describe types needed for modeling the objects and classes of objectoriented languages. The latter requires the use of "negative" (or coinductive) recursion, that is, recursion interacting with function types, with bounded quantified types, and with type abstraction (the dual of type quantification). A paper with Roberto Amadio [ 47 ] provided a first and lasting investigation on subtyping for recursive types, connecting type systems, semantics, and typechecking algorithms. This was an indispensable foundation for much work to follow. From 1985 to 1993 a number of projects were dedicated to understanding the interaction of subtyping with polymorphism, which is still the most difficult topic in the area. It was becoming clear, from a number of sources, that even modeling the "simple" notion of Simula classes required some very powerful type theory. One of the projects was the investigation of "row polymorphism", with John Mitchell [ 51 ], which was a possible alternative to subtyping. Another was an implementation of a programming language, Quest [ 48 ], which integrated subtyping and polymorphism in "the most orthogonal" possible way. Much progress in accurately modeling classes was made by colleagues, including more general forms of bounded quantification. A book written with Martin Abadi [ A ] and published in 1996 collects, integrates, and extends much of my previous work in the area, as well as compatible work from other sources. This book is a focused monograph, rather than a survey. As a first new contribution, the book begins by developing an "object calculus" as a foundation for objectoriented languages, in much the same way that Church's lambdacalculus is a foundation for procedural languages. (Building directly on object calculi bypasses some significant technical problems with using lambda calculi as a foundation.) A progression of increasingly sophisticated type systems, all with subtyping builtin, leads to precise type systems for a spectrum of objectoriented languages, from simple Simulalike languages, to the more sophisticated ones that appeared later. One of the final technical contributions is to show that by extending subtyping to the level of type operators ("higherorder subtyping"), one can be as expressive as the more interesting variations on the original idea of bounded quantification. The book has been used in many advanced courses, with the object calculus and related type systems providing a new foundation for much recent work. The book has never been revised but is still (in 2012) in print. The initial two papers on subtyping [ 52 , 55 ] and the following work stimulated many other investigators from very early on. Through the 80's and 90's a combination of features pioneered by myself and coauthors, in various forms and permutations, formed the core of the study of object oriented languages, with dedicated sessions appearing regularly in mainstream systems conferences, as well as in programming language and theory conferences. Bounded quantification has now been integrated in mainstream commercial languages (Sun's Java, and Microsoft's C#). A direct descendent of ML, the F# language, is a Microsoft product developed by the group I manage in Cambridge. Work on the type theory of objectoriented languages (and languages in general) was originally meant to prevent accidental programming errors, but it has recently become unexpectedly more important, because sound type systems are now a requirement for computer security. Distributed Systems and Concurrency Theory (19932005)At Digital's Systems Research Center (SRC), in 1985, I found a Xeroxstyle programming environment based on multiprocessor workstations and local area networks. This meant that programming languages had to deal with concurrency, both on single processors, on multiprocessors, and on the network. There I participated in the design of the Modula3 language [ P ], which was used as the main programming language at SRC through the 90's. Modula3 became part of a new generation of safe objectoriented languages for systems programming. It was the basis of many research projects outside of SRC, and it ended up inspiring the design of Sun's Java in many direct and indirect ways. The Modula3 environment supports the remote access of objects over the network. Building on top of this feature I implemented a scripting language called Obliq [ 40 ] that made it very easy to do network programming, and that was used extensively within SRC. Obliq's main novel feature is "distributed lexical scoping", meaning that an active computation can migrate over the network and maintain a welldefined behavior, even if it refers to nonlocal resources. Obliq is still studied and referenced as a prime example of a simple network language. (It is also a fairly direct implementation of one of the object calculi in [ A ]). Obliq works very well as a scripting language over local area networks (LANs). But in 1995, web browsers began exposing people (and programmers) to Wide Area Networks (WANs). Computing models that were developed with LANs in mind, simply fall apart on a WAN  from small research project such as Obliq to failed industrywide endeavors such as CORBA. That's because WANs are asynchronous: there is no telling how long something will take, nor whether something has failed. Instead, the basis for LAN programming has always been Remote Procedure Call: a synchronous operation that rarely fails. I embarked on a program to understand the new "programming model" underlying WANs, to understand how to program WANs effectively. This led to an informal description of the basic principles of global computation over WANs [ 91 ]. Around the time that I moved to Microsoft Research in Cambridge UK in 1997, I teamed up with Andy Gordon to try and develop more formal foundations of WAN computation based on process algebra (formal concurrent languages with a strong mathematical basis). Existing process algebras did not seem to capture directly some essential WAN features. So, a new one, the Ambient Calculus [ 32 ], was invented: it extends to the core of Milner's picalculus (the most studied process algebra) with a hierarchy of locations and with mobility operations. The Ambient Calculus basically enables the formal analysis of mobile and widearea systems, in part by taking advantage of a decade of previous work on picalculi. Because of a good compromise of generality (modeling ability) and compactness (formal tractability) it quickly became very influential. Once a plausible notion of WAN computation was defined, in the form of the Ambient Calculus, the goal became to specify properties of such computations, e.g. for theoremproving, modelchecking, or bytecode verification purposes. Various approaches were attempted; the one that prevailed was a "spatial" modal logic where one could make locationaware assertions of the kind "here something is true" or "there something is true" or "somewhere something is true" (as well as routine "temporal" assertions) [ 86 ]. This constitutes a novel approach to logics for concurrency with intriguing connections to foundational logics such as linear logic. The ambient logic gave rise, rather unexpectedly, to an application in a very different domain, as a query language for semistructured databases [ 85 ]. The connection is that, as predicate logic can be seen as a query language for relational databases, so the ambient logic (a logic for treestructured locations) can be seen as a query language for treestructured data (a.k.a. semistructured data, or XML). In retrospect, the "spatial" or "locationaware" approach to logical descriptions makes sense also for most process calculi, where one may want to say "the system is made of two distinct parts such that..." or "the system owns a private resource such that...". This kind of assertion is not supported by traditional logics for concurrency. Efforts were then dedicated to the semantics and proof theory of such assertions [ 83 , 80 ], together with Luis Caires. The goal was to be able to describe concurrent systems to the fine level of detail of how they are constructed and of what resources they use, and not just of how they behave abstractly. Computational Biology and Nanotechnology (2001  current)Systems BiologyIn 2001, indirectly as a result of the work on the Ambient Calculus, I became involved in cosupervising the thesis of a Biologist (Aviv Regev) who wanted to model spatial compartments in cells. (This resulted in a paper in 2004 [ 25 ] that is already in my topten most cited publications.) I realized that I needed to get some basic understanding of cellular biology, and I quickly learned that the field was in the middle of a deep transformation: Systems Biology was being proposed to further the understanding of biological entities at a wholesystems (not components) level. This resonated strongly with concepts from Computer Science, to the point that I thought I could contribute to that area. And besides, biological systems are just fascinating from an informationprocessing point of view. Aviv Regev pioneered using a quantitative flavor of process algebra, and I began to wonder about what kind of programming languages (i.e., modeling languages) were needed to capture the complexity of biological systems. A major problem in systems biology is just to capture in a formal notation the complex and highly combinatorial interactions between components. This is in fact the problem that programming languages solve: they allow the flexible and compact representation of huge and complex state spaces, and enable their study. The main difference from standard programming languages is the massive concurrency of biological systems. But concurrency is the main subject of process algebra: I started applying the theory I was familiar with to these problems, although it was clear that many refinements would be needed. At Microsoft meanwhile there was a growing realization that Scientific Computing (as opposed to Business Computing) was a broad and important area to which we should contribute, both for business impact and for access to talent. Compatibly with that, I was instrumental in the initial contacts that led to the formation in 2005 of the Microsoft  University of Trento Centre for Computational and Systems Biology: I have been serving on the Board of Directors since then. The center started from a core competence in process algebra modeling, and has been branching out in all areas of biological modeling. From 2005 on I have participated in a number of projects in Systems Biology in collaboration with external researches, leading to a number of publications about modeling specific biological systems by process algebra techniques, ranging from immune system response [ 6 ], signaling networks [ 8 , 14 ], and cell cycle networks [ 2 ]. Quantitative SemanticsIn our initial efforts to model biological systems we were building precise quantitative mathematical models based on process algebra, and there was a clear connection between the process algebra 'compositional' approach of modeling systems by composing subsystems and the biologist's tendency to think about system components and their interactions (in contrast to the mathematician's approach to focus on the function of the whole system). But we came across a couple of 'social' problems. On a more superficial level, how could we explain our modeling languages to experimental biologists so that they would be motivated to help us in our modeling efforts, leading to closing the modelexperiment scientific cycle. On a deeper level, how could we explain to theoretical biologists, physicists, and mathematicians that we were doing precise modeling, and not some vague form of software coding not clearly related to, e.g., standard differential equation models. A formal connection was needed between process algebra and the mainstream theory of dynamical systems. The former is concerned with representing interactions between components, and the latter with the dynamics of quantities over time. But there is a lingua franca between the two: the "programming language" of chemical reactions, which on one hand implicitly (phenomenologically) describes interactions between molecules, and on the other hand can be analyzed kinetically. That programming language has, in Computer Science parlance, two distinct (and in fact different) mathematical meanings: where the variables are interpreted as concentrations (massaction / Ordinary Differential Equation (ODE) semantics) and where variables are interpreted as molecule counts (stochastic / Chemical Master Equation (CME) semantics). I studied a simple process algebra that has the property of corresponding exactly, in terms of systems dynamics, to systems of chemical reactions. This established a precise and quantitative connection between process algebra and chemical descriptions of the same systems. Unlike chemical reactions, however, process algebra is compositional, which in practice means that it can avoid combinatorial explosions in system descriptions when modeling complex systems, purely via a different way of describing them. I showed that both the ODE and CME semantics of that simple algebra match classical chemistry, and that the algebra can be easily interpreted as "populations of interacting finite state automata". In general, process algebra is much richer than that simplified chemical algebra, so there is scope for richer modeling. In fact, general process algebras can represent, by finite programs, systems that otherwise require an infinite set of chemical reactions or ODEs. Such systems are extremely common in Systems Biology, because they include all forms of complexation and regular and irregular polymerization. The reduction in descriptive complexity (potentially an infinite reduction!) is the main advantage that is gained by using process algebra and other computinginspired formal language in the modeling of complex systems. The next step needed to build on that foundation, which is still ongoing, is to fully develop a theory of quantitative process algebra, particularly the theory of quantitative approximation. This is the subject of much current research by a number of groups (particularly in the UK), who are now increasingly inspired by biological applications. There has been a rich related tradition in Computing, more often directed to probabilistic or hybrid (discretecontinuous) rather than stochastic systems. My contributions here have been to try to steer the area to consider stochastic systems more centrally, especially in collaboration with my coauthor Radu Mardare [ 61 , 57 , 56 ]. Molecular ProgrammingSystems biology, like most of biology and science in general, is a discipline attempting in the first instance to understand how natural systems work. From an engineering viewpoint, its main aim is to reverseengineer natural biological systems. But what about direct engineering of natural/physical/chemical systems? My natural inclination was always to think about compiling programming languages and process algebra models not only to software but also to physical matter: to active molecular structures like the ones found in biology. For a long time I could not see how that could be done, because there is relatively little 'predictive engineering' of molecular structures: e.g., we cannot flexibly engineer proteins. All that changed for me when in 2008 I came across the Molecular Programming Project (an NSF “Expeditions in Computing” program) via a chance keynote invitation to the DNA'14 conference. In particular, Erik Winfree's group at Caltech was building upon an already long tradition of DNA computing to show how to use DNA to physically emulate arbitrary chemical systems (up to time scaling). The programming language there is the language of (arbitrary stochastic finite programs written as) chemical reactions, which is 'approximately' Turingpowerful in a precise sense [ 10 ], and the physical realization is DNA molecules that support any kinetics one may choose to program. There was a clear path from programming languages to executable matter, and I started working eagerly in the area: in 2009 I had a refereed paper in the DNA'15 conference, and in 2011 I was cochair of the DNA'17 conference. My goal then became to connect the theory of programming languages to this new 'target architecture' provided by molecular systems. There was a disconnect there, because the theory of programming languages has been largely qualitative: what can be computed, how it can be computed, and what is the meaning of a program (although the theory of algorithmic complexity is quantitative). Instead, the chemical and physical theories of molecular systems are quantitative, concerning dynamical systems, kinetics, and ultimately thermodynamics. Fortunately, there had already been a specialized thread of work in Computer Science to study stochastic systems, motivated by performance evaluation of realtime systems and networks: for the previous 1015 years people had developed deep theories, methodologies, and analysis tools for stochastic and hybrid (discretecontinuous) computational systems. In the current phase of my work I am exploring the quantitative analysis of stochastic molecular systems via tools and theories, with collaborators at Microsoft, Oxford, and elsewhere [ 4 , 61 ]. InventionsMy work has normally led to publications rather than patents. The following could count as inventions or devices in a broad sense: Abstract Machines for
Functional Languages  An abstract machine is an
abstract target assembly language for a compiler. The notion
was not new, but I devised an abstract machine that was well
suited for functional language compilers (or any higherorder
lexicallyscoped language), particularly for the
implementation of function closures. Much practical and
theoretical research was dedicated to this topic in following
years. All functional language compilers now use abstract
machines, although of different natures. [
129
] Type Systems with
Subtyping  Although the initial focus of
objectoriented languages was on "code inheritance" and
"subclassing", it is now recognized that subtyping is
ultimately a more flexible and important concept. Subtyping
has been widely adopted by modern objectoriented languages
such as Java and C# for mediating the relations between
interfaces, in contrast with subclassing. Bounded
quantification has been introduced both in Java and in C#. I
pioneered the formal description of type systems with
subtyping. Such formal descriptions are necessary to establish
type soundness, which is ultimately necessary for security.
After the first paper, this work was developed with a number
of coauthors. [
52
,
55
,
47
,
49
,
A
] Modula3 Language
Definition  Modula3 was a very influential systems
programming language until the advent of Java, which adopted
most of Modula3's unique features. Modula3's type system is
carefully defined via a subtyping relation. This was a team
effort at Digital Equipment Corporation. [
P
] Distributed Lexical
Scoping  Distributed lexical scoping, as embedded in
the Obliq language, is a way to extend the notion of function
"closure" to distributed environments. It extends the notions
of Remote Procedure Call and code mobility. Obliq was widely
used at Digital, and frequently cited, but was restricted to
work within a networkbased implementation of Modula3 which
was not easily exportable. [
40
] Ambient Calculus 
Ambient Calculus is a processcalculus model for mobile
computation over widearea networks. Developed with Andy
Gordon, it is probably the most popular such model due to its
generality and relative simplicity. This was directly
motivated by industrial concerns about how to use "the web as
a computer". [
91
,
32
] Spatial Logics 
Arising from work on the Ambient Calculus, spatial logics are
modal logics where the modality is: "a certain property holds
here (and now)". Their intent is to provide a logic that is
inherently wellsuited to talking about distributed systems.
The basic idea was initiated with Andy Gordon and Giorgio
Ghelli (including a practical spinoff [
27
]), and was reapplied to standard process algebra with Luis
Caires [
83
,
80
]. Modeling Languages for
Dynamic Compartments  I introduced a formal language to
model topological membrane transformation such as phagocytosis
in a programmatic way [
75
,
16
]. This work is still far from applications, but the existing
broad field of Membrane Computing quickly adopted these ideas,
and we are beginning to use them in unexpected areas such as
programming microfluidic devices that manipulate vesicles. Twodomain DNA Strand Displacement  My main contribution to DNA nanotechnology has been a new architecture for synthetic DNA circuits [ 60 ]. It is structurally simpler than previous proposals, and hence is potentially more robust (this is currently being demonstrated by experiments). Secondly, it enables an entirely new manufacturing technology. Being the first circuit architecture that relies exclusively on doublestranded DNA (i.e., with no extra secondary structure), the DNA material can be produced by bacterial cloning, instead of by (artificial) DNA synthesis. The former leads to high quality natural DNA of practically arbitrary length, while the latter is technologically limited in the quality and the length of the DNA strands that can be obtained, and hence limits the complexity of the circuits.
i.
Luca Cardelli and
Peter Wegner. On
understanding types, data abstraction, and polymorphism.
Computing Surveys, 17(4):471522, 1985. Cited
by 2235
ii.
Luca Cardelli and
Andrew D. Gordon. Mobile
Ambients.Theoretical Computer Science.
Vol 240/1, June 2000. pp 177213. Cited
by 1187 + Cited
by 697
·
Most Influential
ETAPS 1998 Paper Award (Awarded in 2007).
iii.
Luca Cardelli. A
semantics of multiple inheritance.
Information and Computation, 76(2/3): 138164, 1988. Cited
by 1212
iv.
Martín Abadi, Luca
Cardelli, PierreLouis Curien, and JeanJacques Lévy. Explicit
substitutions. Journal of Functional
Programming, 1(4):375416, October 1991.Cited
by 836
v.
Luca Cardelli. A
language with distributed scope.
Computing Systems, 8(1):2759, January 1995. Cited
by 720
·
Most Influential POPL Paper
Award 2005 (for POPL 1995)
vi.
Roberto M. Amadio
and Luca Cardelli. Subtyping
recursive types. ACM Transactions on
Programming Languages and Systems, 15(4):575631, 1993. Cited
by 551
vii.
Aviv Regev,
Ekaterina M. Panina, William Silverman, Luca Cardelli, Ehud
Shapiro. BioAmbients:
An Abstraction for Biological Compartments.
Theoretical Computer Science. Volume 325, Issue 1 , 28
September 2004, Pages 141167. Elsevier. Cited
by 435
viii.
Antonio Albano,
Luca Cardelli, and Renzo Orsini. Galileo:
a strongly typed, interactive, conceptual language.
ACM Transactions on Database Systems (TODS), 10(2):230260,
1985. Cited
by 441
ix.
Luca Cardelli. Brane
Calculi  Interactions of Biological Membranes.
V.Danos, V.Schachter Eds.: Computational Methods in Systems
Biology. Lecture Notes in Computer Science, Vol 3082,
Springer, 2005. ISBN 3540253750. pp 257280. Cited
by 392
x.
Luca Cardelli and
Andrew D. Gordon. Anytime,
Anywhere. Modal Logics for Mobile Ambients.
Proceedings of the 27th ACM Symposium on Principles of
Programming Languages, 2000. pp 365377. Cited
by 382 · Most Influential POPL Paper Award 2010 (for POPL 2000) BooksTechnical MonographsA. Martín Abadi and Luca Cardelli. A Theory of Objects. Springer, 1996. Edited CollectionsB. Luca Cardelli, William Shih (Eds). DNA Computing and Molecular Programming. (Proceedings) Lecture Notes in Computer Science 6937, Springer, 2011. C. Luca Cardelli, Marcelo Fiore, Glynn Winskel (Eds.). Computation Meaning and Logic: Articles dedicated to Gordon Plotkin. Electronic Notes in Theoretical Computer Science 172, 2007. D. Luca Cardelli (Ed.). ECOOP 2003  ObjectOriented Programming. (Proceedings) 17th European Conference, Lecture Notes in Computer Science 2743, Springer, 2003. E. Henri E. Bal, Boumediene Belkhouche, and Luca Cardelli (Eds.). Internet Programming Languages. Lecture Notes in Computer Science 1686, Springer, 1999. F. Luca Cardelli (Ed.). POPL'98: The 25th ACM SIGPLANSIGACT Symposium on Principles of Programming Languages. (Proceedings) ACM Press, 1998. Book ChaptersG. Luca Cardelli, Corrado Priami. Visualization in Process Algebra Models of Biological Systems. In: Tony Hey, Stewart Tansley, Kristin Tolle, Eds. The Fourth Paradigm: Data Intensive Scientific Discovery. Creative Commons Attribution Share Alike License, pp 99105, October 2009. H. Luca Cardelli. Can a Systems Biologist Fix a Tamagotchi? In: Yves Bertot, Gérard Huet, JeanJacques Lévy, Gordon Plotkin (Eds.). From Semantics to Computer Science  Essays in Honour of Gilles Khan, Chapter 23, pp 517528. Cambridge University Press, 2009. ISBN 9780521518253. I. Luca Cardelli. Artificial Biochemistry. In: A.Condon, D.Harel, J.N.Kok, A.Salomaa, E.Winfree (Eds.). Algorithmic Bioprocesses. Springer 2009. DOI: 10.1007/9783540888697_22. ISBN: 9783540888680. J. Luca Cardelli. Bioware Languages. In: Andrew Herbert, Karen Sparck Jones (Eds.). Computer Systems: Theory, Technology, and Applications  A Tribute to Roger Needham, Monographs in Computer Science. Springer 2004. ISBN 038720170X. pp 5965. K. Luca Cardelli. Type systems. In: Allen B. Tucker (Ed.). The Computer Science and Engineering Handbook. CRC Press, 2004. Chapter 97. Allen B. Tucker (Ed.). The Computer Science and Engineering Handbook. CRC Press, 1997, ISBN: 0849329094. Chapter 103. L. Luca Cardelli. Mobility and Security. In: Friedrich L. Bauer and Ralf Steinbrggen (Eds.). Foundations of Secure Computation. Proceedings of the NATO Advanced Study Institute on Foundations of Secure Computation. IOS Press, 2000. ISBN 1 58603 015 9. pp. 337. M. Luca Cardelli. Mobile Computation. In: J. Vitek and C. Tschudin (Eds.). Mobile Object Systems  Towards the Programmable Internet. Lecture Notes in Computer Science, Vol. 1222, Springer, 1997. pp 36. N. Krishna Bharat and Luca Cardelli. Migratory Applications. In: J. Vitek and C. Tschudin E(Eds.). Mobile Object Systems  Towards the Programmable Internet. Lecture Notes in Computer Science, Vol. 1222, Springer, 1997. pp 131148. O. Luca Cardelli. Extensible records in a pure calculus of subtyping. In: C.A. Gunter and J.C. Mitchell (Eds.). Theoretical Aspects of ObjectOriented Programming. MIT Press, 1994. pp 373425. Q. Luca Cardelli. Typeful programming. E. J. Neuhold and M. Paul, Editors. Formal Description of Programming Concepts, IFIP State of the Art Reports Series. SpringerVerlag, February 1989. S. Luca Cardelli. The amber machine. In: Guy Cousineau, PierreLouis Curien, and Bernard Robinet (Eds.). Combinators and Functional Programming Languages, Lecture Notes in Computer Science, Vol. 242, pp 2170. SpringerVerlag, 1986. Journal ARTICLES1. Luca Cardelli, Philippa Gardner. Processes in Space. Theoretical Computer Science, Volume 431, 2012, pp. 4055. DOI: 10.1016/j.tcs.2011.12.051. 3. Ozan Kahramanoğulları, Luca Cardelli, Emmanuelle Caron.An Intuitive Modelling Interface for Systems Biology. International Journal of Software and Informatics, ISSN 16737288. 2012. (In press.) 7. Luca Cardelli. Strand Algebras for DNA Computing. Natural Computing 10(1) p. 407428, 2011. DOI: 10.1007/s1104701092367. 9. Luca Cardelli, Cosimo Laneve. Reversibility in Massive Concurrent Systems. Scientific Annals of Computer Science 21(2) 175198, A.I. Cuza University Press, 2011. 11. Dennis Y.Q. Wang, Luca Cardelli, Andrew Phillips, Nir Piterman, Jasmin Fisher. Computational Modeling of the EGFR Network Elucidates Control Mechanisms Regulating Signal Dynamics. BMC Systems Biology 2009, 3:118. doi:10.1186/175205093118. 13. Luca Cardelli, Emmanuelle Caron, Philippa Gardner, Ozan Kahramanoğulları, Andrew Phillips. A Process Model of Actin Polymerisation. Electronic Notes in Theoretical Computer Science (ENTCS) 229(1) February 2009, 127144. 17. Ralf Blossey, Luca Cardelli, Andrew Phillips. Compositionality, Stochasticity and Cooperativity in Dynamic Models of Gene Regulation. HFSP Journal, 2(1):17–28 February 2008. 18. Luca Cardelli, Philippa Gardner, and Giorgio Ghelli. L.Cardelli. Manipulating Trees with Hidden Labels. M.Fiore, G.Winskel (Eds.) ENTCS Electronic Notes in Theoretical Computer Science, Vol 172, 2007. pp. 177201. 19. Andrew Phillips, Luca Cardelli, Giuseppe Castagna. A Graphical Representation for Biological Processes in the Stochastic Picalculus. Transactions on Computational Systems Biology VII  Lecture Notes in Computer Science, Vol 4230, Springer 2006, ISBN: 9783540488378, pp 123152. 20. Ralf Blossey, Luca Cardelli, Andrew Phillips. A Compositional Approach to the Stochastic Dynamics of Gene Networks. Transactions on Computational Systems Biology IV  Lecture Notes in Computer Science, Vol 3939, Springer 2006, ISBN: 3540332456, pp 99122. 21. Luca Cardelli, Gheorghe Păun.A Universality Result for a (Mem)Brane Calculus Based on Mate/Drip Operations. International Journal of Foundations of Computer Science, 17(1), pp 4968. World Scientific Publishing Company. 2006. 22. Luca Cardelli. Abstract Machines of Systems Biology. Transactions on Computational Systems Biology. III, LNBI 3737, pp 145168, Springer 2005. 23. Cristiano Calcagno, Luca Cardelli, Andrew D. Gordon. Deciding Validity in a Spatial Logic for Trees. Journal of Functional Programming, Vol 15, pp 543572. Cambridge University Press, 2005. 24. Luca Cardelli, Giorgio Ghelli, Andrew D. Gordon.Secrecy and Group Creation. Information and Computation, Volume 196, Issue 2, January 2005, Pages 127155. 26. Luis Caires and Luca Cardelli. A Spatial Logic for Concurrency (Part II). Theoretical Computer Science, 322(3) pp. 517565, September 2004. 28. Nick Benton, Luca Cardelli, Cedric Fournet. Modern Concurrency Abstractions for C#. ACM Transactions on Programming Languages and Systems (TOPLAS) 26(5), 2004. pp.269804. 29. Luis Caires and Luca Cardelli. A Spatial Logic for Concurrency (Part I). Information and Computation, Vol 186/2 November 2003. pp 194235. 30. Andrew D. Gordon and Luca Cardelli. Equational Properties of Mobile Ambients. Mathematical Structures in Computer Science 13(3):371408, June 2003. 31. Luca Cardelli, Giorgio Ghelli, and Andrew D. Gordon. Types for the Ambient Calculus. Information and Computation, 177(2), 2002. pp. 160194. 33. Kim B. Bruce, Luca Cardelli, and Benjamin C. Pierce. Comparing Object Encodings. Information and Computation.Vol. 155, No. 1/2, Dec 1999, pp. 108133. 34. Luca Cardelli and Rowan Davies. Service Combinators for Web Computing. IEEE Transactions on Software Engineering, Vol 25, No 3, MayJune 1999. pp 309316. 35. Luca Cardelli. Bad engineering properties of objectoriented languages. ACM Computing Surveys, 28(4es), Article 150. 1996. 36. Martín Abadi and Luca Cardelli. On subtyping and matching. ACM Transactions on Programming Languages and Systems, 18(4):401423, 1996. 37. Martín Abadi and Luca Cardelli. A theory of primitive objects: Untyped and firstorder systems. Information and Computation, 125(2):78102, March 1996. 38. Luca Cardelli. Type systems. ACM Computing Surveys, 28(1):263264, 1996. 39. Luca Cardelli. Global computation. ACM Computing Surveys, 28(4es), Article 163. 1996. 40. Luca Cardelli. A language with distributed scope. Computing Systems, 8(1):2759, January 1995. 41. Kim Bruce, Luca Cardelli, Giuseppe Castagna, The Hopkins Objects Group, Gary T. Leavens, Benjamin Pierce. On binary methods. Theory and Practice of Object Systems, 1(3):221242, 1995. 42. Martín Abadi and Luca Cardelli. An imperative object calculus. Theory and Practice of Object Systems, 1(3):151166, 1995. 43. Martín Abadi and Luca Cardelli. A theory of primitive objects: Secondorder systems. Science of Computer Programming, 25(23):81116. December 1995. 44. Martín Abadi, Luca Cardelli, Benjamin C. Pierce, and Didier Rémy. Dynamic typing in polymorphic languages. Journal of Functional Programming, 5(1):111130, January 1995. 46. Martín Abadi, Luca Cardelli, and PierreLouis Curien. Formal parametric polymorphism. Theoretical Computer Science, 121(12):958: 1993. 50. Martín Abadi, Luca Cardelli, Benjamin C. Pierce, and Gordon D. Plotkin. Dynamic typing in a staticallytyped language. ACM Transactions on Programming Languages and Systems, 13(2):237268, April 1991. 53. Luca Cardelli. Basic polymorphic typechecking. Science of Computer Programming, 8(2): 147172, 1987. RefereedConference ARTICLESIn Computer Science many articles first appear in refereed
conference proceedings. Many workshops (including all the
ones listed below) are also formally refereed. Extended
versions of those articles are then published in journals.
These extended versions contain ‘significant’ new material
(a requirement of the journals), are independently
rerefereed, and are subject to a separate copyright; hence
they are technically separate publications while often
bearing the same title. Conference articles later extended and published in journals
(which are listed above) are indicated below in
parentheses. 58. Luca Cardelli, Cosimo Laneve. Reversible Structures. Proceedings of 9th Int. Conf. on Computational Methods in Systems Biology (CMSB 2011), ACM Digital Library, 2011. 131140. Doi:10.1145/2037509.2037529. 59. Luca Cardelli, Philippa Gardner. (Processes in Space.) F.Ferreira, B.Löwe, E.Mayordomo, L.M.Gomes (Eds.). Programs, Proofs, Processes: 6th Conference on Computability in Europe, CiE 2010, Ponta Delgada, Azores, Portugal, June/July 2010, Proceedings. LNCS 6158, pp. 7887, Springer 2010. 62. Luca Cardelli. (Strand Algebras for DNA Computing.)DNA Computing and Molecular Programming. 15th International Conference, DNA 15, Fayetteville, AR, USA, June 2009, Revised Selected Papers. LNCS 5877, Springer, October 2009, pp 1224. 63. Ozan Kahramanoğulları, Luca Cardelli, Emmanuelle Caron. (An Intuitive Modelling Interface for Systems Biology.) Developments in Computational Models 2009. EPTCS 9, pp. 7386, 2009. http://arxiv.org/abs/0911.2327. 64. Luca Cardelli. Molecules as Automata (Extended Abstract). In: A.Corradini, U.Montanari (Eds.). Recent Trends in Algebraic Development Techniques, 19th International Workshop, WADT 2008, Pisa 1316 June 2008. Lecture Notes in Computer Science 5486, Springer, June 2009. 65. Luca Cardelli, Emmanuelle Caron, Philippa Gardner, Ozan Kahramanoğulları, Andrew Phillips. (A Process Model of Actin Polymerisation.) From Biology to Concurrency and back, FBTC 2008, Satellite Workshop of ICALP 2008, July 2008, Reykjavik. 66. Gianluigi Zavattaro, Luca Cardelli. Termination Problems in Chemical Kinetics. In F.van Breugel, M.Chechik (Eds.) CONCUR 2008  Concurrency Theory, 19th International Conference, Toronto, Canada, August 2008. LNCS 5201, pp 477491, Springer 2008. 67. Luca Cardelli, Gianluigi Zavattaro. On the Computational Power of Biochemistry. Third International Conference on Algebraic Biology, AB 2008, July 2008, Linz. 68. Luca Cardelli, Philippa Gardner, Ozan Kahramanoğulları. A Process Model of Rho GTPbinding Proteins in the Context of Phagocytosis. Proc. From Biology To Concurrency and back, Lisbon 8 Sep 2007 in conjunction with Concur 2007. ENTCS 194(3):87102, Elsevier, 2008. <doi:10.1016/j.entcs.2007.12.007> 69. S. van Bakel, L. Cardelli and M.G. Vigliotti.From X to Pi: Representing Classical Sequent Calculus in Picalculus. International Workshop on Classical Logic and Computation (CL&C'08), Reykjavik, Iceland, July 2008. 70. Luca Cardelli. From Processes to ODEs by Chemistry. Fifth IFIP International Conference on Theoretical Computer Science, TCS 2008, 261281, Milan, September 2008. ISBN: 9780387096797. DOI: <http://dx.doi.org/10.1007/9780387096803_18> 71. Andrew Phillips, Luca Cardelli. Efficient, Correct Simulation of Biological Processes in Stochastic Picalculus. Proc. Computational Methods in Systems Biology, CMSB 2007, Edinburgh, September 2007. LNBI 4695, 184199, Springer 2007. 72. Luca Cardelli. A Process Algebra Master Equation. Fourth International Conference on the Quantitative Evaluation of Systems, QEST 2007, Edinburgh, September 2007. IEEE Publishing, ISBN: 9780769528830, pp 219224, 2007. 73. Andrew Phillips, Luca Cardelli. A Graphical Representation for the Stochastic Picalculus. Proceedings of Concurrent Models in Molecular Biology (Bioconcur'05), affiliated with CONCUR'05. 2005. 74. Luca Cardelli, Sylvain Pradalier. Where Membranes Meet Complexes. Proceedings of Concurrent Models in Molecular Biology (Bioconcur'05), affiliated with CONCUR'05. 2005. 76. Alain Frisch and Luca Cardelli. Greedy Regular Expression Matching. Automata, Languages and Programming: 31st International Colloquium, ICALP 2004, Turku, Finland, July 1216, 2004. Lecture Notes in Computer Science 3142. Springer 2004.ISBN 3540228497. pp. 618629. 77. Andrew Phillips, Luca Cardelli. A Correct Abstract Machine for the Stochastic Picalculus. Proceedings of Concurrent Models in Molecular Biology (Bioconcur'04), affiliated with CONCUR'04. 2004. 78. Luca Cardelli, Philippa Gardner, and Giorgio Ghelli. (Manipulating Trees with Hidden Labels.) Andrew D. Gordon (Ed.) Foundations of Software Science and Computational Structures. 6th International Conference, FOSSACS 2003. Lecture Notes in Computer Science 2620. Springer, 2003. ISBN 3540008977. pp 216232. 79. Cristiano Calcagno, Luca Cardelli, Andrew D. Gordon. (Deciding Validity in a Spatial Logic for Trees.) ACM Workshop on Types in Language Design and Implementation, TLDI'03, New Orleans, January 2003, ACM Press. pp 6273. 81. Nick Benton, Luca Cardelli, Cedric Fournet. Modern Concurrency Abstractions for C#. Boris Magnusson (Ed.): ECOOP 2002  ObjectOriented Programming, 16th European Conference. Lecture Notes in Computer Science 2374, Springer, 2002. ISBN 3540437592. pp. 415440. 82. Luca Cardelli, Philippa Gardner, and Giorgio Ghelli. A Spatial Logic for Querying Graphs. Peter Widmayer, Francisco Triguero, Rafael Morales, Matthew Hennessy, Stephan Eidenbenz, Ricardo Conejo (Eds.). Automata, Languages, and Programming, 29th International Colloquium, ICALP 2002, Malaga, Spain, July 2002, Proceedings. Lecture Notes in Computer Science, Vol 2380, Springer, 2002. ISBN 3540438645. pp 597610. 84. Luca Cardelli and Andrew D. Gordon. Logical Properties of Name Restriction. Samson Abramsky (Ed.). Typed Lambda Calculi and Applications. 5th International Conference, TLCA 2001, Krakow, Poland, May 2001, Proceedings. Lecture Notes in Computer Science, Vol. 2044, Springer, 2001. ISBN 3540419608. pp 4660. 87. Luca Cardelli. Semistructured Computation. Richard C. H. Connor, Alberto O. Mendelzon (Eds.): Research Issues in Structured and Semistructured Database Programming, 7th International Workshop on Database Programming Languages, DBPL'99. Lecture Notes in Computer Science 1949. Springer, 2000. ISBN 3540414819. pp. 116. 88. Luca Cardelli, Giorgio Ghelli, and Andrew D. Gordon. Ambient Groups and Mobility Types. In Jan van Leeuwen, Osamu Watanabe, Masami Hagiya, Peter D. Mosses, Takayasu Ito (Eds.). Theoretical Computer Science, International Conference IFIP TCS 2000. Lecture Notes in Computer Science, Vol. 1872, Springer, 2000. ISBN 3540678239. pp. 333347. 89. Luca Cardelli, Giorgio Ghelli, Andrew D. Gordon. (Secrecy and Group Creation.) Catuscia Palamidessi (Ed.). CONCUR 2000  Concurrency Theory. 11th International Conference. Lecture Notes in Computer Science, Vol. 1877, Springer, 2000. ISBN 3540678972. pp. 365379. 90. Andrew D. Gordon and Luca Cardelli. (Equational Properties of Mobile Ambients.) Wolfgang Thomas, Editor. Foundations of Software Science and Computational Structures, Second International Conference, FOSSACS'99. Lecture Notes in Computer Science, Vol. 1578. Springer, 1999. ISBN 3540657193. pp 212226. 92. Luca Cardelli, Giorgio Ghelli, and Andrew D. Gordon. Mobility Types for Mobile Ambients. Jiri Wiedermann, Peter van Emde Boas, and Mogens Nielsen, Editors. Automata, Languagese and Programming, 26th International Colloquium, ICALP'99. Lecture Notes in Computer Science, Vol. 1644, Springer, 1999. ISBN 3540662243. pp. 230239. 93. Luca Cardelli and Andrew D. Gordon. Types for Mobile Ambients. Proceedings of the 26th ACM Symposium on Principles of Programming Languages, 1999. pp 7992. 94. Luca Cardelli. Abstractions for Mobile Computation. Jan Vitek and Christian Jensen, Editors. Secure Internet Programming: Security Issues for Mobile and Distributed Objects. Lecture Notes in Computer Science, Vol. 1603, Springer, 1999. ISBN 3540661301. pp. 5194. 95. Luca Cardelli and Andrew D. Gordon. (Mobile Ambients.) Foundations of Software Science and Computational Structures, Maurice Nivat (Ed.), Lecture Notes in Computer Science, Vol. 1378, Springer, 1998. pp. 140155. 96. Kim B. Bruce, Luca Cardelli, and Benjamin C. Pierce. (Comparing Object Encodings.) Martín Abadi, Takayasu Ito (Eds.): Theoretical Aspects of Computer Software, Third International Symposium, TACS '97. Lecture Notes in Computer Science, Vol. 1281, Springer, 1997, ISBN 354063388X. pp 415438. 97. Luca Cardelli and Rowan Davies. (Service Combinators for Web Computing.) First Usenix Conference on Domain Specific Languages, Santa Barbara, California, October 1517, 1997. 98. Luca Cardelli. Program fragments, linking, and modularization. POPL'97: The 24th ACM SIGPLANSIGACT Symposium on Principles of Programming Languages. ACM Press, 1997, ISBN 0897918533. pp 266277. 99. Martín Abadi, Luca Cardelli, Ramesh Viswanathan. An interpretation of objects and object types. POPL'96: The 23rd ACM SIGPLANSIGACT Symposium on Principles of Programming Languages. ACM Press, 1996, ISBN 0897917693. pp 396409. 100. Martín Abadi and Luca Cardelli. (On subtyping and matching.) Walter G. Olthoff (Ed.): ECOOP'95  ObjectOriented Programming, 9th European Conference. Lecture Notes in Computer Science, Vol. 952, Springer, 1995, ISBN 3540601600. pp 145167. 101. Martín Abadi and Luca Cardelli. (An imperative object calculus.) Peter D. Mosses, Mogens Nielsen, Michael I. Schwartzbach: TAPSOFT'95: Theory and Practice of Software Development, 6th International Joint Conference CAAP/FASE. Lecture Notes in Computer Science, Vol. 915, Springer, 1995, ISBN 3540592938. pp 471485. 102. Martín Abadi and Luca Cardelli. An imperative object calculus: Basic typing and soundness. SIPL '95  Proceedings of the Second ACM SIGPLAN Workshop on State in Programming Languages. Department of Computer Science, University of Illinois at UrbanaChampaign, 1995. 103. Krishna Bharat and Luca Cardelli. (Migratory Applications.) ACM Symposium on User Interface Software and Technology '95, Pittsburgh, PA, November 1995. pp 133142. 104. Krishna Bharat and Luca Cardelli. Distributed applications in a multimedia setting. First International Workshop on Hypermedia Design (IWHD'95), Montpellier, France, 12 June 1995. pp 185192. 105. Luca Cardelli. (A language with distributed scope.) POPL'95: 22nd ACM SIGPLANSIGACT Symposium on Principles of Programming Languages. ACM Press, 1995, ISBN 0897916921. pp 286297. 106. Luca Cardelli, Florian Matthes, and Martín Abadi. Extensible grammars for language specialization. Catriel Beeri, Atsushi Ohori, Dennis Shasha(Eds.): Database Programming Languages (DBPL4), Proceedings of the Fourth International Workshop on Database Programming Languages  Object Models and Languages. Springer 1994, ISBN 3540198539. pp 1131. 107. Martín Abadi and Luca Cardelli. (A theory of primitive objects: Untyped and firstorder systems.) Masami Hagiya, John C. Mitchell (Eds.): Theoretical Aspects of Computer Software, International Conference TACS '94. Lecture Notes in Computer Science, Vol. 789, Springer, 1994, ISBN 3540578870. pp 296320. 108. Martín Abadi and Luca Cardelli. (A theory of primitive objects: Secondorder systems.) Donald Sannella (Ed.): Programming Languages and Systems  ESOP'94, 5th European Symposium on Programming. Lecture Notes in Computer Science, Vol. 788, Springer 1994, ISBN 3540578803. pp 125. 109. Martín Abadi and Luca Cardelli. A semantics of object types. Proceedings, Ninth Annual IEEE Symposium on Logic in Computer Science, Paris, France, July 1994. IEEE Computer Society Press, ISBN 0818663103. pp 332341. 110. Gordon D. Plotkin, Martín Abadi, and Luca Cardelli. Subtyping and parametricity. Ninth Annual IEEE Symposium on Logic in Computer Science, Paris, France, July 1994. IEEE Computer Society Press, ISBN 0818663103. pp 310319. 111. Martín Abadi, Luca Cardelli, and PierreLouis Curien. (Formal parametric polymorphism.) Twentieth Annual ACM SIGPLANSIGACT Symposium on Principles of Programming Languages. ACM Press, 1993. pp 157170. 112. Martín Abadi, Luca Cardelli, Benjamin C. Pierce, and Didier Rémy. (Dynamic typing in polymorphic languages.) Proceedings of the ACM SigPlan Workshop on ML and its Applications, June 1992. 113. Luca Cardelli, John C. Mitchell, Simone Martini, and Andre Scedrov. (An extension of system F with subtyping.) Takayasu Ito, Albert R. Meyer (Eds.): Theoretical Aspects of Computer Software, TACS '91. Lecture Notes in Computer Science, Vol. 526, Springer, 1991, ISBN 3540544151. pp 750770. 114. Roberto M. Amadio and Luca Cardelli. (Subtyping recursive types.) Eighteenth Annual ACM Symposium on Principles of Programming Languages, Orlando, Florida, January 1991. pp 104118. 115. Luca Cardelli. A pure calculus of subtyping, and applications (outline). Paris C. Kanellakis, Joachim W. Schmidt (Eds.): Database Programming Languages: Bulk Types and Persistent Data. 3rd International Workshop. Morgan Kaufmann,1991. ISBN 1558602429. pp 185187. 116. Luca Cardelli and Giuseppe Longo. (A semantic basis for Quest.) ACM Conference on LISP and Functional Programming. ACM Press. 1990. 117. Martín Abadi, Luca Cardelli, PierreLouis Curien, and JeanJacques Lévy. (Explicit substitutions.) Seventeenth Annual ACM Symposium on Principles of Programming Languages, San Francisco, California, January 1990. pp 3146. 118. Luca Cardelli and Xavier Leroy. Abstract types and the dot notation. Programming Concepts and Methods, IFIP State of the Art Reports. TC2 Working Conference. North Holland, 1990. pp 479504. 119. Martín Abadi, Luca Cardelli, Benjamin C. Pierce, and Gordon D. Plotkin. (Dynamic typing in a staticallytyped language.) Sixteenth Annual ACM Symposium on Principles of Programming Languages, Austin, Texas, January 1989. pp 213227. 120. Luca Cardelli and John C. Mitchell. (Operations on records.) Mathematical Foundations of Programming Semantics, 5th International Conference. Lecture Notes in Computer Science, Vol. 442, Springer, 1990. 121. Luca Cardelli, James Donahue, Mick Jordan, Bill Kalsow, and Greg Nelson.The Modula3 Type System. Sixteenth Annual ACM Symposium on Principles of Programming Languages, Austin, Texas, January 1989. pp 202212. 122. Luca Cardelli. Types for dataoriented languages. Joachim W. Schmidt, Stefano Ceri, Michele Missikoff (Eds.): Advances in Database Technology  EDBT'88. Proceedings of the International Conference on Extending Database Technology. Lecture Notes in Computer Science, Vol. 303, Springer, 1988, ISBN 3540190740 and 0387190740. pp 115. 124. Luca Cardelli. Structural subtyping and the notion of power type. Fifteenth Annual ACM Symposium on Principles of Programming Languages. ACM Press, 1988. pp 7079. 125. Luca Cardelli, David B. MacQueen. Persistence and Type Abstraction. Malcolm P. Atkinson, Peter Buneman, Ronald Morrison (Eds.): Data Types and Persistence. Edited Papers from the Proceedings of the First Workshop on Persistent Objects. Springer 1988, ISBN 3540187855. pp 3141. 126. Luca Cardelli. Typechecking dependent types and subtypes. Workshop on Foundations of Logic and Functional Programming. Lecture Notes in Computer Science, Vol. 306, pp 4557. SpringerVerlag, December 1986. 128. Luca Cardelli. An implementation model of rendezvous communication. S.D. Brookes, A.W. Roscoe and G. Winskel. Seminar on Concurrency. Lecture Notes in Computer Science, Vol. 197, SpringerVerlag, 1985, ISBN 3540156704. pp 449457. 130. Luca Cardelli. (A semantics of multiple inheritance.) G. Kahn, D.B. MacQueen and G. Plotkin Eds. Semantics of Data Types, International Symposium. Lecture Notes in Computer Science, Vol. 173, SpringerVerlag, 1984, ISBN 3540133461. pp 5167. 131. Luca Cardelli. Twodimensional syntax for functional languages.Pierpaolo Degano and Erik Sandewall, editors, Integrated Interactive Computing Systems. Proceedings of the European Conference on Integrated Interactive Computing Systems, ECICS 82. North Holland, ISBN 0444865950, 1983. pp 139151. 132. Luca Cardelli. Real time agents. Mogens Nielsen, Erik Meineche Schmidt (Eds.): Automata, Languages and Programming, 9th Colloquium. Lecture Notes in Computer Science, Vol. 140, Springer, 1982, ISBN 3540115765. pp 94106. 133. Luca Cardelli and Gordon D. Plotkin. An algebraic approach to VLSI design. John P. Gray (Ed.). VLSI 81, First International Conference on Very Large Scale Integration, University of Edinburgh, August 1821, 1981. Academic Press, ISBN 0122968603. pp 173182. 134. Luca Cardelli. Analog processes. P. Dembinski (Ed.): Mathematical Foundations of Computer Science (MFCS'80), Proceedings of the 9th Symposium. Lecture Notes in Computer Science, Vol. 88, Springer 1980, ISBN 354010027X. pp 181193.
