Change impact analysis for java programs and applications

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

FCA–CIA: An approach of using FCA to support cross-level change impact analysis for object oriented Java programs

: The focus of this research is pertaining the role of indigenous entrepreneurs in Garut, West Java, Indonesia, for period of 1903-1942. This study aims to determine the role of indigenous entrepreneurs in dealing with the Dutch colonialism and its impact to Garut; and the background of the factors that causing the development of Muslims reformers in Garut. The employed research method of this research is the historical research method, which includes four stages: namely: Heuristics, Criticism, Interpretation, and Historiography. The theories, which used to determine the role of indigenous entrepreneurs in dealing with the Dutch colonialism in Garut, 1903-1942, are the concepts of status and role; network theory; and cultural theory of migration. The results of this research indicate that indigenous entrepreneurs in Garut, West Java, have given their roles in dealing with the Dutch colonialism, are contributing in developing socio-economic life, especially trading activities, in Garut; the indigenous entrepreneurs in “Pasar Baru” (New Market) of Garut play a role in the development of Islamic reformist organizations, such as the SI (Syarekat Islam or Islamic League) and Muhammadiyah (Followers of Prophet Muhammad) organization, and other education institutions in Garut; and indigenous entrepreneurs led by batik merchants, H.M. Djamhari, has a major role in supporting the ideals of the pioneering independence by becoming the permanent donors of Islamic organizations or individual figures of the Indonesian national movement. KEY WORDS : Indigenous entrepreneurs; Batik Merchants; Islamic Reformist Organization; National and Local Figures in Garut. About the Authors: Sopaat Rahmat Selamet , M.Hum. is a Lecturer of Islamic Civilization History at the STAIM (College of Muhammadiyah Islamic Religion) in Bandung, West Java, Indonesia. Dr. Setia Gumilar is a Lecturer and Dean at the Faculty of Adab and Humanities UIN (State Islamic University) Sunan Gunung Djati in Bandung, West Java, Indonesia. E-mails address: kartika.noerhasan@gmail.com and gumilarsetia@yahoo.com Suggested Citation: Selamet, Sopaat Rahmat & Setia Gumilar. (2018). “The Roles of Indigenous Entrepreneurs in Dealing with the Dutch Colonialism in Garut, West Java, 1903-1942” in TAWARIKH: Journal of Historical Studies , Volume 10(1), October, pp.45-58. Bandung, Indonesia: Minda Masagi Press owned by ASPENSI, ISSN 2085-0980 (print). Article Timeline: Accepted (August 24, 2018); Revised (September 29, 2018); and Published (October 30, 2018).

Assurance cases are used to communicate and assess confidence in critical system properties such as safety and security. Historically, assurance cases have been manually created documents, which are evaluated by system stakeholders through lengthy and complicated processes. In recent years, model-based system assurance approaches have gained popularity to improve the efficiency and quality of system assurance activities. This becomes increasingly important, as systems becomes more complex, it is a challenge to manage their development life-cycles, including coordination of development, verification and validation activities, and change impact analysis in inter-connected system assurance artifacts. Moreover, there is a need for assurance cases that support evolution during the operational life of the system, to enable continuous assurance in the face of an uncertain environment, as Robotics and Autonomous Systems (RAS) are adopted into society. In this paper, we contribute ACCESS — Assurance Case Centric Engineering of Safety–critical Systems, an engineering methodology, together with its tool support, for the development of safety–critical systems around evolving model-based assurance cases. We show how model-based system assurance cases can trace to heterogeneous engineering artifacts (e.g. system architectural models, system safety analysis, system behaviour models, etc.), and how formal methods can be integrated during the development process. We demonstrate how assurance cases can be automatically evaluated both at development and runtime. We apply our approach to a case study based on an Autonomous Underwater Vehicle (AUV).

This work investigates the application of deductive verification techniques to safety critical Java programs, in particular RTSJ programs. A focus is put on the formalization of the RTSJ memory model in dynamic logic, the utilization of a region-based memory model for ensuring non-interference and a design-by-contract based approach for the formal specification and verification of worst case memory consumption.

Scala is a new programming language developed at EPFL and incorporating the most important concepts of object-oriented and functional languages. It aims at integrating well with the Java and .NET platforms: their respective libraries are accessible without glue code, and the compiler can produce programs for both virtual machines. This thesis focuses on the compilation of two important concepts of Scala : mixin inheritance and run time types. The compilation techniques are presented in the context of the Java virtual machine, but could be adapted easily to other similar environments. Mixin inheritance is a relatively recent form of inheritance, offering new capabilities compared to single inheritance, without the complexity of multiple inheritance. We propose two implementation techniques for mixin inheritance: code copying and delegation. The implementation used in the Scala compiler is then presented and justified. Run time types make it possible for a program to examine the type of its values during execution. This possibility is interesting in itself, offering new capabilities to the programmer. Furthermore, run time types are also required to implement other high level concepts, like pattern matching, type-safe serialisation and reflection. We propose an implementation technique based on the representation of types as values, and show how to use the run time types of the underlying virtual machine to implement those of Scala. The techniques presented in this thesis have been implemented in our Scala compiler, scalac. This enabled us to evaluate these techniques, in particular their impact on the performances of programs. This evaluation was performed on several real, non-trivial programs.

Correctness of software systems can be proven by using static verification techniques. Static verifiers such as Spec# and ESC/Java have been developed for object-oriented languages. These verifiers have shown that static verification can be applied to object-oriented languages such as C# and Java. However, these verifiers are not easy to use, as they introduce many new concepts that programmers have to learn. To apply these verifiers to a real project, one has to modify existing code by adding contracts and annotations such as pure method marks or ownership information. Eiffel supports Design by Contract. Current libraries and programs are therefore already annotated with contracts. The goal of this thesis is to develop an automatic verifier for Eiffel which can prove existing code without the need of further annotations. The main features supported by the tool are agents and dynamic invocation. The tool, called EVE Proofs, translates Eiffel programs to Boogie and runs a fully automatic theorem prover to check correctness of the code. EVE Proofs is integrated in EVE, the Eiffel Verification Environment. This integration enables Eiffel programmers to use it directly from the programming environment. To reason about framing of routines, one needs modifies clauses. To prove existing Eiffel code, we implemented an automatic extraction of modifies clauses. Although the extraction of modifies clauses is limited, it enables us to prove examples with simple frame conditions. To show the feasibility of EVE Proofs, we present some examples which can be successfully verified. The examples include the command pattern to show the verification of agents and the strategy pattern to show the verification of dynamic invocation.

The time has come when you are almost ready to start using Java to write some programs. Before you do, though, you need to understand something about the process of programming. Programming is a highly structured process; some might even call it a discipline. Good programming requires that the programmer adopt a sensible, structured, and measured approach. Above all it requires that the programmer doesn't panic!

This paper describes a just-in-time (JIT) Java1 compiler for the Intel® Itanium® processor. The Itanium processor is an example of an Explicitly Parallel Instruction Computing (EPIC) architecture and thus relies on aggressive and expensive compiler optimizations for performance. Static compilers for Itanium use aggressive global scheduling algorithms to extract instruction-level parallelism. In a JIT compiler, however, the additional overhead of such expensive optimizations may offset any gains from the improved code.In this paper, we describe lightweight code generation techniques for generating efficient Itanium code. Our compiler relies on two basic methods to generate efficient code. First, the compiler uses inexpensive scheduling heuristics to model the Itanium microarchitecture. Second, the compiler uses the semantics of the Java virtual machine to extract instruction-level parallelism.

: This thesis entitled “KIPRAH POLITIK PAGUYUBAN PASUNDAN PERIODE 1927-1959”. The author takes the topic of Paguyuban Pasundan with the above title, because it is based on the results of the study of literature by the author, that there is still the lack of works that discuss Paguyuban Pasundan, especially about political activities. The main issues that will be raised in this thesis is that Paguyuban Pasundan is not limited active in social and cultural sectors but also actively engaged in politics. Based on the main issue can be developed into three formulation of research: 1) What is the background to the Paguyuban Pasundan ? 2) How is the political role of the Paguyuban Pasundan period 1927-1959 ? 3) How is the end of political struggle Paguyuban Pasundan in 1959 ? The method used is the historical method which consists of four stages, namely Heuristic, Criticism, Interpretation, Historiography, and to be helped by using an interdisciplinary approach from the social sciences (especially of Sociology and Politics). The technique that author uses is the study of literature related to the theme of the author analyzed. Based on the results of the study of literature by the author, Paguyuban Pasundan period 1927-1959 has an important role, especially in the political field. In the period 1927-1942 establishing PPPKI, GAPI and active in the Volksraad. The period of 1942-1945 some of its members active in the formation of Japanese agencies such as newspapers Tjahaja, PETA and Java Hokokai. Period 1945-1950 actively opposed the establishment of Negara Pasundan founded by the Dutch and the last period of 1950-1959 which Paguyuban Pasundan involvement in the 1955 general election.

Accurately predicting program behaviors (e.g., memory locality, method calling frequency) is fundamental for program optimizations and runtime adaptations. Despite decades of remarkable progress, prior studies have not systematically exploited the use of program inputs, a deciding factor of program behaviors, to help in program dynamic optimizations. Triggered by the strong and predictive correlations between program inputs and program behaviors that recent studies have uncovered, the dissertation work aims to bring program inputs into the focus of program behavior analysis and program dynamic optimization, cultivating a new paradigm named input-centric program behavior analysis and dynamic optimization.;The new optimization paradigm consists of three components, forming a three-layer pyramid. at the base is program input characterization, a component for resolving the complexity in program raw inputs and extracting important features. In the middle is input-behavior modeling, a component for recognizing and modeling the correlations between characterized input features and program behaviors. These two components constitute input-centric program behavior analysis, which (ideally) is able to predict the large-scope behaviors of a program's execution as soon as the execution starts. The top layer is input-centric adaptation, which capitalizes on the novel opportunities created by the first two components to facilitate proactive adaptation for program optimizations.;This dissertation aims to develop this paradigm in two stages. In the first stage, we concentrate on exploring the implications of program inputs for program behaviors and dynamic optimization. We construct the basic input-centric optimization framework based on of line training to realize the basic functionalities of the three major components of the paradigm. For the second stage, we focus on making the paradigm practical by addressing multi-facet issues in handling input complexities, transparent training data collection, predictive model evolvement across production runs. The techniques proposed in this stage together cultivate a lifelong continuous optimization scheme with cross-input adaptivity.;Fundamentally the new optimization paradigm provides a brand new solution for program dynamic optimization. The techniques proposed in the dissertation together resolve the adaptivity-proactivity dilemma that has been limiting the effectiveness of existing optimization techniques. its benefits are demonstrated through proactive dynamic optimizations in Jikes RVM and version selection using IBM XL C Compiler, yielding significant performance improvement on a set of Java and C/C++ programs. It may open new opportunities for a broad range of runtime optimizations and adaptations. The evaluation results on both Java and C/C++ applications demonstrate the new paradigm is promising in advancing the current state of program optimizations.

The platform neutrality of Java programs allows them to run on heterogeneous computers. In a distributed environment, however, Java programs often cause performance problems because they are not implemented for specific clients, so their implementation conflicts with their usage patterns at the client side. In this paper, we present a mechanism to address this problem by optimizing Java programs using a program specialization technique. Unlike traditional program specialization, our specialization method does not encode the result of specialization only into run-time code. Instead, it encodes the values of multi-valued static expressions into indexed data structure that is referenced by run-time code, and single-valued static expressions into run-time code. With this approach, we can address the code explosion problem of traditional program specialization. In a preliminary implementation, we achieved improvement in performance up to a factor of 3 with very low space requirements.

Mark Watson Morgan Kaufmann Publishers, San Francisco, 1997, 377 pp. ISBN 1-55860-420-0, $44.95 This book is well written and organized to cover how to apply AI (Artificial Intelligence) techniques for practical Internet and Intranet tools by using the Java programming language. In the book, the author uses neural network and genetic algorithms to develop distributed systems that are applied for the Internet and Intranets, such as client/server model and information retrieval tool and so on. Part 1 begins with a good general introduction to AI. The history and survey of Artificial Intelligence research are given briefly. In addition, symbolic processing versus neural networks approaches are discussed. This author opts to use neural network to develop example Internet/Intranet systems in the book. Part 2 consists of Java programs developed for AI, neural networks, genetic algorithms, natural language processing, and expert systems. Chapter 2 illustrates Graphical User Interface (GUI) class that is derived from Applet and Canvas classes in Java, which is used in most example programs in the book. Chapter 3 introduces a frame data structure that is used as a message in distributed systems in the later chapters. Chapter 4 shows neural network classes developed in Java and its theory and implementation. Chapter 5 explains the genetic algorithms and the Java genetic algorithm classes. Chapter 6 describes how to develop and implement natural language processing classes using Java. Chapter 7 shows how to share data objects in distributed systems. For example, distributed AI agent classes are developed to share data objects, WWW data collection agent classes are shown to retrieve documents in the Internet, and small POP (Post Office Protocol) mail classes are developed to send and receive mails. Chapter 8 illustrates how to develop expert systems by using Java Jess, which is based on OPS5/CLIPS expert systems. Part 3 explains how to generate and implement the projects using the Java classes that are developed in Part 2. Chapter 9 shows the project that demonstrates the use of genetic algorithms in chapter 5 to control enemy ships in a scrolling arcade game. Chapter 10 describes the real-time handwriting recognition system developed by using the neural network classes in chapter 4. Chapter 11 illustrates a greedy algorithm to optimize neural networks that is based on the author’s hand-tuning neural training data. Chapter 12 improves neural network training data by applying genetic algorithms, to discard bad training data and to avoid discarding good training data. Chapter 13 describes the distributed natural language processing system that uses natural language processing classes in chapter 6. The data structures in chapter 2 are used to store historical data in a separate server application on any other computer in the Internet or Intranets. The final chapter provides the design and implementation of a complete agent-based information retrieval tool for the Internet. The retrieved documents are stored in ASCII or HTML format. This book is a very good reference book for anyone interested in developing systems using Java in distributed environments, especially applying AI techniques. Also, the author provides the CD-ROM that includes the source code for Java classes developed in the book. Haklin Kimm, University of Tennessee

Blora Regency is one of regencies in Central Java conducting simultaneously the Complete Systematic Land Registration Program (PTSL) whose responsibility is delegated to the National Land Agency (BPN) Blora. In doing filing related to the file recapitulation, BPN Blora create a policy for the provision of Parent Number meantime to ease the recapitulation of the field which will be registered in PTSL. The purpose of this study was to analyze the Complete Systematic Land Registration Program (PTSL), factors that become obstacles in the implementation of PTSL and to determine the policy of the Master Numbers While (NIS) as a solution Blora District Land Office in the implementation of PTSL. The method used in this research is juridical empirical specification is descriptive analytical research and data collection was obtained from library research and interviews. After data collection is done, then the data is analyzed qualitatively. It can be concluded that the implementation of Complete Systematic Land Registration Program (PTSL) has many constraints among which the cost of land tax payable, the limited number of human resources and infrastructure, land disputes absente, maximum advantages and wastelands and the difficulty of applying the principle of contradictoire delimitatie. To overcome these obstacles BPN Blora do some solutions, among others, added the officer measurement with tool support, expand facilities and infrastructure, especially computers and printers, repair Internet network as well as the policy of Identification Number While (NIS) as a solution to the District Land Office Blora in the implementation PTSL that facilitate more efficient file search. Keywords: Land Registration; Identification Number While (NIS); PTSL.

MORPHOLOGICAL AND THERMAL PROPERTIES OF ALKALI TERATED BACTERIAL CELLULOSE FROM COCONUT WATER . Alkali treatment is one ofwide chemical treatment for removing non cellulosic materials and other impurities of bacterial cellulose (BC). Presently, BC produced by synthetic medium such as Schramm Hestrin or coconut water fermentation using pure culture of Acetobacter xylinum . In this research BC produced from coconut water fermentation using inoculums as suspension of mixture culture of bacteria A. xylinum in coconut water which commercialised inWest Java (Cianjur). Purpose of this research is to know the native and the effect of alkali treatment on the BC (heterofermentive) with evaluation of morphological, elemental analysis and thermal properties by Scanning ElectronMicroscope (SEM)-Energy Dispersive X-ray Spectroscopy (EDX) and Thermo-Gravimetry Analysis (TGA), respectively. Observation on morphological surface of native BC showes that there were noncellulosic materials entangled on the network of cellulose fibrils whichwere identified by EDX analysis as sodium(Na),magnesium(Mg), aluminium (Al), silica (Si) and potassium (K) in addition to carbon (C) and oxygen(O). On thermal analysis, stepwise of decomposition are observed on the native BC indicating the presence of non-cellulosic components which decomposed at different temperatures.While the alkali- treated BC sheet shows a single decomposition stage. The amount of residue formed after alkali treatment was relatively lower than native BC. Thermal degradation properties of the BC produced from coconut water was higher than that of BC belonging to synthetic medium. Based on this data, it is concluded that alkali treated cellulose can be used as a reasonable substitute for various non biodegradable synthetic polymers for large scale industrial in specific application