149,587 research outputs found
Object-Oriented Implementation of the NAS Parallel Benchmarks using Charm++
This report describes experiences with implementing the NAS Computational Fluid Dynamics benchmarks using a parallel object-oriented language, Charm++. Our main objective in implementing the NAS CFD kernel benchmarks was to develop a code that could be used to easily experiment with different domain decomposition strategies and dynamic load balancing. We also wished to leverage the object-orientation provided by the Charm++ parallel object-oriented language, to develop reusable abstractions that would simplify the process of developing parallel applications. We first describe the Charm++ parallel programming model and the parallel object array abstraction, then go into detail about each of the Scalar Pentadiagonal (SP) and Lower/Upper Triangular (LU) benchmarks, along with performance results. Finally we conclude with an evaluation of the methodology used
Life of occam-Pi
This paper considers some questions prompted by a brief review of the history of computing. Why is programming so hard? Why is concurrency considered an “advanced” subject? What’s the matter with Objects? Where did all the Maths go? In searching for answers, the paper looks at some concerns over fundamental ideas within object orientation (as represented by modern programming languages), before focussing on the concurrency model of communicating processes and its particular expression in the occam family of languages. In that focus, it looks at the history of occam, its underlying philosophy (Ockham’s Razor), its semantic foundation on Hoare’s CSP, its principles of process oriented design and its development over almost three decades into occam-? (which blends in the concurrency dynamics of Milner’s ?-calculus). Also presented will be an urgent need for rationalisation – occam-? is an experiment that has demonstrated significant results, but now needs time to be spent on careful review and implementing the conclusions of that review. Finally, the future is considered. In particular, is there a future
Machine Translation from Natural Language to Code using Long-Short Term Memory
Making computer programming language more understandable and easy for the
human is a longstanding problem. From assembly language to present day's
object-oriented programming, concepts came to make programming easier so that a
programmer can focus on the logic and the architecture rather than the code and
language itself. To go a step further in this journey of removing
human-computer language barrier, this paper proposes machine learning approach
using Recurrent Neural Network (RNN) and Long-Short Term Memory (LSTM) to
convert human language into programming language code. The programmer will
write expressions for codes in layman's language, and the machine learning
model will translate it to the targeted programming language. The proposed
approach yields result with 74.40% accuracy. This can be further improved by
incorporating additional techniques, which are also discussed in this paper.Comment: 8 pages, 3 figures, conferenc
Object-Oriented Programming semantics representation utilizing agents
Comprehending Object-Oriented Programming (OOP) is not an easy task especially by novice students. The problem occurs during the transition from learning fundamental programming language concept to OOP concept. It is very important to handle this problem from the beginning before novices learn more advanced OOP concepts like encapsulation, inheritance, and polymorphism. Learning programming from source code examples is a common behavior among novices. Novices tend to refer to source codes examples and adapt the source codes to the problem given in their assignments. To cater the problems faced by these novices, a novel agent-based model have been designed to assist them in comprehending OOP concepts through source codes examples. The instructor needs to provide two related source codes that are similar but in different domain. Generally, these source codes go through the preprocessing, comparison, extraction, generate program semantics and classification processes. A formal algorithm that can be applied to any two related Java-based source codes examples is invented to generate the semantics of these source codes. The algorithm requires source codes comparison based on keyword similarity to extract the words that exist in the two related source codes. Three agents namely SemanticAgentGUI, semanticAgent and noviceAgent are designed in the proposed model. The running system shows an OOP semantic knowledge representation by intelligent agents
Efficient and Reasonable Object-Oriented Concurrency
Making threaded programs safe and easy to reason about is one of the chief
difficulties in modern programming. This work provides an efficient execution
model for SCOOP, a concurrency approach that provides not only data race
freedom but also pre/postcondition reasoning guarantees between threads. The
extensions we propose influence both the underlying semantics to increase the
amount of concurrent execution that is possible, exclude certain classes of
deadlocks, and enable greater performance. These extensions are used as the
basis an efficient runtime and optimization pass that improve performance 15x
over a baseline implementation. This new implementation of SCOOP is also 2x
faster than other well-known safe concurrent languages. The measurements are
based on both coordination-intensive and data-manipulation-intensive benchmarks
designed to offer a mixture of workloads.Comment: Proceedings of the 10th Joint Meeting of the European Software
Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of
Software Engineering (ESEC/FSE '15). ACM, 201
Object-oriented modelling with unified modelling language 2.0 for simple software application based on agile methodology
Unified modelling language (UML) 2.0 introduced in 2002 has been developing
and influencing object-oriented software engineering and has become a standard
and reference for information system analysis and design modelling. There are
many concepts and theories to model the information system or software
application with UML 2.0, which can make ambiguities and inconsistencies for a
novice to learn to how to model the system with UML especially with UML 2.0.
This article will discuss how to model the simple software application by using
some of the diagrams of UML 2.0 and not by using the whole diagrams as
suggested by agile methodology. Agile methodology is considered as convenient
for novices because it can deliver the information technology environment to
the end-user quickly and adaptively with minimal documentation. It also has the
ability to deliver best performance software application according to the
customer's needs. Agile methodology will make simple model with simple
documentation, simple team and simple tools.Comment: 15 pages, 30 figure
- …