Compiling Fresh Breeze Codelets

This paper presents the design of a compiler for parallel programs expressed as collections of codelets -- blocks of statements intended for distribution over the processing cores of a massively parallel computer system.Because interactions of codelets with other codelets are limited to acquiring input data at the start of execution and making results available on completion, an unconventional approach to code generation appears beneficial -- we call it code generation by program analysis and code construction. We present an implementation of this concept in the context of a compiler for functional dialects of the Java or Scala programming languages targeted to the proposed instruction set of a Fresh Breeze computer system architecture.

Jeff Magee and Jeff Kramer John Wiley and Sons, New York, NY, 1999, 374 pp. ISBN 0471987107, $64.99 The book is an introductory text to the ideas, concepts, and topics of concurrency. The text focuses on understanding concepts and techniques, and problems of concurrency, not on the implementation or language. The author's overall goal is that by a combination of learning and doing using Java should make the process of acquiring the skills relating to concurrency interesting, enjoyable, and challenging. The Java language is thus used only for illustration and programming experience of the reader. The book is intended for a computer science student or software developer. A background in programming is expected, as well as some familiarity with the essential concepts of object-oriented programming. Knowledge of the Java programming language and operating systems concepts is beneficial but not required. After reading the text, a reader can expect to have a broad understanding of the concepts of concurrency, the problems that arise, methods to emphasis desirable properties in a concurrent system, and ways to avoid the undesirable ones. The text provides a systematic treatment of concepts, as means to rigorously specify and model concurrent systems, with Java examples to animate and illustrate the concepts discussed. The book is organized into twelve chapters, with three appendices. The first eight chapters provide a concise and comprehensive foundation of concurrency, with the remaining four chapters focusing on more advanced concepts. The latter four chapters are somewhat supplemental and can be read at the discretion of the reader. The content of the text is self-contained, with no reliance upon external references. The authors provide a concluding set of notes and further topics which reference external works, but these are not used in the chapter contents. The introduction provides the foundation for the book, and an idea of what will follow in the rest of the text. The basics of modeling and Java are covered. Authors follow with the concepts of processes, threads and with the idea of concurrency. The emphasis is on using Java, and on the notation used to define a concurrent process or thread. The discussion continues covering interleaving and asynchronous concurrency. Various details about composition of parallel processes and finite state processing modeling are presented. The programming of concurrent execution using Java is then examined via the concept of multiple threads. Here, sharing objects among Java threads is also discussed. The concept of conditional synchronization is covered next, and is used to construct a monitor. The methods of the base object in Java is used, and a waiting queue associated with a Java object is discussed and implemented. This discussion is followed by introduction of deadlock. Authors show the conditions necessary for a deadlock to occur and present an analysis of a concurrent system establishing that such a system is deadlock-free. The classic Dining Philosopher's problem is used to illustrate the distinction between finding deadlocks in models and in programs. The presentation continues with the safety property (that asserts that nothing bad happens), and the liveliness property (that asserts that nothing good happens). Here, authors use the material on model-based design to consolidate many of the concepts previously discussed. No one modeling method or design methodology is emphasized. Then creation and elimination of threads in a running program is covered next. The dynamic starting and stopping of Java threads is presented. The discussion moves then to messaging passing. Asynchronous and synchronous messaging is presented with Java programming examples. The concept of a rendezvous, allowing for interaction in a messaging system, is also presented. Based on the concepts developed so far filter-pipeline, supervisor-worker, and announcer-listener concurrent architectures are examined. Java programs demonstrating how the elements of each model interact at runtime are developed. The presentation completes with modeling and implementing of timed systems. Time is signaled by the passage of successive time ticks. The authors then elaborate on a system that is event-based rather than thread-based. Java programs are used to illustrate in implementation the concepts discussed. The three appendices provide a reference, specification, and listing of semantics for the finite-state modeling algebra used by the authors throughout the book. The text is ideal for teaching in a classroom environment, or for a motivated reader to use for self-paced learning. Its organization follows a logical train of discussion and thought, with each chapter building successively on the other, with the more difficult concepts and topics withheld until later. This gradual approach makes the material flow smoothly and cohesively from the beginning to the end. The book is intended as a textbook, so does organize the material and discussion as one, but does not become too dry or bland to stifle the reader's interest in the material. The examples are inter-mixed with the discussion to highlight and emphasize essential points the authors make in each chapter. The text illustrates concepts well under discussion, and does not become a long-winded recital of theory. The topics examined are fundamental to concurrency, and are well illustrated and discussed, but no one topic is examined extensively. The code examples are well written concerning the programming style, indentation and comments. A CD is provided, containing the codes from the book. In addition supplementary material consisting of presentation slides and an errata is provided on the author's WWW site, as well as on the CD. The book is up to date both on the topics of concurrency, and with the Java applets, code, and programs used to illustrate them. Later, as the Java language evolves, the examples may need to be updated, but for the time being the text well represents that state of the Java language. William F. Gilreath, Micron Technology, Inc., Boise Idaho

This paper describes AnnaBot, one of the first tools to verify correct use of Annotation-based metadata in the Java programming language. These Annotations are a standard Java 5 mechanism used to attach metadata to types, methods, or fields without using an external configuration file. A binary representation of the Annotation becomes part of the compiled “.class” file, for inspection by another component or library at runtime. Java Annotations were introduced into the Java language in 2004 and have become widely used in recent years due to their introduction in the Java Enterprise Edition 5, the Hibernate object-relational mapping API, the Spring Framework, and elsewhere. Despite that, mainstream development tools have not yet produced a widely-used verification tool to confirm correct configuration and placement of annotations external to the particular runtime component. While most of the examples in this paper use the Java Persistence API, AnnaBot is capable of verifying anyannotation-based API for which “claims”—description of annotation usage—are available. These claims can be written in Java or using a proposed Domain-Specific Language, which has been designed and a parser (but not the code generator) have been written.

The emergence of Unified Modeling Language (UML) as a standard for modeling systems has encouraged the use of automated software tools that facilitate the development process from analysis through coding. The UML state machine diagram is used for modeling the dynamic aspects of systems and includes many concepts that are not present in most popular programming languages, like Java or C++. There exists a gap between high level modeling language and a programming language. This paper proposes an approach to narrow the gap between multiple UML models and an implemented system. The narrowing of gap is achieved by generating compact and efficient Java code directly from UML state machine having sequential and concurrent substates. The code generation is achieved by creating a mapping between UML behavior and the Java programming language. Our model can work as a basis for automatic code generation for object-oriented systems.

: There is an increasing interest in recent years to use the Java(trade mark) programming language for implementing real-time systems. Recent advances in the Real-Time Specification for Java (RTSJ) have resulted in the introduction of new means for creating predictable real-time environments for Java programs. However, these new features also make the Java semantics more complex and the run-time behaviors of the Java programs more difficult to analyze. In this technical report, we describe a number of preliminary experiments we performed to study the features of the Sun Java Real-Time System (RTJ 1.0). We designed these experiments to verify the viability of the Real-Time Java language for the implementation of the Global Integrated Fire Control System (GIFC)-a component of the C2BMC element of the Ballistic Missile Defense System (BMDS). Our preliminary experiment shows that it is preferable to use only the Real-Time Java threads that use the heap memory and not the no-heap real-time threads for the GIFC software. However, such architecture cannot be implemented by using RTJ 1.0. Further experiments are needed to determine if the preferred architecture can be implemented with the upcoming RTJ 2.0, which will give programmers more control over the priority of the garbage collection.

In the context of a Computer Science Major in Indonesian higher education, Java programming language is not only one of the most essential programming languages courses but is also considered to be challenging to learn. This fact has led to the development of numerous mobile learning (m-learning) applications to assist learners in acquiring Java programming skills independently. Most existing Java learning assistants are presented on websites or computer platforms which can only be accessed when students open their computer or Laptop and it mostly focuses on enhancing coding abilities, and practical hands-on. While these aspects are crucial, understanding the programming concepts and guided practice are equally essential in fundamental Java programming learning. This paper presents the concept of practical coding exercises in an m-learning application, providing a new interactive approach for learners as an alternative tool for learning Java programming so they can learn Java programming concepts more frequently from their smartphones. The primary objective is to investigate the feasibility of the proposed m-learning prototype. The proposed application is expected to offer intuitive coding exercises and case study opportunities. Experimental results demonstrate that the overall functionality of the proposed application is feasible for future implementation, with a usability score of 84.

With the constant development of computer technology and the increasing complexity of software, the issues of efficient generation of program code are becoming more and more important. The use of modern models and methods of artificial intelligence (AI) to automate the process of creating program code is one of the promising areas of research in the field of software engineering. With the advent and development of neural networks and deep learning, the possibilities for automating the process of creating program code have expanded significantly. In addition, the growing complexity of software and the increased requirements for its quality and performance emphasize the relevance of researching the possibilities of using modern AI methods to generate program code. The purpose of the work is to analyze the quality of application of AI models in the generation of program code intended for the development of complex software systems by students of the “Software Engineering” training direction. In the course of the study, the subject area related to the application of the capabilities of modern AI models to generate program code was studied. Various approaches and technologies of AI were considered, as well as their use in the training of future software engineers. The study included the organization of queries to the ChatGPT-4o, Copilot, Google-gemini-1.5-pro, and YandexGPT models and subsequent comparative analysis of the software codes generated by these models. For sending and subsequent processing of requests, an automated client-server application was developed, which was used in the study of the potential of AI models for generating program code. The results obtained can be useful for teachers and students of the direction of training “Software Engineering”, as well as for software developers using AI models to automate programming processes and improve the quality of professional training.

Перспективний розвиток галузі розробки програмного забезпечення призвів до появи різноманітних шаблонів та стратегій маніпуляцій з базами даних та, відповідно інструментів, що їх реалізують. Одним з шаблонів проектування, що набуває все більшої популярності є Active Record. Цей шаблон дозволяє інкапсулювати всю логіку роботи з таблицею бази даних у сам клас моделі, завдяки чому зникає необхідність створювати додаткові сервісні класи, які будуть відповідати за CRUD операції. Однією з реалізацій цього підходу є ORM-система ActiveJDBC. ActiveJDBC розвивається як відкрите програмне забезпечення і є популярним варіантом для розробки додатків на Java, які взаємодіють з реляційними базами даних. Метою роботи є представлення процесу покращення користувацького досвіду при роботі з ORM-системою ActiveJDBC. Покращення достягається за рахунок автоматичної генерації коду, що дозволяє маніпулювати з ActiveJDBC об’єктами як з POJO. Методологія рішення представленого завдання складається в розробленні обробника анотацій, що дозволяє автоматично на етапі компіляції згенерувати код, що буде взаємодіяти з об’єктами ORM системи ActiveJDBC. Наукова новизна отриманих результатів полягає у тому, що вперше було розроблено програмне забезпечення, яке полегшує взаємодію з ActiveJDBC компонентами, та дозволяє додавати функціонал, який не був закладений у ActiveJDBC його розробником. Висновки. Досліджені підходи генерації програмного коду у мові програмування Java та розроблено обробник анотацій, що дозволяє автоматично на етапі компіляції згенерувати код, який буде взаємодіяти з об’єктами ORM системи ActiveJDBC. Розроблений інструмент дозволяє: вивільнити робочий час програміста від написання шаблонного коду, та зосередитись на вирішенні поставлених задач, а не на обслуговуванні інструмента взаємодії з базою даних; зменшити обсяг коду, що повинен пройти валідацію при проходженні процесу Code Review; підвищити читабельність отриманого коду, завдяки використанню геттерів та сеттерів, назви яких відповідають специфікації JavaBeans, та використанням патерна Будівельник.

Currently the Java programming language is popularly used in Internet-based systems, mobile and ubiquitous devices because of its portability and programability. However, inherently its performance is sometimes very limited due to interpretation overhead of class files by Java Virtual Machines (JVMs). In this paper, as one of the solutions to resolve the performance limitation, we present code generation and optimization techniques for a Java-to-C translator. Our compiler framework translates Java bytecode into C codes with preserving Java’s programming semantics, such as inheritance, method overloading, virtual method invocation, garbage collection, and so on. Moreover, our compiler translates for in Java into for in C instead of test and jump for better performance. Our runtime library fully supports Connected Limited Device Configuration (CLDC) 1.0 API’s.

This paper describes a system that accepts compact specifications of an intermediate code and target machine and produces program code for an integrated code generator and peephole optimizer. A compiler for most of C uses this packa.ge. It emits code comparable to PCCI’S, but it runs over five times faster on preliminary benchmarks. This compiler also runs over twice as fast as a version of pcc2 with a hand-coded, VAX-specific code generator. The code generators are produced as follows. A programmer describes a naive code generator by means of a non-procedural specification. The programmer also prepares a machine description for a retargetable peephole optimizer [2]. These two systems are used together to compile a testbed, and the compiler records each peephole optimization as it is made. This record and the specification of the naive code generator are compiled into a fast, integrated code generator and optimizer. This production code generator then takes the place of the slower “training” version. The production code generator and optimizer are integrated to the point that the code to be generated is communicated from one to the other by encoding it in the program counter, which obviates most inter-phase communication costs. Interpretive peephole optimizers have been driven by traces from retargetable peephole optimizers [3] and integrated with interpretive code generators [4], but the current work is distinguished by the production of a hard-coded, optimizing code generator. Historically, retargetable code generators (i.e., those not largely rewritten for each new machine)

With the advent of mobile learning, educational systems are changing. Mobile learning, also known as m-learning, is an educational system which enable learning process through mobile devices, such as handheld and tablet computers, smart phones, and mobile phones. In this paper we design a mobile application using gamification to learn algorithms and programming, specifically in Java programming language. The objective of the application is to improve learning motivation of students in a private university majoring in computer science. The design of the application is applying a model for e-Learning, in order to enhance students’ motivation and understanding for topic: introduction to Java programming. The application is developed because the need of fast-paced informatics competencies. In addition, Java programming is a subject which considered as attractive yet a difficult subject to learn. Therefore, approaches and methods to teach in this subject should be designed and delivered carefully. The usability testing result shows that the application considered as a usable application for each usability element. It is indicate that the application is potential to be used as learning alternatives in programming language. However there are some issues still remain related to the application’s features which are very important to enhance students’ motivation for learning algorithms and programming.

Supporting source-level performance analysis of programs written in data-parallel languages requires a unique degree of integration between compilers and performance analysis tools. Compilers for languages such as High Performance Fortran infer parallelism and communication from data distribution directives, thus, performance tools cannot meaningfully relate measurements about these key aspects of execution performance to source-level constructs without substantial compiler support. This paper describes an integrated system for performance analysis of data-parallel programs based on the Rice Fortran 77D compiler and the Illinois Pablo performance analysis toolkit. During code generation, the Fortran D compiler records mapping information and semantic analysis results describing the relationship between performance instrumentation and the original source program. An integrated performance analysis system based on the Pablo toolkit uses this information to correlate the program's dynamic behavior with the data parallel source code. The integrated system provides detailed source-level performance feedback to programmers via a pair of graphical interfaces. Our strategy serves as a model for integration of data-parallel compilers and performance tools.

In embedded systems a processor core must be designed with low power consumption, low cost and small silicon area in mind since program code often resides in on-chip ROM. To obtain small code size, not only the amount of instruction-level parallelism can be restricted by instruction sets, but also the encoding cost can be reduced by restricting the access to register files. However, communication among register files has to be supported by hardware, e.g. buses and wires, and compilers. In this paper, we propose a new type of architecture by limiting the encoding range to a subset of registers in a register file on the one hand, and keeping the overlap among different ranges on the other hand in order to support communication between all the functional units. We also propose the annotated conflict graph approach for modeling the range constraints in this architecture, which can be applied in combination with any scheduler. However, to overcome the phase coupling between address range assignment and scheduling in code generation, in this paper the address range constraints are transformed and integrated with the existing timing, resource and register file constraints. Constraint analysis techniques [9] are adapted to prune the search spaces based on those constraints. Results show that we can reduce code size up to 24.58% by applying our technique.

Graphical representation has long been used in the domain of software engineering to provide comprehension aids. Generic and query-based code browsers have contributed towards program comprehension through the provision of high-level customized structural views of the source code. Some research has already focused on combining the advantages of the two techniques through the representation of high-level query-based views using different data visualization techniques. However, little has been done towards the visualization of the query composition process itself. In this paper we develop a query engine for software structural analysis which provides a visual query interface over a high-level textual query language to eliminate the requirement for understanding the query language syntax. Our implementation is provided as an Eclipse plug-in, namely HyQ4J (which stands for hybrid query for Java).

Android developers can use both Java and Kotlin programming languages to create their own apps. Such programming languages provide exception handling facilities to improve apps' robustness (providing means to implement fault-tolerant measures) and maintainability (separating the error-handling code from the regular one). The Android architecture imposes complexity on the way apps handle exceptions, once exceptions may be raised in parts that are not responsible for handling this abnormal situation. A straightforward solution is to send the Exception Notification (EN) to its concerned handler. However, the way developers are using Android's inter-component communication mechanism to perform EN may lead to well-known exception handling drawbacks related to the usage of error/return code (e.g., decaying of code readability, programmability, and extensibility). To overcome this problem, we propose a pub/sub-based mechanism to perform EN between Android components called R-EventBus. We evaluate R-EventBus through a performance benchmark and by refactoring a set of apps from the F-Droid repository and comparing the original and refactored versions regarding behavior preservation and EN concern diffusion. Our results indicate that R-EventBus shows negligible performance issues, preserves the apps' behavior, and considerably improves the modularization of EN concern in the refactored apps.