JSummarizer: An Automatic Generator of Natural
Language Summaries for Java Classes
Laura Moreno1, Andrian Marcus1, Lori Pollock2, K. Vijay-Shanker2
1 2
Department of Computer Science
Wayne State University
Detroit, MI, USA
{lmorenoc, amarcus}@wayne.edu
Abstract—JSummarizer is an Eclipse plug-in for automatically
generating natural language summaries of Java classes. The
summary is based on the stereotype of the class, which implicitly
encodes the design intent of the class and is automatically
inferred by JSummarizer. The tool uses a set of predefined
heuristics to determine what information will be reflected in the
summary, and it uses natural language processing and generation
techniques to form the summary. The generated summaries can
be used to re-document the code and to help developers to easier
understand large and complex classes.
Index Terms—Source code summarization, program
comprehension, documentation generation.
I. INTRODUCTION
During software evolution, depending on the task at hand,
developers need to understand relevant parts of the code. In
consequence, developers often spend more time reading code
[1] than writing it. Good leading comments help when reading
code, by providing developers with at least a superficial
understanding of the source code artifact that they describe.
However, outdated or missing comments are very common and
developers often must read more of the code or turn to external
documentation in order to gain any understanding of the code
relevant to their task.
An obvious solution to this problem would be enforcing the
creation and continuous update of internal documentation.
While such a solution may work with new code, it will likely
not work on existing, poorly-documented code. A more
suitable approach is automatically generating summaries that
describe the code. Such summaries can be used for re-
documentation and will help developers in quickly
understanding existing code.
We present JSummarizer, an Eclipse plug-in that
automatically generates natural language descriptions of Java
classes. The tool takes as input a Java class and its parent
project and produces a short, text-based description of that
class, which is inserted as a Javadoc comment. The summary
focuses on the content and responsibilities of the class by
considering its stereotype, which is automatically inferred by
JSummarizer. The tool implements a set of predefined
heuristics to determine the information to be included in the
summary, and makes use of natural language processing and
generation techniques to form the summary.
978-1-4673-3092-3/13/$31.00
c 2013 IEEE
Computer and Information Sciences Department
University of Delaware
Newark, DE, USA
{pollock, vijay}@cis.udel.edu
II. CLASS SUMMARIZATION
Summarizing a class is more complex than simply listing its
methods and/or its attributes. Object-Oriented (OO) classes
have generic responsibilities (i.e., domain-independent) and
specific responsibilities (i.e., domain-dependent). For example,
the main functionality of a class may be providing data (generic
role) of a particular file, such as an audio file (specific role).
Ideally, both roles should be reflected by the class summaries.
While the specific responsibilities can be inferred from the
textual information embedded in the source code (e.g.,
identifiers or comments), the generic responsibilities of a class
must be inferred from its design. To this end, JSummarizer has
a component that automatically infers the class stereotype [2],
based on the stereotypes of its member methods. Class
stereotypes are low-level patterns that capture the design intent
of the class. For example, a class consisting mostly of methods
that are in charge external objects (i.e., factory and controller
methods) is stereotyped as controller.
Next, JSummarizer uses the class stereotype to determine
what parts of the class should be reflected in the summary,
mostly fields and attributes of the class. The summary of a
class generated by JSummarizer consists of:
 a general description based on its interfaces,
superclass, and/or stereotype;
 the characterization of its structure given by the
definition of its class stereotype;
 a description of its behavior provided by the relevant
methods, grouped in blocks; and
 the enumeration of its inner classes, if they exist.
The goal of the summaries generated by JSummarizer is to
highlight the main functionality of a class, so it ignores
algorithmic details of the implementation. It also ignores the
existing comments (if any).
JSummarizer is very easy to use and fast. The user has the
option of selecting a single class and generating its summary
(right click in the class browser), or selecting an entire project
to generate the summaries for each class in it. Single class
summaries are instantaneously generated, whereas for small to
medium sized systems it takes seconds (e.g., it took 16 seconds
to generate the summaries for aTunes - version 1.6.0, an audio
player and manager system consisting of 218 classes, on an
Intel core-i3 powered laptop running Windows 7).
230 ICPC 2013, San Francisco, CA, USA
 III. DESIGN AND IMPLEMENTATION
JSummarizer is implemented as a plug-in for the Eclipse
development environment, since it is aimed at supporting
developers in their daily tasks. The general process for
generating class summaries is presented in Figure 1.
JSummarizer takes as input a Java class (labeled ) and its
respective project ( ). Both elements are used in the
identification of the class stereotype (1), by determining the
stereotypes of its member methods (2), which in turn are
inferred from their structural attributes (3). Next, the content to
be included in the summary is selected according to stereotype
information (4) and the access level of the methods (5). Then,
the summary is built (6) by generating natural language phrases
for the selected content (7). Finally, the summary is added (8)
to the Javadoc comment of the class ( ), which represents the
main output of the tool (Figure 2).
The four major components of JSummarizer (shown in
Figure 1 by the white rectangles) serve for: the identification of
code stereotypes (i.e., JStereoCode [3]); the selection of
information to be included in the summary; the generation of
the natural-language description; and its inclusion in the
corresponding Javadoc comment. We developed and presented
the first component independently [3]. The text generation
component is based on the previous work of Hill et al. [4-6],
whereas the other components are unique to JSummarizer.
IV. RELATED WORK
The automatic summarization of software artifacts is an
emerging field in software engineering, especially the
generation of natural language descriptions of source code.
Sridhara et al. proposed genSumm [5], a tool that
automatically generates natural language comments for Java
methods. Just like JSummarizer, this tool is implemented as an
Eclipse plug-in; however, it is not available for use. Note that
JSummarizer does not compose summaries of methods that
would be generated by genSumm.
Other simpler, but still important programming constructs
have been automatically described/documented. This is the
case of formal method parameters [7] and exceptions in Java
systems [8]. In a different way, Deltadoc [9] focuses on
describing the changes in the code by dynamically analyzing
the behavior of the program. Also, Rastkar et al. [10] proposed
a prototype for the automatic generation of summaries for
cross-cutting concerns.
To the best of our knowledge, JSummarizer is the first tool
that automatically generates natural language documentation
for Java classes.
V. EVALUATION AND FUTURE WORK
JSummarizer is a fully automated tool, independent of any
existing documentation or external domain knowledge. In an
initial empirical evaluation we asked programmers to evaluate
summaries generated by JSummarizer [11]. The subjects found
that, in most cases, the summaries are concise, readable, and
understandable, and moreover, do not miss important
information.
231
We expect that JSummarizer will be useful in many
evolution and maintenance tasks. We plan to evaluate
JSummarizer in the context of traceability link recovery [12]
and feature location. The summaries generated by JSummarizer
are generic, so for specific applications they will need to be
modified to include information needed for the task at hand.
VI. AVAILABILITY
JSummarizer is free and publicly available for academic
and non-commercial use at this stage. The most recent version
of the plug-in is available to download at:
http://www.cs.wayne.edu/~severe/jsummarizer
ACKNOWLEDGEMENT
This work was supported in part by grants from the
National Science Foundation (CCF-0845706, CCF-1017263,
and CCF-0915803).
REFERENCES
[1] A. J. Ko, B. A. Myers, M. J. Coblenz, and H. H. Aung, "An Exploratory
Study of How Developers Seek, Relate, and Collect Relevant
Information during Software Maintenance Tasks," IEEE Transactions on
Software Engineering (TSE), vol. 32, pp. 971-987, 2006.
[2] N. Dragan, M. L. Collard, and J. I. Maletic, "Automatic Identification of
Class Stereotypes," in 26th IEEE International Conference on Software
Maintenance (ICSM'10), Timisoara, Romania, 2010, pp. 1 -10.
[3] L. Moreno and A. Marcus, "JStereoCode: Automatically Identifying
Method and Class Stereotypes in Java Code," in 27th IEEE/ACM
International Conference on Automated Software Engineering (ASE'12),
Essen, Germany, 2012, pp. 358-361.
[4] E. Hill, L. Pollock, and K. Vijay-Shanker, "Automatically Capturing
Source Code Context of NL-Queries for Software Maintenance and
Reuse," in 31st IEEE International Conference on Software Engineering
(ICSE'09), Vancouver, BC, 2009, pp. 232-242.
[5] G. Sridhara, E. Hill, D. Muppaneni, L. Pollock, and K. Vijay-Shanker,
"Towards Automatically Generating Summary Comments for Java
Methods," in 25th IEEE/ACM International Conference on Automated
Software Engineering (ASE'10), Antwerp, Belgium, 2010, pp. 43-52.
[6] E. Hill, "Developing Natural Language-based Software Analyses And
Tools to Expedite Software Maintenance," Ph.D., Dept. of Computer and
Information Sciences, University of Delaware, Newark, DE, 2010.
[7] G. Sridhara, L. Pollock, and K. Vijay-Shanker, "Generating Parameter
Comments and Integrating with Method Summaries," in 19th IEEE
International Conference on Program Comprehension (ICPC'11),
Kingston, Ontario, Canada, 2011, pp. 71 - 80
[8] R. Buse and W. Weimer, "Automatic documentation inference for
exceptions," in International Symposium on Software Testing and
Analysis (ISSTA'08), Seattle, WA, USA, 2008, pp. 273-282.
[9] R. Buse and W. Weimer, "Automatically Documenting Program
Changes," in 25th IEEE/ACM International Conference on Automated
Software Engineering (ASE'10), Antwerp, Belgium, 2010, pp. 33-42.
[10] S. Rastkar, G. C. Murphy, and A. W. J. Bradley, "Generating Natural
Language Summaries for Crosscutting Source Code Concerns," in 27th
IEEE International Conference on Software Maintenance (ICSM'11),
Williamsburg, VA, 2011, pp. 103-112.
[11] L. Moreno, J. Aponte, G. Sridhara, A. Marcus, L. Pollock, and V. [12] J. Aponte and A. Marcus, "Improving Traceability Link Recovery
Shanker, "Automatic Generation of Natural Language Summaries for Methods through Software Artifact Summarization," in 6th International
Java Classes," in 21st International Conference on Program Workshop on Traceability in Emerging Forms of Software Engineering
Comprehension (ICPC'13), San Francisco, USA, 2013, in press. (TEFSE'11), Honolulu, Hawaii, 2011, pp. 46-49.

Fig. 1. Summary generation process in JSummarizer

(a) (b) (c)

Fig. 2. Different visualizations of the summary generated by JSummarizer for the class AudioFile of aTunes system. In (a) it is shown the full
generated summary as added to the Javadoc of the class, including the HTML tags; in (b) it is presented this Javadoc as shown by a browser; in (c) the
same Javadoc is shown as displayed by the Eclipse pop-up Javadoc, when the mouse is over the name of the class.

232