48,538 research outputs found
Acute: high-level programming language design for distributed computation
Existing languages provide good support for typeful programming of standalone programs. In a distributed system, however, there may be interaction between multiple instances of many distinct programs, sharing some (but not necessarily all) of their module structure, and with some instances rebuilt with new versions of certain modules as time goes on. In this paper we discuss programming language support for such systems, focussing on their typing and naming issues. We describe an experimental language, Acute, which extends an ML core to support distributed development, deployment, and execution, allowing type-safe interaction between separately-built programs. The main features are: (1) type-safe marshalling of arbitrary values; (2) type names that are generated (freshly and by hashing) to ensure that type equality tests suffice to protect the invariants of abstract types, across the entire distributed system; (3) expression-level names generated to ensure that name equality tests suffice for type-safety of associated values, e.g. values carried on named channels; (4) controlled dynamic rebinding of marshalled values to local resources; and (5) thunkification of threads and mutexes to support computation mobility. These features are a large part of what is needed for typeful distributed programming. They are a relatively lightweight extension of ML, should be efficiently implementable, and are expressive enough to enable a wide variety of distributed infrastructure layers to be written as simple library code above the byte-string network and persistent store APIs. This disentangles the language runtime from communication intricacies. This paper highlights the main design choices in Acute. It is supported by a full language definition (of typing, compilation, and operational semantics), by a prototype implementation, and by example distribution libraries
Phobos: A front-end approach to extensible compilers (long version)
This paper describes a practical approach for implementing certain types of domain-specific languages with extensible compilers. Given a compiler with one or more front-end languages, we introduce the idea of a "generic" front-end that allows the syntactic and semantic specification of domain-specific languages. Phobos, our generic front-end, offers modular language specification, allowing the programmer to define new syntax and semantics incrementally
Towards correct-by-construction product variants of a software product line: GFML, a formal language for feature modules
Software Product Line Engineering (SPLE) is a software engineering paradigm
that focuses on reuse and variability. Although feature-oriented programming
(FOP) can implement software product line efficiently, we still need a method
to generate and prove correctness of all product variants more efficiently and
automatically. In this context, we propose to manipulate feature modules which
contain three kinds of artifacts: specification, code and correctness proof. We
depict a methodology and a platform that help the user to automatically produce
correct-by-construction product variants from the related feature modules. As a
first step of this project, we begin by proposing a language, GFML, allowing
the developer to write such feature modules. This language is designed so that
the artifacts can be easily reused and composed. GFML files contain the
different artifacts mentioned above.The idea is to compile them into FoCaLiZe,
a language for specification, implementation and formal proof with some
object-oriented flavor. In this paper, we define and illustrate this language.
We also introduce a way to compose the feature modules on some examples.Comment: In Proceedings FMSPLE 2015, arXiv:1504.0301
Co-expression networks in generation of induced pluripotent stem cells.
We developed an adenoviral vector, in which Yamanaka's four reprogramming factors (RFs) were controlled by individual CMV promoters in a single cassette (Ad-SOcMK). This permitted coordinated expression of RFs (SOX2, OCT3/4, c-MYC and KLF4) in a cell for a transient period of time, synchronizing the reprogramming process with the majority of transduced cells assuming induced pluripotent stem cell (iPSC)-like characteristics as early as three days post-transduction. These reprogrammed cells resembled human embryonic stem cells (ESCs) with regard to morphology, biomarker expression, and could be differentiated into cells of the germ layers in vitro and in vivo. These iPSC-like cells, however, failed to expand into larger iPSC colonies. The short and synchronized reprogramming process allowed us to study global transcription changes within short time intervals. Weighted gene co-expression network analysis (WGCNA) identified sixteen large gene co-expression modules, each including members of gene ontology categories involved in cell differentiation and development. In particular, the brown module contained a significant number of ESC marker genes, whereas the turquoise module contained cell-cycle-related genes that were downregulated in contrast to upregulation in human ESCs. Strong coordinated expression of all four RFs via adenoviral transduction may constrain stochastic processes and lead to silencing of genes important for cellular proliferation
Logic programming in the context of multiparadigm programming: the Oz experience
Oz is a multiparadigm language that supports logic programming as one of its
major paradigms. A multiparadigm language is designed to support different
programming paradigms (logic, functional, constraint, object-oriented,
sequential, concurrent, etc.) with equal ease. This article has two goals: to
give a tutorial of logic programming in Oz and to show how logic programming
fits naturally into the wider context of multiparadigm programming. Our
experience shows that there are two classes of problems, which we call
algorithmic and search problems, for which logic programming can help formulate
practical solutions. Algorithmic problems have known efficient algorithms.
Search problems do not have known efficient algorithms but can be solved with
search. The Oz support for logic programming targets these two problem classes
specifically, using the concepts needed for each. This is in contrast to the
Prolog approach, which targets both classes with one set of concepts, which
results in less than optimal support for each class. To explain the essential
difference between algorithmic and search programs, we define the Oz execution
model. This model subsumes both concurrent logic programming
(committed-choice-style) and search-based logic programming (Prolog-style).
Instead of Horn clause syntax, Oz has a simple, fully compositional,
higher-order syntax that accommodates the abilities of the language. We
conclude with lessons learned from this work, a brief history of Oz, and many
entry points into the Oz literature.Comment: 48 pages, to appear in the journal "Theory and Practice of Logic
Programming
Recommended from our members
Biocatalytic Synthesis of Stereospecific Triketide Lactones using Polyketide Synthases
Polyketide synthases are modular enzymes that create and modify large acyl chains. The domains and modules of polyketide synthases allow us to create molecules that resemble naturally occurring products by applying a biocatalytic in vitro in vivo approach to a diketide acyl chain. We showed that a triketide lactone of desired stereochemistry could be made using a domain and module from the polyketide synthase found in Saccharopolyspora erythraea, 6-Deoxyerythronolide B Synthase. Future projects will explore this approach using different domains and modules.Biochemistr
PORTA: A three-dimensional multilevel radiative transfer code for modeling the intensity and polarization of spectral lines with massively parallel computers
The interpretation of the intensity and polarization of the spectral line
radiation produced in the atmosphere of the Sun and of other stars requires
solving a radiative transfer problem that can be very complex, especially when
the main interest lies in modeling the spectral line polarization produced by
scattering processes and the Hanle and Zeeman effects. One of the difficulties
is that the plasma of a stellar atmosphere can be highly inhomogeneous and
dynamic, which implies the need to solve the non-equilibrium problem of the
generation and transfer of polarized radiation in realistic three-dimensional
(3D) stellar atmospheric models. Here we present PORTA, an efficient multilevel
radiative transfer code we have developed for the simulation of the spectral
line polarization caused by scattering processes and the Hanle and Zeeman
effects in 3D models of stellar atmospheres. The numerical method of solution
is based on the non-linear multigrid iterative method and on a novel
short-characteristics formal solver of the Stokes-vector transfer equation
which uses monotonic B\'ezier interpolation. Therefore, with PORTA the
computing time needed to obtain at each spatial grid point the self-consistent
values of the atomic density matrix (which quantifies the excitation state of
the atomic system) scales linearly with the total number of grid points.
Another crucial feature of PORTA is its parallelization strategy, which allows
us to speed up the numerical solution of complicated 3D problems by several
orders of magnitude with respect to sequential radiative transfer approaches,
given its excellent linear scaling with the number of available processors. The
PORTA code can also be conveniently applied to solve the simpler 3D radiative
transfer problem of unpolarized radiation in multilevel systems.Comment: 15 pages, 15 figures, to appear in Astronomy and Astrophysic
- …