How Do Programmers Express High-Level Concepts using Primitive Data Types?

1. Background
   • Research Questions
   • Related Work
2. Basic Idea
3. Experiment
4. Inferring C-types
5. Conclusion
   • Threats to Validity

1. Background

• Modern programming languages allow various user defined types.
• Primitive obsession often is considered as bad smell:

  String username = getCurrentUserName();
  String path = "/home/"+username+"/user.cfg";
  // Unsafe path: extra check is needed!
  File config = new File(path);
  

  A better (but cumbersome) code would be:

  User user = getCurrentUser();
  Path path = Paths.get(user.getHomeDirectory(), "user.cfg");
  // Path is guaranteed to be safe.
  File config = new File(path);
  

• String and int types, however, are still used for a wide variety of purposes.
• We are interested in how generic data types (such as String and int) are used in various software projects.

1.1. Research Questions

1. What are common "high-level data types"?
2. How do programmers express these high-level types in source code?
3. Is it possible to infer them from surface clues?

1.2. Related Work

• O'Callahan et al.: Type identification by static analysis + type inference. When two values are stored at the same location, they are the same type.
• Guo et al.: Dynamic analysis + type inference.
• Dash et al.: Similar names imply related types.
• Jiang et al.: Type inconsistency detection via dimensional analysis.

2. Basic Idea

When programmers make an API call, they are aware of the role of its arguments:

String x = "foo/bar.txt";
var f = new java.io.File(x);  // x is a pathname

• Here, x refers to a String, but it's clearly a pathname.
• We define these specific roles of data types as Conceptual Types or c-type.
  (They can also be called Abstract Types!)
• API calls are easy to collect and its function is well defined.
  → They provide us a plenty of unambiguous use cases forx c-types!

We studied Java Standard API and defined 12 commonly used c-types:

Method examples:

• new java.io.File(PATH)
• new java.net.URI(URL)
• java.sql.Statement.execute(SQL)
• java.net.InetAddress.getByName(HOST)
• new java.net.Socket(HOST, PORT)
• new java.awt.Point(XCOORD, YCOORD)
• new java.awt.Dimension(WIDTH, HEIGHT)
• new java.util.Date(YEAR, MONTH, DAY)
• java.util.Date.setYear(YEAR)
• java.time.LocalDate.of(YEAR, MONTH, DAY)
• ...

The criterion that we used are:

1. Clearly defined and well understood.
2. Distinct enough to not mix up with other concepts.
3. Widely used in many applications.

3. Experiment

We did the following experiments:

1. Choose medium-sized 26 Java open source projects.
2. Search all the specified API calls.
3. Extract c-type expressions from the arguments of each API call.
4. Examine the type, complexity and commonly used words for each c-type expression.

C-type Expression Examples:

zookeeper/.../TxnLogToolkit.java:
    ...
    File file = new File(dir.getPath() + File.separator + Util.makeLogName(zxid)[PATH]);

jitsi/.../SIPCommSplitPaneDivider.java:
    ...
    rightButton.setBounds((insets.left * 2) + leftSize.width + rightSize.width[XCOORD],
                          y[YCOORD], rightSize.width[WIDTH], rightSize.height[HEIGHT]);

3.1. Projects and Sizes

3.2. Number of Obtained C-Type Expressions

The distribution of c-type expressions differs by application domain. The total number of c-types is roughly propotional to the project size.

3.3. Top C-Type Expressions for Each Project

PATH

URL

XCOORD

WIDTH

3.4. Complex C-Type Expressions

PATH

• mLocalUfsPath + ufsBase
• selectedFile.getAbsolutePath() + PREFERENCES_FILE_EXTENSION
• dir.getPath() + DIR_FAILURE_SUFFIX
• U.defaultWorkDirectory() + separatorChar + DEFAULT_TARGET_FOLDER + separatorChar

URL

• url.toExternalForm().substring(GhidraURL.PROTOCOL.length() + 1)
• str + KMSRESTConstants.SERVICE_VERSION + "/"
• newOrigin(getScheme(),getHost(),getPort()).asString() + path
• base + configFile

XCOORD

• center.x + center.width
• leftButtonWidth + leftWidth
• evt.getX() - getInsets().left
• prefs.getInt(name+".x", 0)

WIDTH

• Math.max(contentWidth, menuWidth) + insets.left + insets.right
• TITLE_X_OFFSET + titlePreferredSize.width
• width + insets.left + insets.right + 2
• (int)(bounds.getWidth() * percent)

3.5. Complexity of C-Type Expressions

(n: number of terms)

4. Inferring C-types

We tried to infer the c-types from the surface clue of expressions.

Basic strategy:

1. Use the obtained c-type expressions (12k) as training set/test set.
2. Extract the features from each expression.
3. Use machine learning (decision tree) to identify the c-type from expressions.

Decision tree-based machine learning is used because

• They are suitable for symbolic features.
• The obtained rules are easy to understand for humans.

Common Top Words for C-Type Expressions:

We used a dataflow diagram to extract features from expressions:

Dependency Rules

We extract "primary identifier" and "secondary identifier(s)" from the above diagram:

• Primary identifer: getPath()
• Secondary identifiers: config, i

We tested the obtained decision tree classifier with leave-one-project-out cross validation:

• Choose one project (and its c-type expressions) as a test set.
• Use the other 25 projects as a training set.
• Average the results of all projects.

Classification Performance

The reason why URL c-type wasn't recognized very well: URL expressions often include HOST, PORT or PATH expressions, which confused the classifier:

"https://"+getHostName()+":"+getPort()+"/"+getPath()

5. Conclusion

• We defined 12 c-types used in Java standard API.
• C-type expressions can be extracted by scanning API calls.
• We studied 26 open source projects.
• We used a decision tree classifier to infer the c-type from its expressions and obtained 83% F-score.

Research Questions (again):

1. What are common "high-level data types"?
   → The distribution of c-types depends on the domain of each project.
2. How do programmers express these high-level types in source code?
3. Is it possible to infer them from surface clues?
   → These questions are related. By using superficial features, we obtained a classifier with 83% F-score. This suggests that programmers tend to express the common c-types in a rather obvious way.

In future, we could use the obtained classifier to infer c-types in other parts of code.

5.1. Threats to Validity

• Not all the Java APIs are inspected.
• Selection bias of open source projects.
• Some c-type distinction might be vague: URL and URI, Filename and Pathname, etc.
• There could be potentially many other c-types that are rarely used.
  Our results didn't account them.

Note to the listners of the previous presentation: This work is related to the previous presentation (Use-Flow Graph Analysis) only in that consistent variable naming would help the accuracy of c-type identification. Also, both works use the same tooling (dataflow graph). Other than that, two works are handling different problems.