- Book Chapter
- 10.1016/b978-0-323-95502-7.00082-8
Computing Languages for Bioinformatics: Java
- Jan 01, 2025
- Reference Module in Life Sciences
- Pietro H Guzzi + 2 more +2
Computing Languages for Bioinformatics: Java
Computing Languages for Bioinformatics: Java
Computing Languages for Bioinformatics: Java
Computing Languages for Bioinformatics: Java
What Is Apache NetBeans
It isn’t often that a technology sweeps the world and ends up being a relevant piece of the technological universe for over 20 years. The Java programming language was originally developed in 1995 by Sun Microsystems, and it has grown into a massive ecosystem over the years. The Java Virtual Machine (JVM) is a virtual computer that is defined by a specification, and the Java programming language can be used to program applications that run on the JVM. A JVM can be installed on just about any computer or hardware device that is available on the market. As such, the JVM is installed on millions of devices worldwide, and there have been dozens of different programming languages built on top of the JVM that compile down to Java byte code, allowing developers to utilize different language syntax to run on the JVM. What does this mean? Well, frankly it means that the JVM and Java are everywhere, and one can use a multitude of languages to program applications that will run just about anywhere. Java is an ecosystem that started in 1995, and it will be around long into the future.
Read moreJava
Java is a strongly typed, object‐oriented , programming language with emphasis on supporting the software engineering of distributed applications. Because of its facilities for user interface and network programming, it has been referred to as a network‐centric language. Introduced in 1995, the Java language incorporates many ideas of previous programming languages into a single language. For example, it combines strong typing, object orientation, modular program structure, exception handling, and concurrency. It also incorporates software engineering ideas for structuring and programming on a large scale. It was designed by James Gosling at Sun Microsystems and since has become an industry standard language. Java's development coincided with the widespread adoption of the Internet; it therefore aims at supporting software engineering of distributed applications. Java relies on a rich environment of libraries that support specific application areas such as network programming, database programming, and graphical user interface programming. New libraries are periodically added to support other applications. The Java virtual machine (JVM) is an abstract machine designed to execute Java (and other) programs. A Java compiler translates a Java program into a program for the JVM, that is, into a program written using the instructions of the JVM. To run the program, a JVM interpreter executes the program. JVM implementations, that is, JVM interpreters, exist for most computers and are embedded in many devices. A Java‐enabled browser is a Web browser that contains a JVM interpreter. It is therefore capable of executing Java programs and applets. The JVM is the main mechanism for achieving portability of Java programs across different machines. The JVM has also been used as the target machine for other language compilers as well.
Read moreA Hardware-Software Integrated Design for a High-Performance Java Processor
Today object-oriented programming (OOP) is becoming more and more popular than ever, due to Internet and network computing, and need for resource sharing. Java becomes attractive because of its appealing features such as platform independence and code reusability. However, Java has lower performance than conventional programming languages due to its real-time execution overheads in the layer of Java Virtual Machine (JVM). With increasing performance through higher clock speed or multi-cores, software virtual machines are still needed to run on top of the operating system to execute Java, reducing the effect of the hardware performance improvements. This research proposes a high-performance computer architecture with hybrid system co-design for Java processing. Our FPGA model implemented in VHDL, jHISC, originates hardware support for object-oriented bytecodes, object referencing and method invocation. Moreover, baseline compiler is developed to construct the core structure and to ensure the architecture compatible to the JVM specifications. The project is at present version 4, which is target for mobile and embedded computing. Comparing with the products by Sun Microsystems through evaluation based on SPEC JVM98 benchmark, jHISC V4.0 provide overall performance gain of around 137% over HotSpot JVM and 102% to 1351% over picoJava II.
Read moreJUSTGen: Effective Test Generation for Unspecified JNI Behaviors on JVMs
Java Native Interface (JNI) provides a way for Java applications to access native libraries, but it is difficult to develop correct JNI programs. By leveraging native code, the JNI enables Java developers to implement efficient applications and to reuse code written in other programming languages such as C and C++. Besides, the core Java libraries already use the JNI to provide system features like a graphical user interface. As a result, many mainstream Java Virtual Machines (JVMs) support the JNI. However, due to the complex interoperation semantics between different programming languages, implementing correct JNI programs is not trivial. Moreover, because of the performance overhead, JVMs do not validate erroneous JNI interoperations by default, but they validate them only when the debug feature, the -Xcheck:jni option, is enabled. Therefore, the correctness of JNI programs highly relies on the checks by the -Xcheck:jni option of JVMs. Questions remain, however, on the quality of the checks provided by the feature. Are there any properties that the -Xcheck:jni option fails to validate? If so, what potential issues can arise due to the lack of such validation? To the best of our knowledge, no research has explored these questions in-depth. In this paper, we empirically study the validation quality and impacts of the -Xcheck:jni option on mainstream JVMs using unspecified corner cases in the JNI specification. Such unspecified cases may lead to unexpected run-time behaviors because their semantics is not defined in the specification. For a systematic study, we propose JUSTGen, a semi-automated approach to identify unspecified cases from a specification and generate test programs. JUSTGen receives the JNI specification written in our domain specific language (DSL), and automatically discovers unspecified cases using an SMT solver. It then generates test programs that trigger the behaviors of unspecified cases. Using the generated tests, we empirically study the validation ability of the -Xcheck:jni option. Our experimental result shows that the JNI debug feature does not validate thousands of unspecified cases on JVMs, and they can cause critical run-time errors such as violation of the Java type system and memory corruption. We reported 792 unspecified cases that are not validated by JVMs to their corresponding JVM vendors. Among them, 563 cases have been fixed and the remaining cases will be fixed in near future. Based on our empirical study, we believe that the JNI specification should specify the semantics of the missing cases clearly and the debug feature should be supported completely.
Read moreJUSTGen: Effective Test Generation for Unspecified JNI Behaviors on JVMs
Java Native Interface (JNI) provides a way for Java applications to access native libraries, but it is difficult to develop correct JNI programs. By leveraging native code, the JNI enables Java developers to implement efficient applications and to reuse code written in other programming languages such as C and C++. Besides, the core Java libraries already use the JNI to provide system features like a graphical user interface. As a result, many mainstream Java Virtual Machines (JVMs) support the JNI. However, due to the complex interoperation semantics between different programming languages, implementing correct JNI programs is not trivial. Moreover, because of the performance overhead, JVMs do not validate erroneous JNI interoperations by default, but they validate them only when the debug feature, the -Xcheck:jni option, is enabled. Therefore, the correctness of JNI programs highly relies on the checks by the -Xcheck:jni option of JVMs. Questions remain, however, on the quality of the checks provided by the feature. Are there any properties that the -Xcheck:jni option fails to validate? If so, what potential issues can arise due to the lack of such validation? To the best of our knowledge, no research has explored these questions in-depth. In this paper, we empirically study the validation quality and impacts of the -Xcheck:jni option on mainstream JVMs using unspecified corner cases in the JNI specification. Such unspecified cases may lead to unexpected run-time behaviors because their semantics is not defined in the specification. For a systematic study, we propose JUSTGEN, a semi-automated approach to identify unspecified cases from a specification and generate test programs. JUSTGEN receives the JNI specification written in our domain specific language (DSL), and automatically discovers unspecified cases using an SMT solver. It then generates test programs that trigger the behaviors of unspecified cases. Using the generated tests, we empirically study the validation ability of the -Xcheck:jni option. Our experimental result shows that the JNI debug feature does not validate thousands of unspecified cases on JVMs, and they can cause critical run-time errors such as violation of the Java type system and memory corruption. We reported 792 unspecified cases that are not validated by JVMs to their corresponding JVM vendors. Among them, 563 cases have been fixed and the remaining cases will be fixed in near future. Based on our empirical study, we believe that the JNI specification should specify the semantics of the missing cases clearly and the debug feature should be supported completely.
Read moreLa Ingeniería Lingüística con Java
Este artículo intenta hacer una reflexión teórica sobre Java que sea de interés y utilidad para la comunidad informática, y especialmente para los programadores de aplicaciones lingüísticas, ya que, como ocurre con muchas otras tecnologías asociadas con la Web, hay cierta confusión, falta de información y malentendidos sobre este lenguaje de programación. Aunque muchos lingüistas computacionales hayan oído hablar de Java, considerado su uso e incluso llegado hasta su primer applet (aplicación pequeña para una página Web) ‘Hola mundo quizás no se hayan planteado todas las implicaciones del uso de este lenguaje y del papel que podría desempeñar en el desarrollo de aplicaciones lingüísticas hoy en día. Es necesario clarificar de antemano que aquí no se tiene el propósito de presentar Java como sustituto absoluto de los lenguajes de programación tradicionales para aplicaciones lingüísticas ya que, entre otras cosas, la historia de Java es demasiado corta para examinar comparativamente las aplicaciones escritas en este lenguaje y en otros y extraer conclusiones definitivas.
Read moreJava Bytecode-to-.NET MSIL Translator for Construction of Platform Independent Information Systems
This paper presents the java bytecode-to-.NET MSIL translator, to construct a platform independent information system, which enables the execution of the java program in .NET environment without JVM(Java Virtual Ma-chine), translating bytecodes produced by compiling java programs into MSIL codes. Java, one of the most widely used programming languages recently, is the language invented by James Gosling at Sun Microsystems, which is the next generation language independent of operating systems and hardware platforms. Java source code is compiled into bytecode as intermediate code independent of each platform by compiler, and also executed by JVM. .NET language such as C# and .NET platform in Microsoft Corp. has been developed to meet the needs of programmers, and cope with Java and JVM platform of Sun Microsystems. After compiling, a program written in .NET language is converted to MSIL code, and also executed by .NET platform but not in JVM platform. For this reason, we designed and implemented the java bytecode-to-.NET MSIL translator system for programs written in java language to be executed in the .NET platform without JVM.
Read moreDeveloping mobile software for foreign language learning
Problem. The subject of the study is an interactive mobile application in Java. To perform this work, the following tasks were set: analysis of programming environments and languages of development; analysis of methods for developing the logic and interface of the mobile application; development of an interactive mobile application in Java. Goal. The aim of the work is to develop a mobile application for learning a foreign language for the Android operating system, whose interface and logic will be modern, user-friendly and accessible to users. Methodology. The general concept of a mobile application for learning a foreign language is as follows: learning a foreign language offline, versatile learning (words, grammar), the presence of a motivational unit, simple design. The object of research is the process of building an interactive mobile application in Java for the Android operating system. In the course of the work, a study of programming languages and environments for the development of mobile applications was conducted. Programming languages such as: Java, C ++, C # were considered. Programming environments such as Android Studio, NetBeans and Eclipse were also analyzed. As a result, the Java programming language and Android Studio programming environment were chosen for the development of the mobile application. Two types of markup were selected: LinearLayout; ConstraintLayout. Results. The mobile application for learning a foreign language for the Android operating system was developed in Android Studio in two programming languages: Java (logic) and XML (interface). The aim to provide the application with modern interface and logic, to make it user-friendly and accessible to users was completed. Originality. Contribution has been made to the field of using smartphones for learning foreign languages. The sphere of using smartphones has been expanded with the use of all modern trends to the creation of mobile applications for learning foreign languages. Practicalvalue. Considering that the number of potential users will only increase in the nearest future, the developed mobile application for learning a foreign language is an ideal platform for educating those who want to develop and learn foreign languages for themselves, as well as for work, communication and travel.
Read moreJava Programming Language
Java is a general-purpose object-oriented programming language created by James Gosling and others at Sun Microsystems in the mid-1990s. It has played a key role in transforming the Internet, and it has fundamentally changed the way in which people program. It supports application programming in a distributed computing environment, and it was designed with portability in mind. The objective is to create a computing environment that allows a program to be written once and executed anywhere, and platform independence is achieved by compiling the Java code into Java bytecode, where the bytecode is an optimized set of instructions that may be executed on a Java Virtual Machine.
Read moreOptiFeat: enhancing feature selection, a hybrid approach combining subject matter expertise and recursive feature elimination method
Optimizing the performance of Java Virtual Machines (JVMs) (Sahin et al. in Proc IEEE Int Congr Big Data BigData Congr 410–417, 2016) is crucial for achieving efficient execution of Java applications. Feature selection plays a pivotal role in identifying the most relevant parameters for fine-tuning JVMs, thereby enhancing their overall efficiency. This paper presents a novel hybrid approach that integrates both subject matter expertise and Recursive Feature Elimination (RFE) (Yin et al. in J Big Data 10(1):15, 2023) model to refine feature selection for JVM fine-tuning using machine learning techniques. Traditional feature selection methods often lack the ability to incorporate domain-specific knowledge, resulting in suboptimal selections (Khaire and Dhanalakshmi in J King Saud Univ Comput Inf Sci 34(4):1060–1073, 2022). In contrast, the hybrid approach leverages the expertise of JVM administrators or developers to guide the feature selection process. By integrating domain knowledge into the feature selection pipeline, ensure the inclusion of crucial JVM parameters that may not be captured by automated techniques alone. Furthermore, employed the RFE model, a powerful recursive feature elimination algorithm, to iteratively identify and eliminate irrelevant features from the initial feature set. This iterative process enhances the efficiency of feature selection by systematically pruning less influential parameters, thereby improving the overall performance of the JVM. To validate the effectiveness of the hybrid approach, conducted experiments using real-world JVM datasets and compare the performance of the method against existing feature selection techniques. The results demonstrate that the approach not only achieves superior performance in terms of JVM fine-tuning but also provides insights into the significance of domain expertise in optimizing JVM performance (Menéndez and Bartlett in http://arxiv.org/abs/2310.16510, 2023). It contributes to the field of JVM optimization by proposing a novel hybrid approach that combines subject matter expertise with machine learning-based feature selection techniques. By leveraging both domain knowledge and automated algorithms, the approach offers a comprehensive solution for enhancing feature selection in JVM fine-tuning, ultimately leading to improved performance and efficiency in Java application execution.
Read moreEvaluating the Impact of Java Virtual Machines on Energy Consumption
Background. The Java Virtual Machine (JVM) platforms have known multiple evolutions along the last decades to enhance both the performance they exhibit and the features they offer. With regards to energy consumption, few studies have investigated the energy consumption of code and data structures. Yet, we keep missing an evaluation of the energy efficiency of existing JVM platforms and an identification of the configurations that minimize the energy consumption of software hosted on the JVM. Aims. The purpose of this paper is to investigate the variations in energy consumption between different JVM distributions and parameters to help developers configure the least consuming environment for their Java application. Method. We thus assess the energy consumption of some of the most popular and supported JVM platforms using 12 Java benchmarks that explore different performance objectives. Moreover, we investigate the impact of the different JVM parameters and configurations on the energy consumption of software. Results. Our results show that some JVM platforms can exhibit up to 100% more energy consumption. JVM configurations can also play a substantial role to reduce the energy consumption during the software execution. Interestingly, the default configuration of the garbage collector was energy efficient in only 50% of our experiments. Conclusion. Finally, we provide an Open source tool, named J-Referral that recommends an energy-efficient JVM distribution and configuration for any Java application.
Read moreA selective dynamic compiler for embedded Java virtual machines targeting ARM processors
A selective dynamic compiler for embedded Java virtual machines targeting ARM processors
Testing in resource constrained execution environments
Software for resource constrained embedded devices is often implemented in the Java programming language because the Java compiler and virtual machine provide enhanced safety, portability, and the potential for run-time optimization. It is important to verify that a software application executes correctly in the environment in which it will normally execute, even if this environment is an embedded one that severely constrains memory resources. Testing can be used to isolate defects within and establish a confidence in the correctness of a Java application that executes in a resource constrained environment. However, executing test suites with a Java virtual machine (JVM) that uses dynamic compilation to create native code bodies can introduce significant testing time overheads if memory resources are highly constrained. This paper describes an approach that uses adaptive code unloading to ensure that it is feasible to perform testing in the actual memory constrained execution environment. The experiments demonstrate that code unloading can reduce both the test suite execution time by 34% and the code size of the test suite and application under test by 78% while maintaining the overall size of the JVM.
Read moreMixed Language Programming in C/C++ and Java for Applications in Mechatronic Systems
Mixed language programming is very useful for many applications which can take advantage of the salient features of different programming languages. In this paper, design and implementation of ChJava which supports portable mixed language programming in C/C++ and Java was presented. ChJava integrates portable C/C++ interpreter Ch and Java virtual machine. Using ChJava, Java classes can be executed from a C/C++ program interpretively, and C/C++ programs can be executed from a Java program. ChJava contains the salient features of both C/C++ and Java. The application of ChJava in interactive control of a mechatronic system is presented. The mechatronic system can be controlled in a standalone environment. It can also be controlled across Internet through a Web browser with the program running either in a client side or in a Web server. In this application, the control of C/C++ scripts can be generated and modified dynamically. It is expected that ChJava will find applications in many different fields
Read more