Christian Hovy

geb. Zoller

ASCII

E-mailhovy@informatik.uni-hamburg.de
AddressDKRZ, room 107
Telephone+49 40 460094-218
AddressInformatikum, room D-020
Telephone+49 40 42883-2261

Biography

Christian Hovy is research assistant at the Department of Informatics at the Universität Hamburg. There, he also studied Informatics with focus on Software Engineering and with Oceanography as minor subject. In early 2011 he received his Diploma degree. Besides his studies, Christian worked as a free software developer. Afterwards he worked for Workplace Solutions GmbH and was involved in several software development and consultancy projects.

For his diploma thesis, Christian developed the open source tool AccessAnalysis, an Eclipse plug-in for measuring the usage of access modifiers in Java projects.

His current research interests are software engineering practices in HPC. In the context of his doctoral thesis he works on testing methods for climate modeling. For his research, he collaborates with scientists from the Max Planck Institute for Meteorology and from the German Weather Service (DWD).

In 2014, Christian married and changed his last name from Zoller to Hovy. He is member of the Scientific Computing group since 2016, before that he was part of the Software Architecture/Software Engineering group.

Teaching

Wintersemester 2017/2018

Sommersemester 2017

Wintersemester 2016/2017

Sommersemester 2016

Publications

2017

  • Poster: FortranTestGenerator: Automatic and Flexible Unit Test Generation for Legacy HPC Code (Christian Hovy, Julian Kunkel), Frankfurt, ISC High Performance 2017, 2017-06-20
    BibTeX Publication
    Abstract: Unit testing is an established practice in professional software development. However, in high-performance computing (HPC) with its scientific applications, it is not widely applied. Besides general problems regarding testing of scientific software, for many HPC applications the effort of creating small test cases with a consistent set of test data is high. We have created a tool called FortranTestGenerator to reduce the effort of creating unit tests for subroutines of an existing Fortran application. It is based on Capture & Replay (C&R), that is, it extracts data while running the original application and uses the extracted data as test input data. The tool automatically generates code for capturing the input data and a basic test driver which can be extended by the developer to a meaningful unit test. A static source code analysis is conducted, to reduce the number of captured variables. Code is generated based on flexibly customizable templates. Thus, both the capturing process and the unit tests can easily be integrated into an existing software ecosystem.

2016

  • Towards Automatic and Flexible Unit Test Generation for Legacy HPC Code (Christian Hovy, Julian Kunkel), In Proceedings of the Fourth International Workshop on Software Engineering for High Performance Computing in Computational Science and Engineering, SEHPCCSE16, Salt Lake City, Utah, USA, 2016
    BibTeX DOI
    Abstract: Unit testing is an established practice in professional software development. However, in high-performance computing (HPC) with its scientific applications, it is not widely applied. Besides general problems regarding testing of scientific software, for many HPC applications the effort of creating small test cases with a consistent set of test data is high. We have created a tool called FortranTestGenerator, that significantly reduces the effort of creating unit tests for subroutines of an existing Fortran application. It is based on Capture & Replay (C&R), that is, it extracts data while running the original application and uses the extracted data as test input data. The tool automatically generates code for capturing the input data and a basic test driver which can be extended by the developer to an appropriate unit test. A static source code analysis is conducted, to reduce the number of captured variables. Code is generated based on flexibly customizable templates. Thus, both the capturing process and the unit tests can easily be integrated into an existing software ecosystem. Since most HPC applications use message passing for parallel processing, we also present an approach to extend our C&R model to MPI communication. This allows extraction of unit tests from massively parallel applications that can be run with a single process.

2012

  • Measuring Inappropriate Generosity with Access Modifiers in Java Systems (Christian Zoller, Axel Schmolitzky), In The Joint Conference of the 22nd International Workshop on Software Measurement (IWSM) and the 7th International Conference on Software Process and Product Measurement (Mensura), pp. 43–52, IWSM/MENSURA2012, Assisi, Italy, 2012
    BibTeX DOI
    Abstract: Every element of a software architecture, e.g. a subsystem, package, or class, should have a well-defined interface that exposes or hides its subelements according to the principles of information hiding and encapsulation. Similar to other object-oriented programming languages, Java supports defining interfaces on several levels. The accessibility of types, methods, and fields can be restricted by using access modifiers. With these modifiers, developers are able to define interfaces of packages and classes tailored for different groups of clients. However, in programming practice, types and members seem to be often declared with too generous access modifiers, i.e. they are accessible by more clients than necessary. This can lead to unwanted dependencies and software quality degradation. We developed an approach to measuring the usage of access modifiers for types and methods in Java by defining two new software metrics: Inappropriate Generosity with Accessibility of Types (IGAT) and Inappropriate Generosity with Accessibility of Methods (IGAM). Furthermore, we created a tool called AccessAnalysis that calculates and displays these metrics. Using AccessAnalysis, we conducted a survey on twelve open source Java projects. The results support our assumption that access modifiers are often chosen more generously than necessary. On average, around one third of all type and method access modifiers fall into this category. Especially top-level types are almost always declared as public, so that package interfaces typically expose more types than necessary. Only 2% of all investigated top-level types are encapsulated inside their package.
  • AccessAnalysis - A Tool for Measuring the Appropriateness of Access Modifiers in Java Systems (Christian Zoller, Axel Schmolitzky), In Proceedings of the 2012 IEEE 12th International Working Conference on Source Code Analysis and Manipulation, pp. 120–125, IEEE Computer Society (Los Alamitos, CA, USA), SCAM 2012, Riva del Garda, Trento, Italy, 2012
    BibTeX DOI
    Abstract: Access modifiers allow Java developers to define package and class interfaces tailored for different groups of clients. According to the principles of information hiding and encapsulation, the accessibility of types, methods, and fields should be as restrictive as possible. However, in programming practice, the potential of the given possibilities seems not always be fully exploited. AccessAnalysis is a plug-in for the Eclipse IDE that measures the usage of access modifiers for types and methods in Java. It calculates two metrics, Inappropriate Generosity with Accessibility of Types (IGAT) and Inappropriate Generosity with Accessibility of Methods (IGAM), which represent the degree of deviation between actual and necessary access modifiers. As an approximation for the necessary access modifier, we introduce the notion of minimal access modifiers. The minimal access modifier is the most restrictive access modifier that allows all existing references to a type or method in the entire source code of a system. AccessAnalysis determines minimal access modifiers by static source code analysis using the build-in Java DOM/AST API of Eclipse.

2011

  • Zwei Metriken zum Messen des Umgangs mit Zugriffsmodifikatoren in Java (Christian Zoller, Axel Schmolitzky), In Software Engineering 2011 – Proceedings, Lecture Notes in Informatics (P-183), pp. 183–194, Gesellschaft für Informatik (Bonn, Germany), SE2011, Karlsruhe, Germany, 2011
    BibTeX URL
    Abstract: Wie viele objektorientierte Programmiersprachen bietet Java die Möglichkeit, über Modifikatoren die Zugreifbarkeit von Typen, Methoden und Feldern in mehreren Stufen einzuschränken. So können für unterschiedliche Gruppen von Klienten differenzierte Schnittstellen definiert werden. Es zeigt sich jedoch, dass in der Praxis die gebotenen Möglichkeiten nicht voll ausgeschöpft werden. Wir beschreiben zwei neue Metriken, mit denen sich der angemessene Umgang mit Zugriffsmodifikatoren in Java messen lässt, sowie ein Werkzeug, das diese Metriken berechnet und beim Einschränken von Schnittstellen hilfreich sein kann. Wir haben unseren Ansatz in zwei kommerziellen Projekten und zwölf Open-Source-Projekten erprobt. Dabei wurde deutlich, dass Zugriffsmodifikatoren oft großzügiger gewählt werden als notwendig.

Talks

More Teaching

Wintersemester 2016/2017

Office Days

Wintersemester 2016/2017

DKRZ         | room 107   |        | Tuesday (?) | Wednesday | Thursday | Friday
Informatikum | room D-213 | Monday | Tuesday (?) |           |          |