@article {Vokac.2006.1,
	title = {An Efficient Tool for Recovering Design Patterns From C++ Code},
	journal = {Journal of Object Technology},
	volume = {5},
	number = {1},
	year = {2006},
	month = {January/February},
	pages = {139-157},
	abstract = {Design Patterns are informal descriptions of tested solutions to recurring problems. Most design tools have little or no support for documenting the presence and usage of patterns in code. Reverse engineering is therefore often required to recover Design Patterns from code in existing projects. Knowledge of what Design Patterns have been used can aid in code comprehension, as well as support research. Since pattern descriptions are abstract and informal, they offer no algorithmic translation into concrete code. Some patterns prescribe class structures that are easy to recognize, while others lead to structures that are difficult or impossible to recognize. This work presents a tool that can recover five different design patterns from C++ code with high precision and at a speed of 3x10^6 LOC/hr. This makes it suitable for analysis of large (multi-millon LOC) systems.},
	author = {Vok{\'a}c, Marek}
}
@phdthesis {Vokac.2005.2,
	title = {On the Practical Use of Design Patterns},
	year = {2005},
	school = {University of Oslo},
	type = {phd},
	abstract = {This thesis investigates the empirical evidence for the usefulness of design patterns, in the context of software maintenance. Advocates of design patterns claim general benefits in the form of higher flexibility, easier maintenance and reduced development time, though there is mostly only anecdotal evidence to support these claims. The thesis reports on empirical research that has been conducted in three related areas: the effects of design patterns on maintenance effort and correctness; the connection between design patterns and corrective maintenance needs, and the utility of design patterns in organizing the development process. The presence of design patterns in the code can have a significant effect on the effort needed to perform maintenance tasks, and the correctness of the results. The effects are strongly dependent on the expertise of the developers-a pattern that is beneficial to an expert, may cause a sharp increase in effort and a reduced correctness for a novice or intermediate developer. However, some patterns are simple and intuitive enough that they provide benefits to all types of developers, even those who lack knowledge of the particular pattern, or even design patterns in general. The presence of design patterns can also be correlated with the need for corrective maintenance, i.e., the error rates in the parts of the code conforming to the patterns, relative to the code at large. Some patterns are correlated with complex program structures that are prone to errors, while other patterns result in simple, less connected structures with lower error rates. Assuming that the patterns are used appropriately, this correlation can be used as a predictive or diagnostic tool to determine areas of the code that need particular design attention from expert developers. Design patterns can also be used in the organization of the development team. Teams are often organized around functional areas or around layers in the code (such as a Web front end or a database-related back end). An alternative, when the architecture of the system is expressed using patterns, is to organize the team around the patterns themselves, so that individual developers work with all the code involved in a pattern, across other boundaries. This can aid in the implementation of complex architectures, for example J2EE applications. Empirical evidence for these contributions was gathered through a combination of controlled experiments and case studies. Realism was ensured by using paid, professional developers as experimental subjects. In the case studies, industrial projects were examined and a large scale analysis of industrial C++ code performed. Research methods in the field were advanced both by the scale, design and realism of the experiment, and by the creation and validation of a tool for extracting design patterns from C++ code at a high precision and speed.},
	author = {Vok{\'a}c, Marek}
}
@inproceedings {Vokac.2005.3,
	title = {Using a Domain-Specific Language and Custom Tools to Model a Multi-Tier Service-Oriented Application-Experiences and Challenges},
	journal = {Models 2005, Montego Bay, Jamaica October 2-7},
	year = {2005},
	note = {ISSN: 0302-9743 ISBN: 3-540-29010-9 DOI: 10.1007/11557432\_37},
	month = {October 2005},
	pages = {492-506},
	publisher = {Springer-Verlag GmbH},
	type = {1},
	address = {Heidelberg},
	abstract = {A commercial Customer Relationship Management application of approx. 1.5 MLOC of C++ code is being reimplemented, in stages, as a service-oriented, multi-tier application in C$\#$ on Microsoft .NET. We have chosen to use a domain-specific language both to model the external service-oriented interfaces, and to manage the transition to the internal, object-oriented implementation. Generic UML constructs such as class diagrams do not capture enough semantics to model these concepts. By defining a UML Profile that incorporates the concepts we wish to model, we have in effect created a Domain-Specific Language for our application. The models are edited using Rational XDE, but we have substituted our own code generator. This generator is a relatively generic text-substitution engine, which takes a template text and performs substitutions based on the model. The generator uses reflection to convert the UML and Profile concepts into substitution tags, which are in turn used in the template text. In this way, we can translate the semantics of the model into executable code, WSDL or other formats in a flexible way. We have successfully used this approach on a prototype scale, and are now transitioning to full-scale development.},
	isbn = {3-540-29010-9},
	doi = {10.1007/11557432_37},
	author = {Vok{\'a}c, Marek and Jens M. {Glattetre} and Williams, Clay and Briand, Lionel Claude}
}
@article {Vokac.2004.2,
	title = {A Controlled Experiment Comparing the Maintainability of Programs Designed With and Without Design Patterns - a Replication in a Real Programming Environment},
	journal = {Empirical Software Engineering},
	volume = {9},
	number = {3},
	year = {2004},
	pages = {149-195},
	abstract = {Software "Design Patterns" seek to package proven solutions to design prob- lems in a form that makes it possible to find, adapt and reuse them. To support the industrial use of Design Patterns, this research investigates when, and how, using patterns is beneficial, and whether some patterns are more di\pmcult to use than others. This paper describes a replication of an earlier controlled experiment on Design Patterns in maintenance, with major extensions. Experimental realism was increased by using a real programming environment instead of pen and paper, and paid professionals from multiple major consultancy companies as subjects. Measurements of elapsed time and correctness were analyzed using regression models and an estimation method that took into account the correlations present in the raw data. Together with on-line logging of the subjects{\textquoteright} work, this made possible a better qualitative understanding of the results. The results indicate quite strongly that some patterns are much easier to understand and use than others. In particular, the Visitor pattern caused much confusion. Conversely, the patterns Observer and, to a certain extent, Decorator were grasped and used intuitively, even by subjects with little or no knowledge of patterns. The implication is that Design Patterns are not universally good or bad, but must be used in a way that matches the problem and the people. When approaching a program with documented Design Patterns, even basic training can improve both the speed and quality of maintenance activities},
	author = {Vok{\'a}c, Marek and Tichy, W. and Sj{\o}berg, Dag Ingar Kondrup and Arisholm, Erik and Aldrin, M.}
}
@article {Vokac.2004.1,
	title = {Defect Frequency and Design Patterns: an Empirical Study of Industrial Code},
	journal = {IEEE Transactions on Software Engineering},
	volume = {30},
	number = {12},
	year = {2004},
	month = {Dec},
	pages = {904-917},
	abstract = {Software {\textquoteleft}{\textquoteleft}Design Patterns{\textquoteright} seek to package proven solutions to design problems in a form that makes it possible to find, adapt and reuse them. A common claim is that a design based on properly applied patterns will have fewer defects than more ad hoc solutions. This case study analyzes the weekly evolution and maintenance of a large commercial product (C++, 500,000 LOC) over three years, comparing defect rates for classes that participated in selected Design Patterns to the code at large. We found that there are significant differences in defect rates among the Patterns, ranging from 63,\% to 154,\% of the average rate. We developed a new set of tools able to extract design pattern information at a rate 3 imes10^6 lines of code per hour, with relatively high precision. Based on a qualitative analysis of the code and the nature of the Patterns, we conclude that the Observer and Singleton patterns tend to be used in complex parts, and so can serve as indicators of code that requires special attention. Conversely, code designed with the Factory pattern is less complex or less central, and consequently has lower defect rates. Template Method was used in both simple and complex situations, leading to no clear tendency.},
	author = {Vok{\'a}c, Marek}
}
@misc {SE.7.Glattetre.2004,
	title = {Generating Service Descriptions and Code From Reusable Models},
	howpublished = {Practitioner{\textquoteright}s Report. ECOOP 2004, Oslo, Norway},
	year = {2004},
	abstract = {Data models have a longer lifetime than the storage platform or technology they are implemented on at any given time. The models tend to change relatively slowly, and are usually described by some form of platform-in{\l}notde{\l}notpendent dictionary, though this may be in a proprietary form. It is then desirable to generate platform- and technology specific data definitions and persistence layers from such a description, as technology changes over time. We have implemented a code generator in C\# that works using text substitution. It takes a plain-text template as input, and combines it with model data to produce a specific output. Within the generator, the dictionary is represented by a thin object layer. C\# attributes are used to denote the roles of the dictionary objects, and reflection is used to load and activate these objects as substitution tags. Occurrences of the tags in the templates are then replaced with actual values from the dictionary by the generator. In this way, we have successfully generated a C\# persistence layer for a legacy database, using its proprietary dictionary and newly written template files. The principle can equally be applied to descriptions of high-level functional services. Service access technology, for instance COM, CORBA or Web Services varies on a shorter timescale than do the services themselves, analogous to the variation of storage technology relative to data models. The same code generator has been used to generate service descriptions, based on platform-independent definitions in UML. Rational XDE was used to create the service definitions, and a th{\l}notin object layer encapsulated the XDE data model for the code generator. By creating the proper template files, we can generate both WSDL and COM IDL descriptions for our services, and even C\# implementation shells. Platform dependency is thus introduced through the templates, and the results may be reverse-engineered to derive an updated, platform-dependent model if needed. This approach achieves a high level of reuse, by concentrating on reusing descriptions instead of concrete, platform-dependent implementations. We have successfully used it as the basis for multiple commercial products within the same product family/line.},
	author = {Glattetre, J. and Vok{\'a}c, Marek}
}
@inproceedings {SE.5.Vokac.2004,
	title = {Using a Reference Application With Design Patterns to Produce Industrial Software},
	journal = {PROFES 2004},
	year = {2004},
	pages = {333-347},
	publisher = {Springer-Verlag},
	type = {1},
	address = {Kansai Science City, Japan},
	abstract = {System architectures are described in abstract terms, often using Design Patterns. Actual reuse based on such descriptions requires that each development project derive a concrete architecture from the chosen Patterns, and then implement it in code. This paper describes a case study of an industrial development project that adopted a reference application as a starting point, in order to avoid the need to design a complete architecture. Reference applications are usually made by platform or component vendors. Such applications are used to provide executable examples of best practices, for a particular platform, component set, or other technology. In this case study, the Pet Store application for the J2EE platform was chosen. Pet Store is documented by Design Patterns and is also available as source code. The development consisted of replacing the application logic, while keeping the architecture intact. The project was thus transformed from an ab initio development project into a major reuse/modification project. This development project was part of a software process improvement effort looking at processes for and with reuse. Our results indicate that this approach works well, provided that the functional and non-functional requirements of the project match those of the reference application. The development time was shortened by approximately one third relative to the original estimate, and a well-designed application was produced despite lack of experience with the platform and n-layer architectures. Surprisingly, the production deployment to a different application server was still problematic, even though the original reference application was available as a sample for that server.},
	author = {Vok{\'a}c, Marek and Jensen, O.}
}
@inbook {Sjoberg.2003.1,
	title = {Challenges and Recommendations When Increasing the Realism of Controlled Software Engineering Experiments},
	booktitle = {Empirical Methods and Studies in Software Engineering: Experiences from ESERNET},
	series = {Lecture Notes in Computer Science, Volume 2765},
	year = {2003},
	pages = {24-38},
	publisher = {Springer},
	organization = {Springer},
	chapter = {Part II: Method Chapters},
	address = {Berlin / Heidelberg},
	abstract = {An important goal of most empirical software engineering experiments is the transfer of the research results to industrial applications. To convince industry about the validity and applicability of the results of controlled software engineering experiments, the tasks, subjects and the environments should be as realistic as practically possible. Such experiments are, however, more demanding and expensive than experiments involving students, small tasks and pen-and-paper environments. This chapter describes challenges of increasing the realism of controlled experiments and lessons learned from the experiments that have been conducted at Simula Research Laboratory.},
	isbn = {978-3-540-40672-3},
	author = {Sj{\o}berg, Dag Ingar Kondrup and Anda, Bente Cecilie Dahlum and Arisholm, Erik and Dyb{\r a}, Tore and J{\o}rgensen, Magne and Karahasanovic, Amela and Vok{\'a}c, Marek},
	editor = {Conradi, Reidar and Alf Inge {Wang}}
}
@inproceedings {SE.5.Sjoeberg.2002,
	title = {Conducting Realistic Experiments in Software Engineering},
	journal = {ISESE{\textquoteright}2002 (First International Symposium on Empirical Software Engineering)},
	year = {2002},
	month = {October 3-4},
	pages = {17-26},
	publisher = {IEEE Computer Society},
	type = {1},
	abstract = {An important goal of most empirical software engineering research is the transfer of research results to industrial applications. Two important obstacles for this transfer are the lack of control of variables of case studies, i.e., the lack of explanatory power, and the lack of realism of controlled experiments. While it may be difficult to increase the explanatory power of case studies, there is a large potential for increasing the realism of controlled software engineering experiments. To convince industry about the validity and applicability of the experimental results, the tasks, subjects and the environments of the experiments should be as realistic as practically possible. Such experiments are, however, more expensive than experiments involving students, small tasks and pen-and-paper environments. Consequently, a change towards more realistic experiments requires a change in the amount of resources spent on software engineering experiments. This paper argues that software engineering researchers should apply for resources enabling expensive and realistic software engineering experiments similar to how other researchers apply for resources for expensive software and hardware that are necessary for their research. The paper describes some of the experiences from recent experiments that varied in size from involving one software professional for 5 days to 130 software professionals, from 9 consultancy companies, for one day each.},
	isbn = {0-7695-1796-X},
	author = {Sj{\o}berg, Dag Ingar Kondrup and Anda, Bente Cecilie Dahlum and Arisholm, Erik and Dyb{\r a}, Tore and J{\o}rgensen, Magne and Karahasanovic, Amela and Koren, E. and Vok{\'a}c, Marek},
	editor = {found, not}
}
@inproceedings {SE.5.Vokac.1982,
	title = {Apparent and True Phase-Shifts of Circadian Rhythms After a Transmeridian Flight and During Night Shifts},
	journal = {IEA{\textquoteright}82},
	year = {1982},
	pages = {212-213},
	publisher = {Japan Ergonomics Research Society, Tokyo, Japan,},
	type = {1},
	author = {Vok{\'a}c, Marek},
	editor = {Noro, K.}
}
@article {SE.4.Vokac.1981,
	title = {Chronobiological Serial Section Analysis With a Pocket Calculator},
	journal = {Chronobiology},
	year = {1981},
	pages = {98-106},
	author = {Vok{\'a}c, Marek}
}
