CodeCity for (and by) JavaScript

CodeCity for (and by) JavaScript

Marcos Viana, Andre Hora, Marco Tulio Valente
Department of Computer Science,
Federal University of Minas Gerais (UFMG), Belo Horizonte – Brazil
Abstract

JavaScript is one of the most popular programming languages on the web. Despite the language popularity and the increasing size of JavaScript systems, there is currently a limited number of visualization tools that can be used by developers to comprehend, maintain, and evolve JavaScript software. In this paper, we introduce JSCity, an implementation in JavaScript of the well-known Code City software visualization metaphor. JSCity relies on JavaScript features and libraries to show “software cities” in standard web browsers, without requiring complex installation procedures. We also report our experience on producing visualizations for 40 popular JavaScript systems using JScity.

1 Introduction

JavaScript is one of the most popular programming languages on the web. The language was designed in the middle of 1990 aiming to extend web pages with small pieces of executable code. Since then, its popularity and relevance have only grown [4, 5]. Currently, JavaScript is used to develop complex applications in several domains, such as email clients, office applications, IDEs, etc. However, despite the increasing size and complexity of JavaScript systems, there is currently no visualization tools that can be used by developers to comprehend, maintain, and evolve JavaScript software.

In this short paper, we present JSCity, an open source tool that offers an intuitive way for representing, modeling and visualizing JavaScript source code using 3D visualizations. Specifically, JSCity adapts to JavaScript the well-known CodeCity software visualization metaphor, originally proposed by Wettel and Lanza to visualize object-oriented code. JSCity represents a JavaScript program as a city; folders are districts and files are sub-districts; the buildings are functions; inner functions are represented as buildings on the top of their enclosing function/building. The Number Of Lines of source Code (LOC) represents the height of the buildings/functions; the Number Of Variables (NOV) in a function correlates to the building’s base size. In the paper, we also report our experience on producing visualizations for 40 popular JavaScript systems using JScity.

This paper is organized as follows. Section 2 describes the city metaphor for the representation of code. Section 3 describes the implementation of JSCity in JavaScript. Section 4 illustrates the usage of JSCity in real JavaScript code. Finally, related work is presented in Section 5 and conclusions are provided in Section 6.

2 CodeCity for JavaScript

In the original code city metaphor, classes are represented as buildings. However, despite the possibility of emulating classes by means of prototypes [6], JavaScript is not a class-based programming language, such as Smalltalk, Java, and C++. Therefore, we use buildings to represent JavaScript functions, as illustrated in Figure 1. The buildings’ color is used to distinguish named functions (represented in blue) from anonymous functions (represented in green). The height of the buildings correlates with a function size, measured in number of lines of code; the width correlates with the number of variables of a function. Finally, directories are city districts and files are sub-districts. Districts and sub-districts are represented by the colors yellow and red, respectively.

Figure 1: City metaphor for JavaScript.

A common practice in JavaScript is to declare nested functions. To handle such functions, we adapt the city metaphor to display a building (nested function) on the top of another (the enclosing function). The total height of a building is in fact the sum of the size of all nested functions (in lines of code). The width of a parent function is the sum of its variables and the variables of the child functions, ensuring the construction of a wider building at the bottom and narrower buildings over it. information.

3 CodeCity by JavaScript

JSCity is developed in JavaScript itself and uses the Esprima111http://esprima.org framework to generate an Abstract Syntax Tree (AST) for the target code. The ThreeJS framework222https://threejs.org is used to design the 3D city. ThreeJS offers several graphical resources that enable scenes representation in 3D. Among the offered features, we enumerate the creation of scenes, geometries, animations, and perspectives without page reloading. These features are used in our tool to draw the city, to make it possible to navigate by city elements, to perform zoom operations, and to change the camera angle and cursor position with function.

Figure 2 presents the steps that are needed to produce a code city visualization. First, during an offline phase, the Esprima parser is called to generate an AST. After that, the data required for producing a city visualization is persisted in a database. During an online phase, a City Drawer component is responsible for retrieving the data required for producing a city visualization and to draw the city using the ThreeJS framework.

Figure 2: Component diagram of JSCity tool.

4 Examples

We use JSCity to produce code cities for 40 well-known JavaScript systems, including popular libraries and frameworks, code editors, browser plugins, and games. The complete list of systems, with the respective cities, is available at: https://github.com/ASERG-UFMG/JSCity/wiki/JSCITY.

In this section, we present and discuss the code cities of three systems:

  • Figures 3 and 4 present the city of AngularJS, a popular MVC-based framework. The system has 233,785 lines of source code, 20 directories, 863 files, 10,362 anonymous functions, and 6,050 named functions. We can see that AngularJS’s city has two main areas: a district with small buildings (Figure 3) and an area with many skyscrapers (Figure 4). In fact, the directory (district) in Figure 3 has many small anonymous functions (in green) for internationalization, which are located in directory . By contrast, the district in Figure 4 includes functions responsible for the system core. The tallest building is function . This function “compiles an HTML string or DOM into a template and produces a template function”.

    Figure 3: AngularJS: Internationalization functions
    Figure 4: AngularJS:Core Functions
  • Figure 5 presents the city of jQuery, the popular DOM manipulation library for JavaScript. The code has mostly anonymous functions (green buildings). The big buildings represent core event-handling functions, like an anonymous function in with 798 LOC. We also see through the visualization that directories are organized in large modules, such as , , and .

    Figure 5: jQuery city
  • Figure 6 presents the city of Bower, a popular package management system for JavaScript. We observe that most of functions are anonymous (green buildings), but named functions are also common (blue buildings). Besides that, the use of nested functions is very common (buildings on top of other buildings).

    Figure 6: Bower city

From our selection of systems, it is possible to infer some patterns of development, summarized as follows. Tall and wide buildings are usually core functions of the systems; large districts with small and regular layouts represent, for example, internationalization features. Green buildings (anonymous functions) are largely used in practice as well as buildings on top of other buildings (nested functions).

5 Related Work

In this work, we presented JSCity, which is inspired by CodeCity [7, 8]. CodeCity aims to make software analysis, where systems are shown as navigable and interactive 3D cities. Classes are represented as city buildings, while modules are represented as districts. Number of methods is the height of the buildings, the number of variables represents the width, and the number of lines of code is represented by colors – from dark gray (lowest number) to intense blue (greater number). CodeCity is available in Eclipse [1] and Moose tool [2]. However, such cases are restricted to the analysis of the object-oriented languages Java and Smalltalk. Finally, other visualization—not necessarily in the form of cities—have already been proposed for other system dimensions, such as bug analysis [3].

6 Conclusion

JSCity extends CodeCity for JavaScript and provides—to our knowledge—the first source code visualization tool for this language. The city metaphor was adapted to represent JavaScript systems, for instance, by supporting the visualization of anonymous and nested functions. Moroever, JSCity is easily accessible because it runs directly in a web page, without requiring the installation of any visualization-specific software As future work, we plan to survey developers about posssible aplications and use of code cities. We also plan to provide support to other languages, but keeping the visualization engine implemented in JavaScript.

Acknowledgments

This research was supported by CNPq and FAPEMIG.

References

  • [1] CodeCity Eclipse. CodeCity Eclipse, 2015. https://marketplace.eclipse.org/content/codecity.
  • [2] CodeCity Moose. CodeCity Moose, 2015. http://www.inf.usi.ch/phd/wettel/codecity.html.
  • [3] Andre Hora, Nicolas Anquetil, Stephane Ducasse, Muhammad Bhatti, Cesar Couto, Marco Tulio Valente, and Julio Martins. Bug maps: A tool for the visual exploration and analysis of bugs. In European Conference on Software Maintenance and Reengineering, 2012.
  • [4] Holger M. Kienle. It’s about time to take javascript (more) seriously. IEEE Software, 27(3), 2010.
  • [5] Alex Nederlof, Ali Mesbah, and Arie van Deursen. Software engineering for the web: The state of the practice. In Companion Proceedings of the 36th International Conference on Software Engineering, 2014.
  • [6] Leonardo Silva, Miguel Ramos, Marco Tulio Valente, Alexandre Bergel, and Nicolas Anquetil. Does javascript software embrace classes? In International Conference on Software Analysis, Evolution, and Reengineering, 2015.
  • [7] Richard Wettel and Michele Lanza. CodeCity: 3D Visualization of Large-scale Software. In International Conference on Software Engineering, 2008.
  • [8] Richard Wettel, Michele Lanza, and Romain Robbes. Software systems as cities: A controlled experiment. In International Conference on Software Engineering, 2011.
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
""
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
   
Add comment
Cancel
Loading ...
254384
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test
Test description