180,494 research outputs found
Multiple views of control flows as a tool to improve programmer's understanding of interactive software
International audienceMy work addresses the question of how to improve programming notations and environments used for developing interactive systems. I focus on representing the control flow in interactive programs in the hope that it will improve the programmer?s ability to understand how their programs work. My thesis is that offering programmers the ability to create and manipulate multiple ad-hoc views of the control flow is the right way to go, where current programming languages and environment each choose one particular view
Flexible Language Interoperability
Virtual machines raise the abstraction level of the execution environment at the cost of restricting the set of supported languages. Moreover, the ability of a language implementation to integrate with other languages hosted on the same virtual machine typically constrains the features of the language. In this paper, we present a highly flexible yet efficient approach to hosting multiple programming languages on an objectoriented virtual machine. Our approach is based on extending the interface of each class with language-specific wrapper methods, offering each language a tailored view of a given class. This approach can be deployed both on a statically typed virtual machine, such as the JVM, and on a dynamic virtual machine, such as a Smalltalk virtual machine. We have implemented our approach to language interoperability on top of a prototype virtual machine for embedded systems based on the Smalltalk object model, which provides interoperability for embedded versions of the Smalltalk, Java, and BETA programming languages
Ranking programming languages by energy efficiency
This paper compares a large set of programming languages regarding their
efficiency, including from an energetic point-of-view. Indeed, we seek to establish
and analyze different rankings for programming languages based on their energy
efficiency. The goal of being able to rank languages with energy in mind is a
recent one, and certainly deserves further studies.
We have taken 19 solutions to well defined programming problems, expressed
in (up to) 27 programming languages, from well know repositories such as the
Computer Language Benchmark Game and Rosetta Code. We have also built a
framework to automatically, and systematically, run, measure and compare the
efficiency of such solutions. Ultimately, it is based on such comparison that we
propose a serious of efficiency rankings, based on multiple criteria.
Our results show interesting findings, such as, slower/faster languages consuming less/more energy, and how memory usage influences energy consumption. We also show how to use our results to provide software engineers support
to decide which language to use when energy efficiency is a concern(University of Porto) for the help that he
provided. This work is financed by the ERDF – European Regional Development
Fund through the Operational Programme for Competitiveness and Internationalisation - COMPETE 2020 Programme within project POCI-01-0145-FEDER-006961,
and by National Funds through the Portuguese funding agency, FCT - Funda¸c˜ao para a
Ciˆencia e a Tecnologia within project POCI-01-0145-FEDER-016718 and UID/EEA/50014/2013.
The first and second authors are also sponsored by FCT grants SFRH/BD/112733/2015
and SFRH/BD/132485/201
A Model-based transformation process to validate and implement high-integrity systems
Despite numerous advances, building High-Integrity Embedded systems remains a complex task. They come with strong requirements to ensure safety, schedulability or security properties; one needs to combine multiple analysis to validate each of them. Model-Based Engineering is an accepted solution to address such complexity: analytical models are derived from an abstraction of the system to be built. Yet, ensuring that all abstractions are semantically consistent, remains an issue, e.g. when performing model checking for assessing safety, and then for schedulability using timed automata, and then when generating code. Complexity stems from the high-level view of the model compared to the low-level mechanisms used. In this paper, we present our approach based on AADL and its behavioral annex to refine iteratively an architecture description. Both application and runtime components are transformed into basic AADL constructs which have a strict counterpart in classical programming languages or patterns for verification. We detail the benefits of this process to enhance analysis and code generation. This work has been integrated to the AADL-tool support OSATE2
A Comparison of OLAP and Coherence Large Scale Aggregations
The goal of the project is to develop a generic mechanism for cache-based aggregation of data. This will allow the end user to have a summary view with multiple pivot points. To achieve this goal, the following steps will be taken: 1. Converting the database to files 2. Loading the files into caches 3. Aggregating the data in the caches Coherence and aggregators will be used to complete these tasks. To write the code for these processes, Java, C# and SQL are the programming languages that will be used
A Comparison of OLAP and Coherence Large Scale Aggregations
The goal of the project is to develop a generic mechanism for cache-based aggregation of data. This will allow the end user to have a summary view with multiple pivot points. To achieve this goal, the following steps will be taken: 1. Converting the database to files 2. Loading the files into caches 3. Aggregating the data in the caches Coherence and aggregators will be used to complete these tasks. To write the code for these processes, Java, C# and SQL are the programming languages that will be used
Array operators using multiple dispatch: a design methodology for array implementations in dynamic languages
Arrays are such a rich and fundamental data type that they tend to be built
into a language, either in the compiler or in a large low-level library.
Defining this functionality at the user level instead provides greater
flexibility for application domains not envisioned by the language designer.
Only a few languages, such as C++ and Haskell, provide the necessary power to
define -dimensional arrays, but these systems rely on compile-time
abstraction, sacrificing some flexibility. In contrast, dynamic languages make
it straightforward for the user to define any behavior they might want, but at
the possible expense of performance.
As part of the Julia language project, we have developed an approach that
yields a novel trade-off between flexibility and compile-time analysis. The
core abstraction we use is multiple dispatch. We have come to believe that
while multiple dispatch has not been especially popular in most kinds of
programming, technical computing is its killer application. By expressing key
functions such as array indexing using multi-method signatures, a surprising
range of behaviors can be obtained, in a way that is both relatively easy to
write and amenable to compiler analysis. The compact factoring of concerns
provided by these methods makes it easier for user-defined types to behave
consistently with types in the standard library.Comment: 6 pages, 2 figures, workshop paper for the ARRAY '14 workshop, June
11, 2014, Edinburgh, United Kingdo
The role of concurrency in an evolutionary view of programming abstractions
In this paper we examine how concurrency has been embodied in mainstream
programming languages. In particular, we rely on the evolutionary talking
borrowed from biology to discuss major historical landmarks and crucial
concepts that shaped the development of programming languages. We examine the
general development process, occasionally deepening into some language, trying
to uncover evolutionary lineages related to specific programming traits. We
mainly focus on concurrency, discussing the different abstraction levels
involved in present-day concurrent programming and emphasizing the fact that
they correspond to different levels of explanation. We then comment on the role
of theoretical research on the quest for suitable programming abstractions,
recalling the importance of changing the working framework and the way of
looking every so often. This paper is not meant to be a survey of modern
mainstream programming languages: it would be very incomplete in that sense. It
aims instead at pointing out a number of remarks and connect them under an
evolutionary perspective, in order to grasp a unifying, but not simplistic,
view of the programming languages development process
- …