How Do Java Programs Use Inheritance? An Empirical Study of Inheritance in Java Software

Reuse in polymorphic systems strongly depends on correct use of inheritance. There have been many efforts to check whether or not subtyping is correct. All of these approaches either restrict the use of inheritance customize the class hierarchies in an application specific way or use proof theoretical techniques. This is often too restrictive or even impossible-at least for practical use. In order to provide both flexibility and robustness the paper introduces the concept of weak conformance. This concept allows the specification of specialized classes that may be used in a polymorphic context. The main idea is to check conformance in the context of a concrete application. Furthermore, the paper demonstrates how the proposed concept can easily be integrated into any programming language and introduces an algorithm for checking robustness of an application. This algorithm detects all critical and illegal polymorphic method calls that may violate the robustness. Finally the paper discusses ways of handling critical calls, i.e., calls that can be proven correct by the developer but not by the type system.

SUMMARYOne of the characteristics of the increasingly widespread use of object‐oriented libraries and the resulting intensive use of inheritance is the proliferation of dependencies on abstract classes. Since abstract classes cannot be instantiated, they cannot be tested in isolation using standard execution‐based testing strategies. A standard approach to testing abstract classes is to instantiate a concrete descendant class and test the features that are inherited. This paper presents a structured approach that supports the testing of features in abstract classes, paying particular attention to ensuring that the features tested are those defined in the abstract class. Two empirical studies are performed on a suite of large Java programs and the results presented. The first study analyses the role of abstract classes from a testing perspective. The second study investigates the impact of the testing strategy on the programs in this suite to demonstrate its feasibility and to comment on the pragmatics of its use. Copyright © 2010 John Wiley & Sons, Ltd.

Object-oriented programming is a practical and useful programming methodology that encourages modular design and software reuse. Most object-oriented programming languages support data abstraction by preventing an object from being manipulated except via its defined external operations. In most languages, however, the introduction of inheritance severely compromises the benefits of this encapsulation. Furthermore, the use of inheritance itself is globally visible in most languages, so that changes to the inheritance hierarchy cannot be made safely. This paper examines the relationship between inheritance and encapsulation and develops requirements for full support of encapsulation with inheritance.

For several years, software engineers have debated the impact that inheritance mechanisms have on software development. Inheritance can be ignored until coding begins, or it can be used early during analysis to model conceptual abstractions; specifically, IS_A relations between classes in a problem domain. Unfortunately, the conceptual structuring relevant to analysis can conflict with the practice of code reuse. In this paper, we explain why this conflict arises and suggest ways of dealing with it. We review the basic facilities provided by inheritance mechanisms in object-oriented programming languages and survey their use in programming. Legitimations for the use of inheritance are described and evaluated. We conclude with a tentative proposal for the development of more powerful inheritance mechanisms.

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

Object-oriented programs cause a shift in focus from software units to the way software classes and components are connected. Thus, we are finding that we need less emphasis on unit testing and more on integration testing. The compositional relationships of inheritance and aggregation, especially when combined with polymorphism, introduce new kinds of integration faults, which can be covered using testing criteria that take the effects of inheritance and polymorphism into account. This paper demonstrates, via a set of experiments, the relative effectiveness of several coupling-based OO testing criteria and branch coverage. OO criteria are all more effective at detecting faults due to the use of inheritance and polymorphism than branch coverage.

ProtoMol is a high-performance framework in C++ for rapid prototyping of novel algorithms for molecular dynamics and related applications. Its flexibility is achieved primarily through the use of inheritance and design patterns (object-oriented programming). Performance is obtained by using templates that enable generation of efficient code for sections critical to performance (generic programming). The framework encapsulates important optimizations that can be used by developers, such as parallelism in the force computation. Its design is based on domain analysis of numerical integrators for molecular dynamics (MD) and of fast solvers for the force computation, particularly due to electrostatic interactions. Several new and efficient algorithms are implemented in ProtoMol. Finally, it is shown that ProtoMol's sequential performance is excellent when compared to a leading MD program, and that it scales well for moderate number of processors. Binaries and source codes for Windows, Linux, Solaris, IRIX, HP-UX, and AIX platforms are available under open source license at http://protomol.sourceforge.net.

OPINION article Front. Physiol., 05 January 2012Sec. Craniofacial Biology and Dental Research volume 2 - 2011 | https://doi.org/10.3389/fphys.2011.00119

BackgroundDespite focused initiatives to reduce device-associated infection among hospitalised patients, the practices US hospitals are currently using are unknown. We thus used a national survey to ascertain the use of...

Computational fluid dynamics (CFD) is a valuable tool for personalised, non-invasive evaluation of hemodynamics in arteries, but its complexity and time-consuming nature prohibit large-scale use in practice. Recently, the use of deep learning for rapid estimation of CFD parameters like wall shear stress (WSS) on surface meshes has been investigated. However, existing approaches typically depend on a hand-crafted re-parametrisation of the surface mesh to match convolutional neural network architectures. In this work, we propose to instead use mesh convolutional neural networks that directly operate on the same finite-element surface mesh as used in CFD. We train and evaluate our method on two datasets of synthetic coronary artery models with and without bifurcation, using a ground truth obtained from CFD simulation. We show that our flexible deep learning model can accurately predict 3D WSS vectors on this surface mesh. Our method processes new meshes in less than 5 [s], consistently achieves a normalised mean absolute error of $\leq$ 1.6 [%], and peaks at 90.5 [%] median approximation accuracy over the held-out test set, comparing favourably to previously published work. This demonstrates the feasibility of CFD surrogate modelling using mesh convolutional neural networks for hemodynamic parameter estimation in artery models.

Logic-based programming languages are increasingly applied as program query languages which allow developers to reason about the structure and behaviour of programs. To achieve this, the queried programs are reified as logic values such that logic quantification and unification can be used effectively. However, in many cases, standard logic unification is inappropriate for program entities, forcing developers to resort to overly complex queries. In this paper, we argue that such incidental complexity can be reduced significantly by customizing the unification algorithm. We present a practical implementation approach through inter-language reflection and open unification. These techniques are at the core of the logic program query language SOUL, through which we demonstrate custom unification schemes for reasoning over Smalltalk and Java programs. Queries written in this tailored version of SOUL can exploit advanced program matching strategies without increasing the incidental complexity of the queries.

Boar semen cryopreservation has a high potential in the swine industry, allowing the large-scale use of genetically superior animals, improving efficiency, product quality, helping to reduce the risk of disease spread and gathering needs from the market. From a genetic point of view, semen freezing is desirable for genetic diversification, favouring a more efficient reproduction as well as the constitution of germplasm banks, including for repopulation in case of disease outbreak. However, freezing this semen for long periods for practical use is limited by the reduced viability and fertilization potential caused to sperm during the cryopreservation process and consequently low conception rates and smaller litters after artificial insemination. In part, the decrease in the fertilizing power of frozen spermatozoa may be associated with oxidative damage due to excessive formation of Reactive Oxygen Species (ROS), osmotic stress and cell damage due to ice formation during cryopreservation. To suppress the damage caused by ROS, the present study was conducted to determine the impact of supplementation with three antioxidants, these being ascorbic acid, a-tocopherol and reduced glutathione, evaluating the parameters of semen quality, viability, total and progressive motility, vigour and agglutination rate after thawing. For this purpose, semen was collected from five boars, each being collected three times, at weekly intervals, always at the same time. Immediately after harvesting, the macroscopic (colour, appearance, and volume) and microscopic evaluation of the semen (mass motility, concentration, progressive individual motility, spermatic vigour and spermatic morphology) were evaluated. Subsequently, the semen was placed at 15°C for two hours and centrifuged at 800 x g for 10 minutes also at 15°C, removing the supernatant. For the freezing medium, a base medium consisting of a commercial MR-A extender, supplemented with 3% v/v glycerol, 10% v/v egg yolk and 0.20% w/v Sodium Dodecyl Sulfate (SDS) was used. The nine treatments used in the study were, respectively, ascorbic acid at concentrations of 100, 200 and 400μL, a-Tocopherol at concentrations of 200, 400 and 800μM and reduced Glutathione at concentrations of 2.5, 5 and 10 mg/l and numbered as T1 to T9, respectively. In the control group, semen was frozen in a medium without adding any antioxidant. The semen belonging to the different treatments and to the control was placed in 0.25ml insemination French straws and incubated at 6°C for two hours. The subsequent freezing was carried out in nitrogen vapours (-120°C) for ten minutes and immersed in liquid nitrogen after this period. After 7 days, the semen was thawed in a water bath at 37°C for 20 seconds, the straws dried on paper, placed on a microscope slide heated to 37°C and evaluated according to the parameters described above. Regarding the comparison between the different treatments, it was observed that the sperm viability obtained in the treatments with ascorbic acid as well as glutathione reduced, was not statistically different from the control group. Higher values of ascorbic acid and reduced glutathione reduced sperm viability after thawing. As for the use of a-tocopherol at a concentration of 400μM, the best results of the entire study were obtained, with sperm viability of 31.52% (±1.50). Regarding sperm motility and agglutination rate, a-tocopherol also showed the best results at the concentration of 200μM, in which the mean sperm motility was 2.57 ± 0.15 and 2.07 ± 0.15, respectively. The results of the present study allow us to infer that the addition of 200μM or 400μM of a-tocopherol to the swine semen-freezing medium has a positive effect on sperm viability parameters after thawing.

Statement of the problem. The need to successfully fulfill the targets of the national project entitled “Development of the export potential of the Russian education system” emphasizes the importance of broad interdisciplinary studies of international academic mobility as a factor of strengthening Russian influence in the world. The analysis of statistical data presented in the scientific literature of the research results confirms the presence of a number of educational and managerial problems at universities that restrain the influx of students from foreign countries to Russian universities. The purpose of the article is to theoretically substantiate the modular structure of the international academic mobility development program at a university. Methodology (materials and methods). The methodological basis of the research is a systematic approach that allows us to consider international academic mobility as a complex multidimensional phenomenon with internal integrity. The reliance on a multi-context approach ensures that the system of factors affecting the development of international academic mobility in universities is taken into account. Research results. The scientific novelty and theoretical significance of the results obtained lies in the substantiation of the modular structure of the program for the development of international academic mobility at a university, including conceptual-strategic, administrative-managerial, scientific-methodological and psychological-advisory modules. The practical significance of the results obtained is determined by the possibility of their use in university practice for analyzing existing experience and planning new directions for development of international academic mobility at a university. Conclusion. The development of a comprehensive program for the development of international academic mobility will allow universities to move from isolated events to the implementation of a scientifically based strategy for strengthening leadership positions in the international arena.

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.

: 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.