Results 11  20
of
419
Links: web programming without tiers
 In FMCO 2006, volume 4709 of LNCS
, 2007
"... Abstract. Links is a programming language for web applications that generates code for all three tiers of a web application from a single source, compiling into JavaScript to run on the client and into SQL to run on the database. Links supports rich clients running in what has been dubbed ‘Ajax ’ st ..."
Abstract

Cited by 123 (19 self)
 Add to MetaCart
(Show Context)
Abstract. Links is a programming language for web applications that generates code for all three tiers of a web application from a single source, compiling into JavaScript to run on the client and into SQL to run on the database. Links supports rich clients running in what has been dubbed ‘Ajax ’ style, and supports concurrent processes with staticallytyped message passing. Links is scalable in the sense that session state is preserved in the client rather than the server, in contrast to other approaches such as Java Servlets or PLT Scheme. Clientside concurrency in JavaScript and transfer of computation between client and server are both supported by translation into continuationpassing style. 1
The Polymorphic Picalculus: Theory and Implementation
, 1995
"... We investigate whether the πcalculus is able to serve as a good foundation for the design and implementation of a stronglytyped concurrent programming language. The first half of the dissertation examines whether the πcalculus supports a simple type system which is flexible enough to provide a su ..."
Abstract

Cited by 112 (0 self)
 Add to MetaCart
We investigate whether the πcalculus is able to serve as a good foundation for the design and implementation of a stronglytyped concurrent programming language. The first half of the dissertation examines whether the πcalculus supports a simple type system which is flexible enough to provide a suitable foundation for the type system of a concurrent programming language. The second half of the dissertation considers how to implement the πcalculus efficiently, starting with an abstract machine for πcalculus and finally presenting a compilation of πcalculus to C. We start the dissertation by presenting a simple, structural type system for πcalculus, and then, after proving the soundness of our type system, show how to infer principal types for πterms. This simple type system can be extended to include useful typetheoretic constructions such as recursive types and higherorder polymorphism. Higherorder polymorphism is important, since it gives us the ability to implement abstract datatypes in a typesafe manner, thereby providing a greater degree of modularity for πcalculus programs. The functional computational paradigm plays an important part in many programming languages. It is wellknown that the πcalculus can encode functional computation. We go further and show that the type structure of λterms is preserved by such encodings, in the sense that we can relate the type of a λterm to the type of its encoding in the πcalculus. This means that a πcalculus programming language can genuinely support typed functional programming as a special case. An efficient implementation of πcalculus is necessary if we wish to consider πcalculus as an operational foundation for concurrent programming. We first give a simple abstract machine for πcalculus and prove it correct. We then show how this abstract machine inspires a simple, but efficient, compilation of πcalculus to C (which now forms the basis of the Pict programming language implementation).
Practical type inference for arbitraryrank types
 JOURNAL OF FUNCTIONAL PROGRAMMING
, 2005
"... ..."
Scalable ContextSensitive Flow Analysis Using Instantiation Constraints
 In Conference on Programming Language Design and Implementation
, 2000
"... This paper shows that a type graph (obtained via polymorphic type inference) harbors explicit directional flow paths between functions. These flow paths arise from the instantiations of polymorphic types and correspond to callreturn sequences in firstorder programs. We show that flow information c ..."
Abstract

Cited by 95 (2 self)
 Add to MetaCart
This paper shows that a type graph (obtained via polymorphic type inference) harbors explicit directional flow paths between functions. These flow paths arise from the instantiations of polymorphic types and correspond to callreturn sequences in firstorder programs. We show that flow information can be computed efficiently while considering only paths with well matched callreturn sequences, even in the higherorder case. Furthermore, we present a practical algorithm for inferring type instantiation graphs and provide empirical evidence to the scalability of the presented techniques by applying them in the context of pointsto analysis for C programs.
A Polymorphic Record Calculus and Its Compilation
 ACM Transactions on Programming Languages and Systems
, 1995
"... this article appeared in Proceedings of ACM Symposium on Principles of Programming Languages, 1992, under the title \A compilation method for MLstyle polymorphic record calculi." This work was partly supported by the Japanese Ministry of Education under scienti c research grant no. 06680319. A ..."
Abstract

Cited by 80 (10 self)
 Add to MetaCart
(Show Context)
this article appeared in Proceedings of ACM Symposium on Principles of Programming Languages, 1992, under the title \A compilation method for MLstyle polymorphic record calculi." This work was partly supported by the Japanese Ministry of Education under scienti c research grant no. 06680319. Author's address: Research Institute for Mathematical Sciences, Kyoto University, Sakyoku, Kyoto 60601, JAPAN; email: ohori@kurims.kyotou.ac.jp Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice and the title of the publication and its date appear, and notice is given that copying is by permission of ACM. To copy otherwise, or to republish, requires a fee and/or speci c permission. c 1999 ACM 01640925/99/01000111 $00.75
Mechanizing the metatheory of Standard ML
, 2007
"... We present an internal language with equivalent expressive power to Standard ML, and discuss its formalization in LF and the machinechecked verification of its type safety in Twelf. The internal language is intended to serve as the target of elaboration in an elaborative semantics for Standard ML ..."
Abstract

Cited by 80 (11 self)
 Add to MetaCart
We present an internal language with equivalent expressive power to Standard ML, and discuss its formalization in LF and the machinechecked verification of its type safety in Twelf. The internal language is intended to serve as the target of elaboration in an elaborative semantics for Standard ML in the style of Harper and Stone. Therefore, it includes all the programming mechanisms necessary to implement Standard ML, including translucent modules, abstraction, polymorphism, higher kinds, references, exceptions, recursive types, and recursive functions. Our successful formalization of the proof involved a careful interplay between the precise formulations of the various mechanisms, and required the invention of new representation and proof techniques of general interest.
Gradual Typing for Functional Languages
 IN SCHEME AND FUNCTIONAL PROGRAMMING WORKSHOP
, 2006
"... Static and dynamic type systems have wellknown strengths and weaknesses, and each is better suited for different programming tasks. There have been many efforts to integrate static and dynamic typing and thereby combine the benefits of both typing disciplines in the same language. The flexibility o ..."
Abstract

Cited by 80 (13 self)
 Add to MetaCart
Static and dynamic type systems have wellknown strengths and weaknesses, and each is better suited for different programming tasks. There have been many efforts to integrate static and dynamic typing and thereby combine the benefits of both typing disciplines in the same language. The flexibility of static typing can be improved by adding a type Dynamic and a typecase form. The safety and performance of dynamic typing can be improved by adding optional type annotations or by performing type inference (as in soft typing). However, there has been little formal work on type systems that allow a programmercontrolled migration between dynamic and static typing. Thatte proposed QuasiStatic Typing, but it does not statically catch all type errors in completely annotated programs. Anderson and Drossopoulou defined a nominal type system for an objectoriented language with optional type annotations. However, developing a sound, gradual type system for functional languages with structural types is an open problem. In this paper
Synchronous Kahn Networks
, 1996
"... Synchronous dataflow is a programming paradigm which has been successfully applied in reactive systems. In this context, it can be characterized as some class of static bounded memory dataflow networks. In particular, these networks are not recursively defined, and obey some kind of "synchron ..."
Abstract

Cited by 76 (12 self)
 Add to MetaCart
Synchronous dataflow is a programming paradigm which has been successfully applied in reactive systems. In this context, it can be characterized as some class of static bounded memory dataflow networks. In particular, these networks are not recursively defined, and obey some kind of "synchronous" constraints (clock calculus). Based on Kahn's relationship between dataflow and stream functions, the synchronous constraints can be related to Wadler's listlessness, and can be seen as sufficient conditions ensuring listless evaluation. As a byproduct, those networks enjoy efficient compiling techniques. In this paper, we show that it is possible to extend the class of static synchronous dataflow to higher order and dynamical networks, thus giving sense to a larger class of synchronous dataflow networks.
Typed Concurrent Objects
 In Proceedings of the Eighth European Conference on Object Oriented Programming (ECOOP
"... Based on a namepassing calculus and on its typing system the paper shows how to build several language constructors towards a stronglytyped objectoriented concurrent programming language. The basic calculus incorporates the notions of asynchronous labelled messages, concurrent objects composed of ..."
Abstract

Cited by 72 (10 self)
 Add to MetaCart
(Show Context)
Based on a namepassing calculus and on its typing system the paper shows how to build several language constructors towards a stronglytyped objectoriented concurrent programming language. The basic calculus incorporates the notions of asynchronous labelled messages, concurrent objects composed of labelled methods, and a form of abstraction on processes allowing in particular to declare polymorphic classes. We introduce a notion of values as nameexpressions, and show how to create subclasses of existing classes. A systematic translation of the derived constructors into the basic calculus provides for semantics and for typing rules for the new constructors.