9,745 research outputs found
Julia: A Fresh Approach to Numerical Computing
Bridging cultures that have often been distant, Julia combines expertise from
the diverse fields of computer science and computational science to create a
new approach to numerical computing. Julia is designed to be easy and fast.
Julia questions notions generally held as "laws of nature" by practitioners of
numerical computing:
1. High-level dynamic programs have to be slow.
2. One must prototype in one language and then rewrite in another language
for speed or deployment, and
3. There are parts of a system for the programmer, and other parts best left
untouched as they are built by the experts.
We introduce the Julia programming language and its design --- a dance
between specialization and abstraction. Specialization allows for custom
treatment. Multiple dispatch, a technique from computer science, picks the
right algorithm for the right circumstance. Abstraction, what good computation
is really about, recognizes what remains the same after differences are
stripped away. Abstractions in mathematics are captured as code through another
technique from computer science, generic programming.
Julia shows that one can have machine performance without sacrificing human
convenience.Comment: 37 page
RTMPL: A structured programming and documentation utility for real-time multiprocessor simulations
The NASA Lewis Research Center is developing and evaluating experimental hardware and software systems to help meet future needs for real time simulations of air-breathing propulsion systems. The Real Time Multiprocessor Simulator (RTMPS) project is aimed at developing a prototype simulator system that uses multiple microprocessors to achieve the desired computing speed and accuracy at relatively low cost. Software utilities are being developed to provide engineering-level programming and interactive operation of the simulator. Two major software development efforts were undertaken in the RTMPS project. A real time multiprocessor operating system was developed to provide for interactive operation of the simulator. The second effort was aimed at developing a structured, high-level, engineering-oriented programming language and translator that would facilitate the programming of the simulator. The Real Time Multiprocessor Programming Language (RTMPL) allows the user to describe simulation tasks for each processor in a straight-forward, structured manner. The RTMPL utility acts as an assembly language programmer, translating the high-level simulation description into time-efficient assembly language code for the processors. The utility sets up all of the interfaces between the simulator hardware, firmware, and operating system
Recommended from our members
Extraordinary Emergencies: Reproducing Moral Discourses of the Child in Institutional Interaction
This report uses audio recorded telephone calls and textual data from an emergency medical services call center to examine the interactional practices through which speakers produce what we call “extraordinary emergencies”, treating the events concerned as requiring moral, as well as medical, attention. Since one of the overarching institutional aims of emergency call centers is to facilitate the efficient provision of medical services, call-takers typically treat reported emergencies as routine events. However, in some instances speakers produce practices that do not contribute toward the institutional agenda of providing medical assistance, thereby treating them as extraordinary cases. These practices occurred recurrently in calls involving reports of emergencies relating to child sexuality, including sexual assaults against children and obstetric emergencies where the mother was particularly young. We discuss the implications of these findings for the situated reproduction of particular moral norms, especially with respect to the category of the child in society
Using Actor Network Theory to Interpret the Introduction of Information Systems within the London Ambulance Service
This paper presents a comparative analysis of two attempts to computerize the dispatch system (known as CAD) for the London Ambulance Service (LAS). These two cases are relatively well known and the first attempt has been characterized as a „failure‟ and the second as a „success‟. However, this analysis focuses on the human elements and uses Actor Network Theory (ANT) as the comparative interpretive framework to draw insights from the two cases. The ANT analyses focus on the role of the chief executive (CE) in each case, and how well they were able to mobilize the relevant groups involved in the CAD development and implementation. Both cases involved conflict between management and workforce aimed at changing peoples‟ working practices and processes, organizational politics, industrial relationships and the CAD development. The concepts of the successful and unsuccessful problem solving actor networks are developed as a means of appreciating the complexities, comparability and differences of these scenarios. Lessons learned from the comparative experience of the LAS cases provide insights into organizational turnaround, with success attributed to actively integrating IS and business development based on effective problem solving
MultiJava: Design Rationale, Compiler Implementation, and Applications
MultiJava is a conservative extension of the Java programming language that adds symmetric multiple dispatch and open classes. Among other benefits, multiple dispatch provides a solution to the binary method problem. Open classes provide a solution to the extensibility problem of object-oriented programming languages, allowing the modular addition of both new types and new operations to an existing type hierarchy. This paper illustrates and motivates the design of MultiJava and describes its modular static typechecking and modular compilation strategies. Although MultiJava extends Java, the key ideas of the language design are applicable to other object-oriented languages, such as C# and C++, and even, with some modifications, to functional languages such as ML. This paper also discusses the variety of application domains in which MultiJava has been successfully used by others, including pervasive computing, graphical user interfaces, and compilers. MultiJava allows users to express desired programming idioms in a way that is declarative and supports static typechecking, in contrast to the tedious and type-unsafe workarounds required in Java. MultiJava also provides opportunities for new kinds of extensibility that are not easily available in Java
An Optimizing Java Translation Framework for Automated Checkpointing and Strong Mobility
Long-running programs, e.g., in high-performance computing, need to
write periodic checkpoints of their execution state to disk to allow
them to recover from node failure. Manually adding checkpointing code
to an application, however, is very tedious. The mechanisms needed
for writing the execution state of a program to disk and restoring it
are similar to those needed for migrating a running thread or a mobile
object. We have extended a source-to-source translation scheme that
allows the migration of mobile Java objects with running threads to
make it more general and allow it to be used for automated
checkpointing. Our translation scheme allows serializable threads to
be written to disk or migrated with a mobile agent to a remote
machine. The translator generates code that maintains a serializable
run-time stack for each thread as a Java data structure. While this
results in significant run-time overhead, it allows the checkpointing
code to be generated automatically. We improved the locking mechanism
that is needed to protect the run-time stack as well as the translation
scheme. Our experimental results demonstrate an speedup of the
generated code over the original translator and show that the approach
is feasible in practice
Julia: A Fresh Approach to Numerical Computing
Bridging cultures that have often been distant, Julia combines expertise from the diverse fields of computer science and computational science to create a new approach to numerical computing. Julia is designed to be easy and fast and questions notions generally held to be “laws of nature" by practitioners of numerical computing: \beginlist \item High-level dynamic programs have to be slow. \item One must prototype in one language and then rewrite in another language for speed or deployment. \item There are parts of a system appropriate for the programmer, and other parts that are best left untouched as they have been built by the experts. \endlist We introduce the Julia programming language and its design---a dance between specialization and abstraction. Specialization allows for custom treatment. Multiple dispatch, a technique from computer science, picks the right algorithm for the right circumstance. Abstraction, which is what good computation is really about, recognizes what remains the same after differences are stripped away. Abstractions in mathematics are captured as code through another technique from computer science, generic programming. Julia shows that one can achieve machine performance without sacrificing human convenience.National Science Foundation (U.S.) (CCF-0832997)National Science Foundation (U.S.) (DMS-1016125)National Science Foundation (U.S.) (DMS-1312831
QL: Object-oriented Queries on Relational Data
This paper describes QL, a language for querying complex, potentially recursive data structures. QL compiles to Datalog and runs on a standard relational database, yet it provides familiar-looking object-oriented features such as classes and methods, reinterpreted in logical terms: classes are logical properties describing sets of values, subclassing is implication, and virtual calls are dispatched dynamically by considering the most specific classes containing the receiver. Furthermore, types in QL are prescriptive and actively influence program evaluation rather than just describing it. In combination, these features enable the development of concise queries based on reusable libraries, which are written in a purely declarative style, yet can be efficiently executed even on very large data sets. In particular, we have used QL to implement static analyses for various programming languages, which scale to millions of lines of code
- …