713 research outputs found
Virtual Machine Support for Many-Core Architectures: Decoupling Abstract from Concrete Concurrency Models
The upcoming many-core architectures require software developers to exploit
concurrency to utilize available computational power. Today's high-level
language virtual machines (VMs), which are a cornerstone of software
development, do not provide sufficient abstraction for concurrency concepts. We
analyze concrete and abstract concurrency models and identify the challenges
they impose for VMs. To provide sufficient concurrency support in VMs, we
propose to integrate concurrency operations into VM instruction sets.
Since there will always be VMs optimized for special purposes, our goal is to
develop a methodology to design instruction sets with concurrency support.
Therefore, we also propose a list of trade-offs that have to be investigated to
advise the design of such instruction sets.
As a first experiment, we implemented one instruction set extension for
shared memory and one for non-shared memory concurrency. From our experimental
results, we derived a list of requirements for a full-grown experimental
environment for further research
Management implications of moving from a traditional structured systems development methodology to object-orientation
Thesis (M.S.) University of Alaska Fairbanks, 2003As software application systems become larger and more complex, many software employers and managers believe that the key to sustaining its competitive advantage in the computing technology market lies in its software engineering capabilities. Software crisis situation seems to be a common occurrence in the software development environment as systems become larger and more complex. Object Orientation (OO) has been proposed as a viable alternative to traditional approach (i.e., structured techniques), an approach that many hope will solve the current software crisis. 00 is a new paradigm, and it requires new types of knowledge, new specialists, and significant changes in the mindset, an entirely different way of thinking, representing and solving a problem. The transition of moving toward the 00 from the traditional approach may involve a high risk of failure if the managers do not understand the nature of paradigm shifts and do not anticipate the future. The problem of moving to 00 has become very important. An understanding of potential problems from migrating to the new paradigm helps managers make a smoother paradigm shift. The implications and challenges of the 00 paradigm are presented. The study suggests that Object-Oriented System Development (OOSD) requires more discipline, management and training than traditional software development does. Education and experience are keys for the success of any OOSD project
PLOMO Associate Team Final Report
The goal of Plomo is to develop new meta tools to improve and bring synergy in the existing infrastructure of Pharo1 (for software development) and the Moose software analysis platform2 (for maintenance). PLOMO will (i) enhance the Opal open compiler infrastructure to support plugin definition, (ii) offer an infrastructure for change and event tracking as well as models to compose and manipulate them, (iii) work on a layered library of algorithms for the Mondrian visualization engine of Moose, (iv) work on new ways of profiling applications. All the efforts will be performed on Pharo and Moose, two platforms heavily used by the RMoD and Pleiad teams
Graphical Programming of Simulation Models in an Object-Oriented Environment
Graphical programming has been used in conjunction with
conventional simulation languages via block diagrams or activity
networks. Its beneficial effects on programming and modeling in
simulation have been accepted by everyone involved in these
languages. However, none of these conventional techniques is
truely interactive. Given the level of the current hardware and
software technology, it is possible to design a very good
graphical programming system which supports an interactive
incremental programming style in specifications of simulation
models. The benefit of such a visual system would go beyond the
modeling phase of a simulation study and it might as well be
realized in understanding the behavior of complex problems, in
being a communication and training medium for the user and
developers, and finally in presenting the simulation results.
In this study, the graphical programming methodology has
been investigated from the perspective of object-oriented
simulation. The truely interactive and graphical orientation of
some of the object-oriented languages (e.g., Smalltalk-80) has
opened up new avenues of research in this very important topic.
Today, the nature of this type of research will be not whether it can be done but how the known techniques should be combined to yield the highest benefit
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
A Programming Environment Evaluation Methodology for Object-Oriented Systems
The object-oriented design strategy as both a problem decomposition and system development paradigm has made impressive inroads into the various areas of the computing sciences. Substantial development productivity improvements have been demonstrated in areas ranging from artificial intelligence to user interface design. However, there has been very little progress in the formal characterization of these productivity improvements and in the identification of the underlying cognitive mechanisms. The development and validation of models and metrics of this sort require large amounts of systematically-gathered structural and productivity data. There has, however, been a notable lack of systematically-gathered information on these development environments. A large part of this problem is attributable to the lack of a systematic programming environment evaluation methodology that is appropriate to the evaluation of object-oriented systems
The 14th Overture Workshop: Towards Analytical Tool Chains
This report contains the proceedings from the 14th Overture workshop organized in connection with the Formal Methods 2016 symposium. This includes nine papers describing different technological progress in relation to the Overture/VDM tool support and its connection with other tools such as Crescendo, Symphony, INTO-CPS, TASTE and ViennaTalk
Annotated bibliography of software engineering laboratory literature
An annotated bibliography of technical papers, documents, and memorandums produced by or related to the Software Engineering Laboratory is given. More than 100 publications are summarized. These publications cover many areas of software engineering and range from research reports to software documentation. This document has been updated and reorganized substantially since the original version (SEL-82-006, November 1982). All materials have been grouped into eight general subject areas for easy reference: the Software Engineering Laboratory; the Software Engineering Laboratory-software development documents; software tools; software models; software measurement; technology evaluations; Ada technology; and data collection. Subject and author indexes further classify these documents by specific topic and individual author
- …