Yang, Ye; Liu, Juan
We developed a program JVM (Java Visual Mapping) for mapping next generation sequencing read to reference sequence. The program is implemented in Java and is designed to deal with millions of short read generated by sequence alignment using the Illumina sequencing technology. It employs seed index strategy and octal encoding operations for sequence alignments. JVM is useful for DNA-Seq, RNA-Seq when dealing with single-end resequencing. JVM is a desktop application, which supports reads capacity from 1 MB to 10 GB.
to prevent catastrophic failures from reaching the production environment. We will show how we have leveraged Geb -- a browser automation tool built on top of Selenium -- to develop a full suite of smoke tests for CERN's Electronic Document Handling (EDH) system -- a large web application with over 1 million lines of Java code, in production since 1998. Though the tool is aimed for use on the JVM, the concepts that will be presented can be applied in other languages that have wrappers for Selenium. In particular, patterns that can be used to better describe and structure functional/smoke tests, as well as how to integrate these tests with continuous integration systems, such as Atlassian Bamboo, using headless browsers (e.g. PhantomJS) or virtual frame buffers.
Full Text Available Employing the Java virtual machine (JVM architecture provides smart phone systems stability and security by sandboxing third-party applications and controlling their behavior. However, the JVM layer hinders applications from notifying the operating system scheduler about their timeliness requirements; therefore, applications sometimes fail to respond on time. In order to improve the responsiveness of smart phone applications, this paper proposes two schemes. First, for existing applications that cannot be rebuilt, we modify the kernel scheduler to value task priorities over fairness. Second, we propose cross-layer real-time support APIs to deliver applications' priorities to the kernel scheduler, which will help developers to add real-time scheduling support to their applications. Our prototype demonstrates that the suggested schemes dramatically improve response times and throughputs of prioritized applications.
This project aim is to create a Content Marketing Strategy for a Finnish logistics company. The aim of the thesis is to develop an action plan that will help the commissioning company increase sales and gain new customers. The commissioner for the study is NetLogistic JVM Oy. The Company specializes in handling trade of transit and export shipments to Russia and CIS-countries via Finland. The company does not have huge resources to run large campaign, but is looking for ways to reach new...
Nikita Kamble; Vaishnavi Patil; Shweta Desai; Dhanashri Kasar; Mrunali Patil
Computer technology has rapidly grown over past decades. Most of this can be attributed to the Internet as many computers now have a need to be networked together to establish an online connection. A local area network is a group of computers and associated devices that share a common communication line or wireless link to the service. Typically a LAN compasses computers and peripherals connected to a secure server within a small geographic area such as an office building or home computer and...
Full Text Available Computer technology has rapidly grown over past decades. Most of this can be attributed to the Internet as many computers now have a need to be networked together to establish an online connection. A local area network is a group of computers and associated devices that share a common communication line or wireless link to the service. Typically a LAN compasses computers and peripherals connected to a secure server within a small geographic area such as an office building or home computer and other mobile devices that share resources such as printer or network storage. A LAN is contrasted in principle to a wide area networkWANwhich covers a larger geographic distance and may involve leased telecom circuits while the media for LANs are locally managed. Ethernet are twisted pair cabling amp Wi-Fi are the two most common transmission technologies in use for LAN. The rise of virtualization has fueled the development of virtual LANWLANwhich allows network administrator to logically group network nodes amp partition their networks without the need for major infrastructure changes. In some situations a wireless LAN or Wi-Fi maybe preferable to a wired LAN because of its flexibility amp cost. Companies are asserting WLANs as a replacement for their wired infrastructure as the number of smart phones tablets amp other mobile devices proliferates.
Full Text Available The motivation for our research starts from the common belief that the Java platform is not suitable for implementing ultra-high performance applications. Java is one of the most widely used software development platform in the world, and it provides the means for rapid development of robust and complex applications that are easy to extend, ensuring short time-to-market of initial deliveries and throughout the lifetime of the system. The Java runtime environment, and especially the Java Virtual Machine, on top of which applications are executed, is the principal source of concerns in regards to its suitability in the electronic trading environment, mainly because of its implicit memory management. In this paper, we intend to identify some of the most common measures that can be taken, both at the Java runtime environment level and at the application architecture level, which can help Java applications achieve ultra-high performance. We also propose two efficient architectures for exchange trading systems that allow for ultra-low latencies and high throughput.
M.J. Steindorfer (Michael); J.J. Vinju (Jurgen)
textabstractThe data structures under-pinning collection API (e.g. lists, sets, maps) in the standard libraries of programming languages are used intensively in many applications. The standard libraries of recent Java Virtual Machine languages, such as Clojure or Scala, contain scalable and
M.J. Steindorfer (Michael); J.J. Vinju (Jurgen)
textabstractAn immutable multi-map is a many-to-many thread-friendly map data structure with expected fast insert and lookup operations. This data structure is used for applications processing graphs or many-to-many relations as applied in static analysis of object-oriented systems. When
Steindorfer, Michael J.; Vinju, Jurgen J.
textabstractAn immutable multi-map is a many-to-many thread-friendly map data structure with expected fast insert and lookup operations. This data structure is used for applications processing graphs or many-to-many relations as applied in static analysis of object-oriented systems. When processing such big data sets the memory overhead of the data structure encoding itself is a memory usage bottleneck. Motivated by reuse and type-safety, libraries for Java, Scala and Clojure typically implem...
Gal, Andreas; Probst, Christian; Franz, Michael
We have implemented a virtual execution environment that executes legacy binary code on top of the type-safe Java Virtual Machine by recompiling native code instructions to type-safe bytecode. As it is essentially impossible to infer static typing into untyped machine code, our system emulates...... untyped memory on top of Java’s type system. While this approach allows to execute native code on any off-the-shelf JVM, the resulting runtime performance is poor. We propose a set of virtual machine extensions that add type-unsafe memory objects to JVM. We contend that these JVM extensions do not relax...... Java’s type system as the same functionality can be achieved in pure Java, albeit much less efficiently....
Learn how to be more productive with Scala, a new multi-paradigm language for the Java Virtual Machine (JVM) that integrates features of both object-oriented and functional programming. With this book, you'll discover why Scala is ideal for highly scalable, component-based applications that support concurrency and distribution. Programming Scala clearly explains the advantages of Scala as a JVM language. You'll learn how to leverage the wealth of Java class libraries to meet the practical needs of enterprise and Internet projects more easily. Packed with code examples, this book provides us
Luckow, Kasper Søe; Thomsen, Bent; Frost, Christian
We present a novel tool for statically determining the Worst Case Execution Time (WCET) of Java Bytecode-based programs called Tool for Execution Time Analysis of Java bytecode (TetaJ). This tool differentiates itself from existing tools by separating the individual constituents of the execution...... environment into independent components. The prime benefit is that it can be used for execution environments featuring common embedded processors and software implementations of the JVM. TetaJ employs a model checking approach for statically determining WCET where the Java program, the JVM, and the hardware...
Gal, Andreas; Probst, Christian W.; Franz, Michael
Java Virtual Machines (JVMs) traditionally perform bytecode verification by way of an iterative data-flow analysis. Bytecode verification is necessary to ensure type safety because temporary variables in the JVM are not statically typed. We present an alternative verification mechanism that trans......Java Virtual Machines (JVMs) traditionally perform bytecode verification by way of an iterative data-flow analysis. Bytecode verification is necessary to ensure type safety because temporary variables in the JVM are not statically typed. We present an alternative verification mechanism...
All patients had general anaesthesia and were operated on by the same vascular surgeon (JvM). All patients were evaluated preoperatively by an experienced sonographer. Cerebral monitoring during carotid endarterectomy – a comparison between electroencephalography, transcranial cerebral oximetry and carotid ...
This thesis proposes novel and efficient data structures, suitable for immutable collection libraries, that carefully balance memory footprint and runtime performance of operations, and are aware of constraints and platform co-design challenges on the Java Virtual Machine (JVM). Collection data
We propose a typesafe abstraction to tensors (i.e. multidimensional arrays) exploiting the type-level programming capabilities of Scala through heterogeneous lists (HList), and showcase typesafe abstractions of common tensor operations and various neural layers such as convolution or recurrent neural networks. This abstraction could lay the foundation of future typesafe deep learning frameworks that runs on Scala/JVM.
Hilderink, G.H.; Broenink, Johannes F.; Bakkers, André
The Java ™ Virtual Machine (JVM) provides a high degree of platform independence, but being an interpreter, Java has a poor system performance. New compiler techniques and Java processors will gradually improve the performance of Java, but despite these developments, Java is still far from
Geoffray, Nicolas; Thomas, Gaël; Lawall, Julia
Managed Runtime Environments (MREs), such as the JVM and the CLI, form an attractive environment for program execution, by providing portability and safety, via the use of a bytecode language and automatic memory management, as well as good performance, via just-in-time (JIT) compilation. Neverth...
Sharp, D. C.; Pla, E.; Luecke, K. R.; Hassan, R. J.
This paper describes benchmarking results on an RT JVM. This paper extends previously published results by including additional tests, by being run on a recently available pre-release version of the first commercially supported RTSJ implementation, and by assessing results based on our experience with avionics systems in other languages.
VME processors under VxWorks, a real time operating system, manage the fieldbus, concentrate the accelerator information and transmit it to the supervisory software through the ethernet network. This software consists of a collection of Java virtual machines (JVM) running on several Unix work-stations and PCs under ...
Schoeberl, Martin; Korsholm, Stephan; Kalibera, Tomas
Embedded systems use specialized hardware devices to interact with their environment, and since they have to be dependable, it is attractive to use a modern, type-safe programming language like Java to develop programs for them. Standard Java, as a platform-independent language, delegates access...... to devices, direct memory access, and interrupt handling to some underlying operating system or kernel, but in the embedded systems domain resources are scarce and a Java Virtual Machine (JVM) without an underlying middleware is an attractive architecture. The contribution of this article is a proposal...... for Java packages with hardware objects and interrupt handlers that interface to such a JVM. We provide implementations of the proposal directly in hardware, as extensions of standard interpreters, and finally with an operating system middleware. The latter solution is mainly seen as a migration path...
Schoeberl, Martin; Thalinger, Christian; Korsholm, Stephan
Java, as a safe and platform independent language, avoids access to low-level I/O devices or direct memory access. In standard Java, low-level I/O it not a concern; it is handled by the operating system. However, in the embedded domain resources are scarce and a Java virtual machine (JVM) without...... an underlying middleware is an attractive architecture. When running the JVM on bare metal, we need access to I/O devices from Java; therefore we investigate a safe and efficient mechanism to represent I/O devices as first class Java objects, where device registers are represented by object fields. Access...... to those registers is safe as Java’s type system regulates it. The access is also fast as it is directly performed by the bytecodes getfield and putfield. Hardware objects thus provide an object-oriented abstraction of low-level hardware devices. As a proof of concept, we have implemented hardware objects...
Wickstrom, Gregory Lloyd; Winter, Victor Lono (University of Nebraska at Omaha, Omaha, NE); Fraij, Fares (University of Texas at El Paso, El Paso, TX); Roach, Steve (University of Texas at El Paso, El Paso, TX); Beranek, Jason (University of Nebraska at Omaha, Omaha, NE)
The SSP is a hardware implementation of a subset of the JVM for use in high consequence embedded applications. In this context, a majority of the activities belonging to class loading, as it is defined in the specification of the JVM, can be performed statically. Static class loading has the net result of dramatically simplifying the design of the SSP as well as increasing its performance. Due to the high consequence nature of its applications, strong evidence must be provided that all aspects of the SSP have been implemented correctly. This includes the class loader. This article explores the possibility of formally verifying a class loader for the SSP implemented in the strategic programming language TL. Specifically, an implementation of the core activities of an abstract class loader is presented and its verification in ACL2 is considered.
When connecting together heterogeneous and complex systems, it is not easy to exchange data between components. Streams of data are successfully used in industry in order to overcome this problem, especially in the case of "live" data. Streams are a specialization of the Observer design pattern and they provide asynchronous and non-blocking data flow. The ongoing effort of the ReactiveX initiative is one example that demonstrates how demanding this technology is even for big companies. Bridging the discrepancies of different technologies with common interfaces is already done by the Reactive Streams initiative and, in the JVM world, via reactive-streams-jvm interfaces. Streaming Pool is a framework for providing and discovering reactive streams. Through the mechanism of dependency injection provided by the Spring Framework, Streaming Pool provides a so called Discovery Service. This object can discover and chain streams of data that are technologically agnostic, through the use of Stream IDs. The stream to ...
Luckow, Kasper Søe; Thomsen, Bent; Korsholm, Stephan Erbs
We present HVMTIME; a portable and time predictable JVM implementation with applications in resource-constrained hard real-time embedded systems. In addition, it implements the Safety Critical Java (SCJ) Level 1 specification. Time predictability is achieved by a combination of time predictable...... algorithms, exploiting the programming model of the SCJ specification, and harnessing static knowledge of the hosted SCJ system. This paper presents HVMTIME in terms of its design and capabilities, and demonstrates how a complete timing model of the JVM represented as a Network of Timed Automata can...... be obtained using the tool TetaSARTSJVM. Further, using the timing model, we derive Worst Case Execution Times (WCETs) and Best Case Execution Times (BCETs) of the Java Bytecodes....
science IT information technology JBOD just a bunch of disks JDBC java database connectivity xviii JPME Joint Professional Military Education JSO...Joint Service Officer JVM java virtual machine MPP massively parallel processing MPTE Manpower, Personnel, Training, and Education NAVMAC Navy...27 external database, whether it is MySQL , Oracle, DB2, or SQL Server (Teller, 2015). Connectors optimize the data transfer by obtaining metadata
Halli , Nassim; Charles , Henri-Pierre; Méhaut , Jean-François
International audience; General purpose CPUs used in high performance computing (HPC) support a vector instruction set and an out-of-order engine dedicated to increase the instruction level parallelism. Hence, related optimizations are currently critical to improve the performance of applications requiring numerical computation. Moreover, the use of a Java run-time environment such as the HotSpot Java Virtual Machine (JVM) in high performance computing is a promising alternative. It benefits ...
Voltan, Rebecca; Rimondi, Erika; Melloni, Elisabetta; Rigolin, Gian Matteo; Casciano, Fabio; Arcidiacono, Maria Vittoria; Celeghini, Claudio; Cuneo, Antonio; Zauli, Giorgio; Secchiero, Paola
The aim of this study was to investigate the anti-leukemic activity of the Bruton tyrosine kinase inhibitor Ibrutinib in combination with the small molecule MDM-2 inhibitor Nutlin-3 in preclinical models. The potential efficacy of the Ibrutinib/Nutlin-3 combination was evaluated in vitro in a panel of B leukemic cell lines (EHEB, JVM-2, JVM-3, MEC-1, MEC-2) and in primary B-chronic lymphocytic leukemia (B-CLL) patient samples, by assessing cell viability, cell cycle profile, apoptosis and intracellular pathway modulations. Validation of the combination therapy was assessed in a B leukemic xenograft mouse model. Ibrutinib exhibited variable anti-leukemic activity in vitro and the combination with Nutlin-3 synergistically enhanced the induction of apoptosis independently from the p53 status. Indeed, the Ibrutinib/Nutlin-3 combination was effective in promoting cytotoxicity also in primary B-CLL samples carrying 17p13 deletion and/or TP53 mutations, already in therapy with Ibrutinib. Molecular analyses performed on both B-leukemic cell lines as well as on primary B-CLL samples, while confirming the switch-off of the MAPK and PI3K pro-survival pathways by Ibrutinib, indicated that the synergism of action with Nutlin-3 was independent by p53 pathway and was accompanied by the activation of the DNA damage cascade signaling through the phosphorylation of the histone protein H2A.X. This observation was confirmed also in the JVM-2 B leukemic xenograft mouse model. Taken together, our data emphasize that the Ibrutinib/Nutlin-3 combination merits to be further evaluated as a therapeutic option for B-CLL.
The objective of the thesis was to implement or modify an existing Java virtual machine (JVM) in a way that it will allow insight into statistics of the executed Java instructions of an executed user program. The functionality will allow analysis of the algorithms in Java environment. After studying the theory of Java and Java virtual machine, we decided to modify an existing Java virtual machine. We chose JamVM which is a lightweight, open-source Java virtual machine under GNU license. The i...
Pilgrim, Peter A
Java EE 7 Handbook is an example based tutorial with descriptions and explanations.""Java EE 7 Handbook"" is for the developer, designer, and architect aiming to get acquainted with the Java EE platform in its newest edition. This guide will enhance your knowledge about the Java EE 7 platform. Whether you are a long-term Java EE (J2EE) developer or an intermediate level engineer on the JVM with just Java SE behind you, this handbook is for you, the new contemporary Java EE 7 developer!
Cuadrado, Daniel Lázaro; Ravn, Anders Peter; Koch, Peter
The purpose of the Distributed-SDF domain for Ptolemy II is to allow distributed simulation of SDF models. It builds on top of the existing SDF domain by extending it. From the user’s point of view, using the Distributed-SDF director is sufficient to run the distributed version. It provides optio...... distributed nature. First of all, known memory bounds of the JVM can be overcome. Second, it yields smaller simulation times, mainly for models with high degree of parallelism and granularity....
Luciana Souza Borges
Full Text Available Investigamos os juízos de representação da realidade (JRR e de valor moral (JVM de 20 homens homicidas (30 a 49 anos, acerca da razão do crime, à época do homicídio e no momento atual. Realizamos entrevistas individuais e verificamos que: o JRR mais apontado, no presente e no passado, foi a agressão física sofrida, justificada no presente principalmente pelo fato de o agressor ter-se sentido humilhado e, no passado, pelo fato de ter querido vingar-se e pelas características próprias, dele ou da vítima; o JVM mais mencionado no passado foi o de que as razões estavam certas, devido a características dos entrevistados ou das vítimas, pelas humilhações sofridas ou porque precisavam defender uma vida, ao passo que no presente o juízo mais citado pelos entrevistados foi o de que estavam errados os motivos, em face das conseqüências negativas do crime para eles e dos argumentos religiosos.We investigated the judgment of representation of reality (JRR, and the judgment of moral value (JVM of 20 homicidal subjects (30 to 49 as to the reasons of the crime, at the time of the homicide and at the present moment. Individual interviews were carried out. We verified that the most indicated JRR, in the present and in the past, was the physical aggression suffered by the aggressor, justified in the present because the aggressor felt humiliated and, in the past, for having wished to take revenge due to his or the victim's characteristics; the most mentioned JVM in the past was that that their reasons were right due to the characteristics of the interviewees or those of the victims, for the humiliations suffered or because they needed to defend a life, whereas in the present, the most cited judgment was that their motives were wrong, in face of the negative consequences, and religious arguments.
X4Cro 7WAW,"G9 N k Y,1i ACCA . 2 JVM ly y,- L OA.0 v roo*Ler t-OAD. FA’ A /"Fi./A/a. (" -A,E’ CNAiv*6:CP A/ ’r/O’,L C4A$4P&4R.* -1MAGC.T?D0 VI.3 Moon...M- S 3D = .. = ==-=== Version 1.1 02/01/85 LTHD muzzle brate thermal load - steel Load Case 1: Loads Node F x FFM - My
Schaefer, Ralf; Finger, Ulrich
In this paper, we present an implementation of an MPEG-4 decoder using Java for dynamic processing, i.e. providing flexibility and extensibility. The advantage of Java is its platform independent paradigm using a virtual machine. This enables us to provide downloading of tools and also dynamic configuration of already downloaded tools. However, the disadvantage of Java is its low performance. Therefore we propose a hybrid implemented approach using Java implementations only for flexibility and extensibility. All the rest of the decoder is implemented in native code, providing the high performance necessary for real time issues. We use Java only where Java is necessary. To integrate Java with the native code implementations we utilize the Java native interface (JNI). We use the JNI to create an instance of the Java virtual machine (JVM) in the running MPEG-4 application. This JVM instance handles all Java decoder tool implementations as well as incoming Java bit streams. All the other data streams are handled by the native implemented part.
Michel, Georg, E-mail: email@example.com; Sachtleben, Juergen
The ECRH system of W7-X is composed of 10 independent gyrotron modules. Each module consists of one gyrotron and its peripherals such as power supplies, cooling plants and distributed PLC systems. The fast real-time control functions such as the timing of the two high voltage supplies, trigger pulses, protection, modulation and communication with the central control of W7-X, is implemented in an integrated controller which is described in this paper. As long-term maintainability and sustainability are important for nuclear fusion experiments, the choice fell on an FPGA-based design which is exclusively based on free (as in 'freedom') software and configuration code. The core of the controller consists of a real-time Java virtual machine (JVM) that provides the TCP-IP connectivity as well as more complicated control functions, and which interacts with the gyrotron-specific hardware. Both the gyrotron-specific hardware and the JVM are implemented on the same FPGA, which is the main component of the controller. All 10 controllers are currently completed and operational. All parameters and functions are accessible via Ethernet. Due to the open, FPGA-based design, most hardware modifications can be made via the network as well. This paper discusses the capabilities of the controllers and their integration into the central W7-X control.
Batool, N.; Huqqani, A.A.; Mahmood, A.
Image processing applications requirements can be best met by using the distributed environment. This report presents to draw inferences by utilizing the existed LAN resources under the distributed computing environment using Java and web technology for extensive processing to make it truly system independent. Although the environment has been tested using image processing applications, its design and architecture is truly general and modular so that it can be used for other applications as well, which require distributed processing. Images originating from server are fed to the workers along with the desired operations to be performed on them. The Server distributes the task among the Workers who carry out the required operations and send back the results. This application has been implemented using the Remote Method Invocation (RMl) feature of Java. Java RMI allows an object running in one Java Virtual Machine (JVM) to invoke methods on another JVM thus providing remote communication between programs written in the Java programming language. RMI can therefore be used to develop distributed applications . We undertook this project to gain a better understanding of distributed systems concepts and its uses for resource hungry jobs. The image processing application is developed under this environment
York, David W.; Ponyik, Joseph G.
A new software design and development effort has produced a Java (Sun Microsystems, Inc.) version of the award-winning Tempest software (refs. 1 and 2). In 1999, the Embedded Web Technology (EWT) team received a prestigious R&D 100 Award for Tempest, Java Version. In this article, "Tempest" will refer to the Java version of Tempest, a World Wide Web server for desktop or embedded systems. Tempest was designed at the NASA Glenn Research Center at Lewis Field to run on any platform for which a Java Virtual Machine (JVM, Sun Microsystems, Inc.) exists. The JVM acts as a translator between the native code of the platform and the byte code of Tempest, which is compiled in Java. These byte code files are Java executables with a ".class" extension. Multiple byte code files can be zipped together as a "*.jar" file for more efficient transmission over the Internet. Today's popular browsers, such as Netscape (Netscape Communications Corporation) and Internet Explorer (Microsoft Corporation) have built-in Virtual Machines to display Java applets.
This paper presents Distributed Systems Foundation (DSF), a common platform for distributed systems research and development. It can run a distributed algorithm written in Java under multiple execution modes—simulation, massive multi-tenancy, and real deployment. DSF provides a set of novel features to facilitate testing and debugging, including chaotic timing test and time travel debugging with mutable replay. Unlike existing research prototypes that offer advanced debugging features by hacking programming tools, DSF is written entirely in Java, without modifications to any external tools such as JVM, Java runtime library, compiler, linker, system library, OS, or hypervisor. This simplicity stems from our goal of making DSF not only a research prototype but more importantly a production tool. Experiments show that DSF is efficient and easy to use. DSF's massive multi-tenancy mode can run 4,000 OS-level threads in a single JVM to concurrently execute (as opposed to simulate) 1,000 DHT nodes in real-time.
Choi, Yoo Rark; Lee, Jae Cheol; Kim, Jae Hee [Korea Atomic Energy Research Institute, Daejeon (Korea, Republic of)
The world wide web and java are powerful networking technologies on the internet. An applet is a program written in the java programming language that can be included in an HTML page, much in the same way as an image is included. When we use a Java technology-enabled browser to view a page that contains an applet, the applet code is transferred to a client's system and executed by the browser's Java Virtual Machine (JVM). We have developed two remote inspection systems for a reactor wall inspection and guide tube spilt pin inspection based on the java and traditional programming language. The java is used on a GUI(graphic user interface) and the traditional visual C++ programming language is used to control the inspection equipments.
Ekman, Torbjörn; Mechlenborg, Peter; Schultz, Ulrik Pagh
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 object-oriented 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...
David M. Doolin
Full Text Available The JLAPACK project provides the LAPACK numerical subroutines translated from their subset Fortran 77 source into class files, executable by the Java Virtual Machine (JVM and suitable for use by Java programmers. This makes it possible for Java applications or applets, distributed on the World Wide Web (WWW to use established legacy numerical code that was originally written in Fortran. The translation is accomplished using a special purpose Fortran‐to‐Java (source‐to‐source compiler. The LAPACK API will be considerably simplified to take advantage of Java’s object‐oriented design. This report describes the research issues involved in the JLAPACK project, and its current implementation and status.
Misiowiec, M; Buttner, M
CERN controls software is often developed on Java foundation. Some systems carry out a combination of data, network and processor intensive tasks within strict time limits. Hence, there is a demand for high performing, quasi real time solutions. Extensive prototyping of the new CERN monitoring and alarm software required us to address such expectations. The system must handle dozens of thousands of data samples every second, along its three tiers, applying complex computations throughout. To accomplish the goal, a deep understanding of multithreading, memory management and interprocess communication was required. There are unexpected traps hidden behind an excessive use of 64 bit memory or severe impact on the processing flow of modern garbage collectors. Tuning JVM configuration significantly affects the execution of the code. Even more important is the amount of threads and the data structures used between them. Accurately dividing work into independent tasks might boost system performance. Thorough profili...
Caska, James; Schoeberl, Martin
Java is slowly being accepted as a language and platform for embedded devices. However, the memory requirements of the Java library and runtime are still troublesome. A Java system is considered small when it requires less than 1 MB, and within the embedded domain small microcontollers with a few...... KB on-chip Flash memory and even less on-chip RAM are very common. For such small devices Java is a clearly challenging. In this paper we present the combination of the Java compiler Muvium for microcontrollers with the tiny soft-core Leros for an FPGA. To the best of our knowledge, the presented...... embedded Java system is the smallest Java system available. The Leros processor consumes less than 5% of the logic cells of the smallest FPGA from Altera and the Muvium compiler produces a JVM, including the Java application, that can execute in a few KB ROM and less than 1 KB RAM. The Leros processor...
Choi, Yoo Rark; Lee, Jae Cheol; Kim, Jae Hee
The world wide web and java are powerful networking technologies on the internet. An applet is a program written in the java programming language that can be included in an HTML page, much in the same way as an image is included. When we use a Java technology-enabled browser to view a page that contains an applet, the applet code is transferred to a client's system and executed by the browser's Java Virtual Machine (JVM). We have developed two remote inspection systems for a reactor wall inspection and guide tube spilt pin inspection based on the java and traditional programming language. The java is used on a GUI(graphic user interface) and the traditional visual C++ programming language is used to control the inspection equipments
Stojković, Danijela Lj; Jevtić, Verica V.; Vuković, Nenad; Vukić, Milena; Čanović, Petar; Zarić, Milan M.; Mišić, Milena M.; Radovanović, Dragče M.; Baskić, Dejan; Trifunović, Srećko R.
In reaction of 3-acetyl-4-hydroxy coumarine with methionine methyl ester hydrochloride and tryptophane methyl ester hydrochloride the corresponding enamine ligands were obtained. Palladium (II) complexes were prepared in reaction of potassium-tetrachloridopalladate (II) and corresponding enamine. All compounds were characterized by microanalysis, infrared, 1H and 13C NMR spectroscopy. In vitro antitumor activity of the mentioned ligands and corresponding palladium (II) complexes, as well as me-Gly and me-Val ligands and [Pd (me-Gly)]Cl and [Pd (me-Val)2] complexes was determined by MTT assay against two leukemia cell lines (JVM-13 and MOLT-4) and against primary leukemic cells isolated from chronic lymphocytic leukemia (CLL) patients. Antimicrobial activity of the tested compound was evaluated by determining the minimum inhibitory concentration (MIC) and minimum microbicidal concentration (MMC) against three reference bacterial strains: E. faecalis, P. aeruginosa, S. aureus and one clinical isolate of yeast: Candida spp.
Luckow, Kasper Søe; Thomsen, Bent; Korsholm, Stephan
bytecodes can be derived from the model. Furthermore, we take a first look at how to support the new Java 8 language feature of Lambda expressions in a SCJ context – we look in particular at how the invokedynamic bytecode can be implemented in a time-predictable way and integrated in HVMTP.......We present HVMTP, a time predictable and portable Java virtual machine (JVM) implementation with applications in resource-constrained, hard real-time embedded systems, which implements all levels of the safety critical Java (SCJ) specification. Time predictability is achieved by a combination...... can be obtained using the tool TETASARTSJVM. The timing model readily integrates with the rest of the TETASARTS tool set for temporal verification of SCJ systems. We will also show how a complete timing scheme in terms of safe worst-case execution times and best-case execution times of the Java...
Phoenix is a Java Virtual Machine (JVM) based library for performing mathematical and astrodynamics calculations. It consists of two primary sub-modules, phoenix-math and phoenix-astrodynamics. The mathematics package has a variety of mathematical classes for performing 3D transformations, geometric reasoning, and numerical analysis. The astrodynamics package has various classes and methods for computing locations, attitudes, accesses, and other values useful for general satellite modeling and simulation. Methods for computing celestial locations, such as the location of the Sun and Moon, are also included. Phoenix is meant to be used as a library within the context of a larger application. For example, it could be used for a web service, desktop client, or to compute simple values in a scripting environment.
Truslove, I.; Reed, S.
In practice, Earth and Space Science Informatics often relies on getting more done with less: fewer hardware resources, less IT staff, fewer lines of code. As a capacity-building exercise focused on rapid development of high-performance geoinformatics software, the National Snow and Ice Data Center (NSIDC) built a prototype metadata brokering system using a new JVM language, modern database engines and virtualized or cloud computing resources. The metadata brokering system was developed with the overarching goals of (i) demonstrating a technically viable product with as little development effort as possible, (ii) using very new yet very popular tools and technologies in order to get the most value from the least legacy-encumbered code bases, and (iii) being a high-performance system by using scalable subcomponents, and implementation patterns typically used in web architectures. We implemented the system using the Clojure programming language (an interactive, dynamic, Lisp-like JVM language), Redis (a fast in-memory key-value store) as both the data store for original XML metadata content and as the provider for the message queueing service, and ElasticSearch for its search and indexing capabilities to generate search results. On evaluating the results of the prototyping process, we believe that the technical choices did in fact allow us to do more for less, due to the expressive nature of the Clojure programming language and its easy interoperability with Java libraries, and the successful reuse or re-application of high performance products or designs. This presentation will describe the architecture of the metadata brokering system, cover the tools and techniques used, and describe lessons learned, conclusions, and potential next steps.
Long-term storage and long-distance transportation of hydrogen by use of catalyst-addisted decalin dehydrogenation/naphthalene hydrogenation pair; Dekarin dassuiso/nafutarensuisoka shokubai hannotai wo mochiiru suiso no chokikan chozo/chokyori yuso
Liu, C.; Sakaguchi, M.; Saito, Y. [Scince Univ.of Tokyo, Tokyo (Japan)
To enable taking in and out hydrogen with little energy consumption, it is sufficient if decalin is dehydrogenated to naphthalene under moderate heating condition. It is found that carbon supporting metal catalyst in liquid film state shows extremely high dehydrogeno-aromatization activity of decalin. The result of comparison with liquid hydrogen or metal hydride as media for hydrogen storage and transportation media is reported. The platinum-tungsten composite metal catalyst is prepared from an aqueous solution of K2PtC16 and Li2WO4 in the ratio of 1 to 1 so as to achieve 5wt-metal% carbon supporting. When hydrogen and naphthalene are discharged from the liquid phase reaction medium to the vapor phase and solid phase, respectively, under boiling and refluxing conditions, hydrogen is produced steadily by heating at 200 to 210degC. If economical efficiency is ignored, development of an inter-season energy storage system is desired to be developed which can be used in the season between summertime when sufficient hydrogen is obtained by photovoltaic power generation and electrolysis of water and wintertime when heat source is obtained by catalytic combustion of hydrogen. 11 refs., 4 figs., 4 tabs.
Full Text Available The Isabelle/PIDE platform addresses the question whether proof assistants of the LCF family are suitable as technological basis for educational tools. The traditionally strong logical foundations of systems like HOL, Coq, or Isabelle have so far been counter-balanced by somewhat inaccessible interaction via the TTY (or minor variations like the well-known Proof General / Emacs interface. Thus the fundamental question of math education tools with fully-formal background theories has often been answered negatively due to accidental weaknesses of existing proof engines. The idea of "PIDE" (which means "Prover IDE" is to integrate existing provers like Isabelle into a larger environment, that facilitates access by end-users and other tools. We use Scala to expose the proof engine in ML to the JVM world, where many user-interfaces, editor frameworks, and educational tools already exist. This shall ultimately lead to combined mathematical assistants, where the logical engine is in the background, without obstructing the view on applications of formal methods, formalized mathematics, and math education in particular.
Muñoz-Caro, Camelia; Niño, Alfonso; Reyes, Sebastián; Castillo, Miriam
We present a new version of the core structural package of our Application Programming Interface, APINetworks, for the treatment of complex networks in arbitrary computational environments. The new version is written in Java and presents several advantages over the previous C++ version: the portability of the Java code, the easiness of object-oriented design implementations, and the simplicity of memory management. In addition, some additional data structures are introduced for storing the sets of nodes and edges. Also, by resorting to the different garbage collectors currently available in the JVM the Java version is much more efficient than the C++ one with respect to memory management. In particular, the G1 collector is the most efficient one because of the parallel execution of G1 and the Java application. Using G1, APINetworks Java outperforms the C++ version and the well-known NetworkX and JGraphT packages in the building and BFS traversal of linear and complete networks. The better memory management of the present version allows for the modeling of much larger networks.
Misiowiec, M.; Buczak, W.; Buttner, M.
CERN controls software is often developed on Java foundation. Some systems carry out a combination of data, network and processor intensive tasks within strict time limits. Hence, there is a demand for high performing, quasi real time solutions. The system must handle dozens of thousands of data samples every second, along its three tiers, applying complex computations throughout. To accomplish the goal, a deep understanding of multi-threading, memory management and inter process communication was required. There are unexpected traps hidden behind an excessive use of 64 bit memory or severe impact on the processing flow of modern garbage collectors. Tuning JVM configuration significantly affects the execution of the code. Even more important is the amount of threads and the data structures used between them. Accurately dividing work into independent tasks might boost system performance. Thorough profiling with dedicated tools helped understand the bottlenecks and choose algorithmically optimal solutions. Different virtual machines were tested, in a variety of setups and garbage collection options. The overall work provided for discovering actual hard limits of the whole setup. We present this process of designing a challenging system in view of the characteristics and limitations of the contemporary Java run-time environment. (authors)
Dynamic array bound checks are crucial elements for the security of a Java Virtual Machines. These dynamic checks are however expensive and several static analysis techniques have been proposed to eliminate explicit bounds checks. Such analyses require advanced numerical and symbolic manipulations that 1) penalize bytecode loading or dynamic compilation, 2) complexify the trusted computing base. Following the Foundational Proof Carrying Code methodology, our goal is to provide a lightweight bytecode verifier for eliminating array bound checks that is both efficient and trustable. In this work, we define a generic relational program analysis for an imperative, stackoriented byte code language with procedures, arrays and global variables and instantiate it with a relational abstract domain as polyhedra. The analysis has automatic inference of loop invariants and method pre-/post-conditions, and efficient checking of analysis results by a simple checker. Invariants, which can be large, can be specialized for proving a safety policy using an automatic pruning technique which reduces their size. The result of the analysis can be checked efficiently by annotating the program with parts of the invariant together with certificates of polyhedral inclusions. The resulting checker is sufficiently simple to be entirely certified within the Coq proof assistant for a simple fragment of the Java bytecode language. During the talk, we will also report on our ongoing effort to scale this approach for the full sequential JVM.
Security is an often understated problem in high growth emerging branches of IT like big data and IoT. Elasticsearch is a great example because support for security not only came late, but it's a quite convoluted, non-open, and very expensive solution. Learn how Simone Scarduzio lead his Open Source project ReadonlyREST to become the solution of choice for many. From hackathon hustlers to Fortune500 corporates. ReadonlyREST is simple yet powerful because it leverages the concept of access control list (yes, like firewalls). We'll go through some creative use cases and business concepts made possible by the creative use of ReadonlyREST and its configuration model. About the speaker Simone Scarduzio has a 8 years background in software engineering, spanning from mobile messaging clusters to Cloud-first startups. He wrote the first book about Vert.x, a JVM micro services framework. Recently, he helped Thomson Reuters re-architect legacy back ends into secure, polyglot, resilient distributed systems. Today, ...
Full Text Available Low-level bytecode instrumentation techniques are widely used in many software-engineering tools for the Java Virtual Machine (JVM, that perform some form of dynamic program analysis, such as profilers or debuggers. While program manipulation at the bytecode level is very flexible, because the possible bytecode transformations are not restricted, tool development based on this technique is tedious and error-prone. As a promising alternative, the specification of bytecode instrumentation at a higher level using aspect-oriented programming (AOP can reduce tool development time and cost. Unfortunately, prevailing AOP frameworks lack some features that are essential for certain dynamic analyses. In this article, we focus on three common shortcomings in AOP frameworks with respect to the development of aspect-based tools - (1 the lack of mechanisms for passing data between woven advices in local variables, (2 the support for user-defined static analyses at weaving time, and (3 the absence of pointcuts at the level of individual basic blocks of code. We propose @J, an annotation-based AOP language and weaver that integrates support for these three features. The benefits of the proposed features are illustrated with concrete examples.
Hung, Le Viet; Caprari, Silvia; Bizai, Massimiliano; Toti, Daniele; Polticelli, Fabio
In recent years, structural genomics and ab initio molecular modeling activities are leading to the availability of a large number of structural models of proteins whose biochemical function is not known. The aim of this study was the development of a novel software tool that, given a protein's structural model, predicts the presence and identity of active sites and/or ligand binding sites. The algorithm implemented by ligand binding site recognition application (LIBRA) is based on a graph theory approach to find the largest subset of similar residues between an input protein and a collection of known functional sites. The algorithm makes use of two predefined databases for active sites and ligand binding sites, respectively, derived from the Catalytic Site Atlas and the Protein Data Bank. Tests indicate that LIBRA is able to identify the correct binding/active site in 90% of the cases analyzed, 90% of which feature the identified site as ranking first. As far as ligand binding site recognition is concerned, LIBRA outperforms other structure-based ligand binding sites detection tools with which it has been compared. The application, developed in Java SE 7 with a Swing GUI embedding a JMol applet, can be run on any OS equipped with a suitable Java Virtual Machine (JVM), and is available at the following URL: http://www.computationalbiology.it/software/LIBRAv1.zip. © The Author 2015. Published by Oxford University Press. All rights reserved. For Permissions, please e-mail: firstname.lastname@example.org.
Bonachea, D.; Dickens, P.; Thakur, R.; Mathematics and Computer Science; Univ. of California at Berkeley; Illinois Institute of Technology
There is a growing interest in using Java as the language for developing high-performance computing applications. To be successful in the high-performance computing domain, however, Java must not only be able to provide high computational performance, but also high-performance I/O. In this paper, we first examine several approaches that attempt to provide high-performance I/O in Java - many of which are not obvious at first glance - and evaluate their performance on two parallel machines, the IBM SP and the SGI Origin2000. We then propose extensions to the Java I/O library that address the deficiencies in the Java I/O API and improve performance dramatically. The extensions add bulk (array) I/O operations to Java, thereby removing much of the overhead currently associated with array I/O in Java. We have implemented the extensions in two ways: in a standard JVM using the Java Native Interface (JNI) and in a high-performance parallel dialect of Java called Titanium. We describe the two implementations and present performance results that demonstrate the benefits of the proposed extensions.
Humeniuk, Dave; Klawon, Kevin
Under the Terra Harvest Program, the DIA has the objective of developing a universal Controller for the Unattended Ground Sensor (UGS) community. The mission is to define, implement, and thoroughly document an open architecture that universally supports UGS missions, integrating disparate systems, peripherals, etc. The Controller's inherent interoperability with numerous systems enables the integration of both legacy and future UGS System (UGSS) components, while the design's open architecture supports rapid third-party development to ensure operational readiness. The successful accomplishment of these objectives by the program's Phase 3b contractors is demonstrated via integration of the companies' respective plug-'n'-play contributions that include controllers, various peripherals, such as sensors, cameras, etc., and their associated software drivers. In order to independently validate the Terra Harvest architecture, L-3 Nova Engineering, along with its partner, the University of Dayton Research Institute, is developing the Terra Harvest Open Source Environment (THOSE), a Java Virtual Machine (JVM) running on an embedded Linux Operating System. The Use Cases on which the software is developed support the full range of UGS operational scenarios such as remote sensor triggering, image capture, and data exfiltration. The Team is additionally developing an ARM microprocessor-based evaluation platform that is both energy-efficient and operationally flexible. The paper describes the overall THOSE architecture, as well as the design decisions for some of the key software components. Development process for THOSE is discussed as well.
Lindstrom, Gary; Mehlitz, Peter C.; Visser, Willem
The Real Time Specification for Java (RTSJ) is an augmentation of Java for real time applications of various degrees of hardness. The central features of RTSJ are real time threads; user defined schedulers; asynchronous events, handlers, and control transfers; a priority inheritance based default scheduler; non-heap memory areas such as immortal and scoped, and non-heap real time threads whose execution is not impeded by garbage collection. The Robust Software Systems group at NASA Ames Research Center has JAVA PATHFINDER (JPF) under development, a Java model checker. JPF at its core is a state exploring JVM which can examine alternative paths in a Java program (e.g., via backtracking) by trying all nondeterministic choices, including thread scheduling order. This paper describes our implementation of an RTSJ profile (subset) in JPF, including requirements, design decisions, and current implementation status. Two examples are analyzed: jobs on a multiprogramming operating system, and a complex resource contention example involving autonomous vehicles crossing an intersection. The utility of JPF in finding logic and timing errors is illustrated, and the remaining challenges in supporting all of RTSJ are assessed.
During my participation in the CERN Summer Student Program 2013, I worked under the Technology Department of CERN and, more specifically, in the Machine Protection and Electrical Integrity (MPE) Group. The MPE Group supports LHC operation and maintains state‐of‐the art technology for magnet circuit protection and interlock systems for the present and future accelerators, magnet test facilities and CERN hosted experiments. Within this context, we developed an application that parallelizes the Unidentified Falling Object Detection Algorithm on the LHC Operational Data Analysis Software. For this reason, we used a JVM-based toolkit, named Akka, which parallelizes the execution by creating a number of actors that run simultaneously. The results of the new approach are presented on the last part of this report. They tend to be quite interesting and promising as we managed to reduce the execution time of the analysis by a factor of 10 on a local machine and the first attempts to execute the program on a cluster...
Winter, Victor [Univ. of Nebraska, Omaha, NE (United States); McCoy, James A. [Sandia National Lab. (SNL-NM), Albuquerque, NM (United States); Guerrero, Jonathan [Univ. of Nebraska, Omaha, NE (United States); Reinke, Carl Werner [Sandia National Lab. (SNL-NM), Albuquerque, NM (United States); Perry, James Thomas [Sandia National Lab. (SNL-NM), Albuquerque, NM (United States)
Embedded systems form an integral part of our technological infrastructure and oftentimes play a complex and critical role within larger systems. From the perspective of reliability, security, and safety, strong arguments can be made favoring the use of Java over C in such systems. In part, this argument is based on the assumption that suitable subsets of Java’s APIs and extension libraries are available to embedded software developers. In practice, a number of Java-based embedded processors do not support the full features of the JVM. For such processors, source code migration is a mechanism by which key abstractions offered by APIs and extension libraries can made available to embedded software developers. The analysis required for Java source code-level library migration is based on the ability to correctly resolve element references to their corresponding element declarations. A key challenge in this setting is how to perform analysis for incomplete source-code bases (e.g., subsets of libraries) from which types and packages have been omitted. This article formalizes an approach that can be used to extend code bases targeted for migration in such a manner that the threats associated the analysis of incomplete code bases are eliminated.
José G Palacio Velásquez
Full Text Available Resumen:Los servicios se pueden definir como aplicaciones que se encuentran disponibles para que otras aplicaciones llamadas clientes pueden hacer usos de las funciones de dicho servidor, para la comunicación con dichos servidores se hace necesario que los clientes sepan cuáles de los equipos que se encuentran disponibles brindan servicios y cual servicio brinda cada uno, esto exige la configuración del cliente para que este puede realizar la comunicación con el respectivo servidor. Este tipo de configuración exige conocer que servicios se están brindando en la red y quien los brinda, pero qué sucede si los clientes no saben quiénes son los servidores y peor aún qué sucedería si los clientes no saben qué servicios se están prestando, en este caso aparecen unos sistemas que permiten descubrir qué servicios se encuentran disponibles en una red. Los protocolos de descubrimiento de servicios están pensados precisamente para poder llevar a cabo estas actividades, buscando generar redes que se configuren de manera automática. Protocolos como el SDP usado por el sistema Bluetooth, Jini de Sun Microsystem, Universal Plug and Play de Microsoft son ejemplos claros de dichos protocolos, los cuales abarcaremos en este artículo.Palabras claves:Protocolos de Descubrimiento de Servicios, Bluetooth, Jini, UPnP, Salutation, SDP, SLP, SSDP, TCP/IP, RMI, JVM, RPC, HTTPU, HTTPMU.Abstract:The services can be defined as applications that are available for other applications called customers can use the functions of a server, for communicating with those servers is necessary for customers to know which of the teams that provide services are available and what each service provides, this requires client configuration so that this can make communication with the respective server. This configuration requires knowing what services are being provided on the network and who offers them, but what happens if customers do not know who the servers and even
Rampazzo, Enrico; Voltan, Rebecca; Petrizza, Luca; Zaccheroni, Nelsi; Prodi, Luca; Casciano, Fabio; Zauli, Giorgio; Secchiero, Paola
Silica-based luminescent nanoparticles (SiNPs) show promising prospects in nanomedicine in light of their chemical properties and versatility. In this study, we have characterized silica core-PEG shell SiNPs derivatized with PEG moieties (NP-PEG), with external amino- (NP-PEG-amino) or carboxy-groups (NP-PEG-carbo), both in cell cultures as well as in animal models. By using different techniques, we could demonstrate that these SiNPs were safe and did not exhibit appreciable cytotoxicity in different relevant cell models, of normal or cancer cell types, growing either in suspension (JVM-2 leukemic cell line and primary normal peripheral blood mononuclear cells) or in adherence (human hepatocarcinoma Huh7 and umbilical vein endothelial cells). Moreover, by multiparametric flow cytometry, we could demonstrate that the highest efficiency of cell uptake and entry was observed with NP-PEG-amino, with a stable persistence of the fluorescence signal associated with SiNPs in the loaded cell populations both in vitro and in vivo settings suggesting this as an innovative method for cell traceability and detection in whole organisms. Finally, experiments performed with the endocytosis inhibitor Genistein clearly suggested the involvement of a caveolae-mediated pathway in SiNP endocytosis. Overall, these data support the safe use of these SiNPs for diagnostic and therapeutic applications.Silica-based luminescent nanoparticles (SiNPs) show promising prospects in nanomedicine in light of their chemical properties and versatility. In this study, we have characterized silica core-PEG shell SiNPs derivatized with PEG moieties (NP-PEG), with external amino- (NP-PEG-amino) or carboxy-groups (NP-PEG-carbo), both in cell cultures as well as in animal models. By using different techniques, we could demonstrate that these SiNPs were safe and did not exhibit appreciable cytotoxicity in different relevant cell models, of normal or cancer cell types, growing either in suspension (JVM-2
M. A. Brovelli
Lambert, Dean; Hamilton, Alasdair C.; Constable, George; Snehanshu, Harsh; Talati, Sharvil; Courtial, Johannes
TIM (The Interactive METATOY) is a ray-tracing program specifically tailored towards our research in METATOYs, which are optical components that appear to be able to create wave-optically forbidden light-ray fields. For this reason, TIM possesses features not found in other ray-tracing programs. TIM can either be used interactively or by modifying the openly available source code; in both cases, it can easily be run as an applet embedded in a web page. Here we describe the basic structure of TIM's source code and how to extend it, and we give examples of how we have used TIM in our own research. Program summaryProgram title: TIM Catalogue identifier: AEKY_v1_0 Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEKY_v1_0.html Program obtainable from: CPC Program Library, Queen's University, Belfast, N. Ireland Licensing provisions: GNU General Public License No. of lines in distributed program, including test data, etc.: 124 478 No. of bytes in distributed program, including test data, etc.: 4 120 052 Distribution format: tar.gz Programming language: Java Computer: Any computer capable of running the Java Virtual Machine (JVM) 1.6 Operating system: Any; developed under Mac OS X Version 10.6 RAM: Typically 145 MB (interactive version running under Mac OS X Version 10.6) Classification: 14, 18 External routines: JAMA  (source code included) Nature of problem: Visualisation of scenes that include scene objects that create wave-optically forbidden light-ray fields. Solution method: Ray tracing. Unusual features: Specifically designed to visualise wave-optically forbidden light-ray fields; can visualise ray trajectories; can visualise geometric optic transformations; can create anaglyphs (for viewing with coloured "3D glasses") and random-dot autostereograms of the scene; integrable into web pages. Running time: Problem-dependent; typically seconds for a simple scene.
Kainz, Philipp; Mayrhofer-Reinhartshuber, Michael; Ahammer, Helmut
Image and signal analysis applications are substantial in scientific research. Both open source and commercial packages provide a wide range of functions for image and signal analysis, which are sometimes supported very well by the communities in the corresponding fields. Commercial software packages have the major drawback of being expensive and having undisclosed source code, which hampers extending the functionality if there is no plugin interface or similar option available. However, both variants cannot cover all possible use cases and sometimes custom developments are unavoidable, requiring open source applications. In this paper we describe IQM, a completely free, portable and open source (GNU GPLv3) image and signal analysis application written in pure Java. IQM does not depend on any natively installed libraries and is therefore runnable out-of-the-box. Currently, a continuously growing repertoire of 50 image and 16 signal analysis algorithms is provided. The modular functional architecture based on the three-tier model is described along the most important functionality. Extensibility is achieved using operator plugins, and the development of more complex workflows is provided by a Groovy script interface to the JVM. We demonstrate IQM's image and signal processing capabilities in a proof-of-principle analysis and provide example implementations to illustrate the plugin framework and the scripting interface. IQM integrates with the popular ImageJ image processing software and is aiming at complementing functionality rather than competing with existing open source software. Machine learning can be integrated into more complex algorithms via the WEKA software package as well, enabling the development of transparent and robust methods for image and signal analysis.
Full Text Available Gilles P Squelard,1 Pierre A Missotten,1 Louis Paquay,2 Jan A De Lepeleire,2 Frank JVM Buntinx,2 Ovide Fontaine,1 Stephane R Adam,1 Michel JD Ylieff11Clinical Psychology of Ageing, Qualidem Research Project, University of Liège (ULg, Liège, Belgium; 2KU Leuven, Department of Public Health and Primary Care, Leuven, BelgiumBackground/aims: This study assesses and compares prevalence of psychological and behavioral symptoms in a Belgian sample of people with and without dementia.Methods: A total of 228 persons older than 65 years with dementia and a group of 64 non-demented persons were assessed using the Neuropsychiatric Inventory (NPI in 2004.Results: Within the group without dementia, the most frequent symptoms were depression, agitation, and irritability. Within the group with dementia, the most common symptoms were depression, irritability, apathy, and agitation. Prevalence of delusions (P < 0.05, hallucinations (P < 0.05, anxiety (P < 0.05, agitation (P < 0.05, apathy (P < 0.01, aberrant motor behavior (P < 0.01, and eating disorders (P < 0.05 were significantly higher in the group with dementia.Conclusion: Depression, elation, irritability, disinhibition, and sleeping disorders are not specific to dementia. Agitation, apathy, anxiety, and delusions are more frequent in dementia but were not specific to the dementia group because their prevalence rates were close to 10% in the group without dementia. Hallucinations, aberrant motor behavior, and eating disorders are specific to dementia. The distinction between specific and nonspecific symptoms may be useful for etiological research on biological, psychological, and environmental factors.Keywords: behavior, behavior disorders, epidemiology, dementia, psychiatric symptoms, neuropsychiatry
Brovelli, M. A.; Kilsedar, C. E.; Zamboni, G.
Java Pathfinder (JPF) is a verification and testing environment for Java that integrates model checking, program analysis, and testing. JPF consists of a custom-made Java Virtual Machine (JVM) that interprets bytecode, combined with a search interface to allow the complete behavior of a Java program to be analyzed, including interleavings of concurrent programs. JPF is implemented in Java, and its architecture is highly modular to support rapid prototyping of new features. JPF is an explicit-state model checker, because it enumerates all visited states and, therefore, suffers from the state-explosion problem inherent in analyzing large programs. It is suited to analyzing programs less than 10kLOC, but has been successfully applied to finding errors in concurrent programs up to 100kLOC. When an error is found, a trace from the initial state to the error is produced to guide the debugging. JPF works at the bytecode level, meaning that all of Java can be model-checked. By default, the software checks for all runtime errors (uncaught exceptions), assertions violations (supports Java s assert), and deadlocks. JPF uses garbage collection and symmetry reductions of the heap during model checking to reduce state-explosion, as well as dynamic partial order reductions to lower the number of interleavings analyzed. JPF is capable of symbolic execution of Java programs, including symbolic execution of complex data such as linked lists and trees. JPF is extensible as it allows for the creation of listeners that can subscribe to events during searches. The creation of dedicated code to be executed in place of regular classes is supported and allows users to easily handle native calls and to improve the efficiency of the analysis.
Oxburgh, Stephen; Tyc, Tomáš; Courtial, Johannes
We describe several extensions to TIM, a raytracing program for ray-optics research. These include relativistic raytracing; simulation of the external appearance of Eaton lenses, Luneburg lenses and generalised focusing gradient-index lens (GGRIN) lenses, which are types of perfect imaging devices; raytracing through interfaces between spaces with different optical metrics; and refraction with generalised confocal lenslet arrays, which are particularly versatile METATOYs. Catalogue identifier: AEKY_v2_0 Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEKY_v2_0.html Program obtainable from: CPC Program Library, Queen’s University, Belfast, N. Ireland Licencing provisions: GNU General Public License No. of lines in distributed program, including test data, etc.: 106905 No. of bytes in distributed program, including test data, etc.: 6327715 Distribution format: tar.gz Programming language: Java. Computer: Any computer capable of running the Java Virtual Machine (JVM) 1.6. Operating system: Any, developed under Mac OS X Version 10.6 and 10.8.3. RAM: Typically 130 MB (interactive version running under Mac OS X Version 10.8.3) Classification: 14, 18. Catalogue identifier of previous version: AEKY_v1_0 Journal reference of previous version: Comput. Phys. Comm. 183(2012)711 External routines: JAMA  (source code included) Does the new version supersede the previous version?: Yes Nature of problem: Visualisation of scenes that include scene objects that create wave-optically forbidden light-ray fields. Solution method: Ray tracing. Reasons for new version: Significant extension of the capabilities (see Summary of revisions), as demanded by our research. Summary of revisions: Added capabilities include the simulation of different types of camera moving at relativistic speeds relative to the scene; visualisation of the external appearance of generalised focusing gradient-index (GGRIN) lenses, including Maxwell fisheye, Eaton and Luneburg lenses; calculation of
Gehrke, Iris; Razavi, Regina; Poll-Wolbeck, Simon Jonas; Berkessel, Albrecht; Hallek, Michael; Kreuzer, Karl-Anton
Chronic Lymphocytic Leukemia (CLL) is not curable in patients that are not eligible for allogeneic stem cell transplantation. Therefore, new treatment options are highly desirable. Chemically modified nonsteroidal anti-inflammatory drugs (NSAIDs), such as nitric-oxide-donating acetylsalicylic acid (NO-ASA), have been described to possess antineoplastic capacity. Recently, we could demonstrate a potent apoptosis induction in primary CLL cells in vitro and tumor growth inhibition by para-NO-ASA in a xenograft mouse model. However, little is known about the impact of positional isomerism of NO-ASA on its antineoplastic capacity in CLL. Primary CLL cells were treated with the meta-or para-isomer of NO-ASA at varying concentrations and durations. Viability was assessed flow cytometrically by annexin V-FITC/PI staining and by CellTiter-Glo luminescence cell viability assay. Caspase and PARP cleavage as well as involvement of β-catenin/Lef-1 signaling was determined by immunoblotting. For caspase inhibition, BD™ ApoBlock was used. Nude mice were xenografted with JVM3 cells and treated with meta-NO-ASA, para-NO-ASA or vehicle control. The meta-isomer was entirely ineffective in inducing CLL cell apoptosis in concentrations up to 100 μM, while para-NO-ASA acted in the low micromolar range. meta-NO-ASA, in contrast to para-NO-ASA, did not alter caspase activity. While para-NO-ASA action involved inhibition of β-catenin/Lef-1 signaling, meta-NO-ASA did not show any impact on this signaling pathway. Further, meta-NO-ASA did not significantly reduce tumor growth in a CLL xenograft mouse model, while para-NO-ASA was highly potent. We conclude that positional isomerism is crucial for the antineoplastic effect of NO-ASA in CLL. It can be suggested that the para-isomer, but not the meta-isomer, generates a chemical structure which is essential for the neoplastic effect of NO-ASA.
Pirrone, Daniele; Pajewski, Lara
can be employed to import synthetic data created by GprMax using the binary-format option into MATLAB, in order to be processed and/or visualized. Further MATLAB procedures for the visualization of GprMax synthetic data have been developed within the COST Action TU1208  and are available for free public download on www.GPRadar.eu. The current version of GprMax3D is compiled with OpenMP, supporting multi-platform shared memory multiprocessing which allows GprMax3D to take advantage of multiple cores/CPUs. GprMax2D, instead, exploits a single core when executed. E2GPR is a new software tool, available free of charge for both academic and commercial use, conceived to: 1) assist in the creation, modification and analysis of GprMax2D models, through a Computer-Aided Design (CAD) system; 2) allow parallel and/or distributed computing with GprMax2D, on a network of computers; 3) automatically plot A-scans and B-scans generated by GprMax2D. The CAD and plotter parts of the tool are implemented in Java and can run on any Java Virtual Machine (JVM) regardless of computer architecture. The part of the tool devoted to supporting parallel and/or distributed computing, instead, requires the set up of a Web-Service (on a server emulator or server); in fact, it is currently configured only for Windows Server and Internet Information Services (IIS). In this work, E2GPR is presented and examples are provided which demonstrate its use. The tool can be currently obtained by contacting the authors. It will soon be possible to download it from www.GPRadar.eu. Acknowledgement This work is a contribution to the COST Action TU1208 'Civil Engineering Applications of Ground Penetrating Radar.' The authors thank COST for funding the Action TU1208. References  A. Giannopoulos, 'Modelling ground penetrating radar by GprMax,' Construction and Building Materials, vol. 19, pp. 755-762, 2005.  L. Pajewski, A. Benedetto, X. Dérobert, A. Giannopoulos, A. Loizos, G. Manacorda, M. Marciniak, C