6,580 research outputs found
In the Age of Web: Typed Functional-First Programming Revisited
Most programming languages were designed before the age of web. This matters
because the web changes many assumptions that typed functional language
designers take for granted. For example, programs do not run in a closed world,
but must instead interact with (changing and likely unreliable) services and
data sources, communication is often asynchronous or event-driven, and programs
need to interoperate with untyped environments.
In this paper, we present how the F# language and libraries face the
challenges posed by the web. Technically, this comprises using type providers
for integration with external information sources and for integration with
untyped programming environments, using lightweight meta-programming for
targeting JavaScript and computation expressions for writing asynchronous code.
In this inquiry, the holistic perspective is more important than each of the
features in isolation. We use a practical case study as a starting point and
look at how F# language and libraries approach the challenges posed by the web.
The specific lessons learned are perhaps less interesting than our attempt to
uncover hidden assumptions that no longer hold in the age of web.Comment: In Proceedings ML/OCaml 2014, arXiv:1512.0143
NaDeA: A Natural Deduction Assistant with a Formalization in Isabelle
We present a new software tool for teaching logic based on natural deduction.
Its proof system is formalized in the proof assistant Isabelle such that its
definition is very precise. Soundness of the formalization has been proved in
Isabelle. The tool is open source software developed in TypeScript / JavaScript
and can thus be used directly in a browser without any further installation.
Although developed for undergraduate computer science students who are used to
study and program concrete computer code in a programming language we consider
the approach relevant for a broader audience and for other proof systems as
well.Comment: Proceedings of the Fourth International Conference on Tools for
Teaching Logic (TTL2015), Rennes, France, June 9-12, 2015. Editors: M.
Antonia Huertas, Jo\~ao Marcos, Mar\'ia Manzano, Sophie Pinchinat,
Fran\c{c}ois Schwarzentrube
Trust, but Verify: Two-Phase Typing for Dynamic Languages
A key challenge when statically typing so-called dynamic languages is the
ubiquity of value-based overloading, where a given function can dynamically
reflect upon and behave according to the types of its arguments. Thus, to
establish basic types, the analysis must reason precisely about values, but in
the presence of higher-order functions and polymorphism, this reasoning itself
can require basic types. In this paper we address this chicken-and-egg problem
by introducing the framework of two-phased typing. The first "trust" phase
performs classical, i.e. flow-, path- and value-insensitive type checking to
assign basic types to various program expressions. When the check inevitably
runs into "errors" due to value-insensitivity, it wraps problematic expressions
with DEAD-casts, which explicate the trust obligations that must be discharged
by the second phase. The second phase uses refinement typing, a flow- and
path-sensitive analysis, that decorates the first phase's types with logical
predicates to track value relationships and thereby verify the casts and
establish other correctness properties for dynamically typed languages
- …