Sefik Kanat Bolazar, PhD

Software engineer skilled in architecting, developing, unit testing and deploying stand-alone applications, with prior experience in client-server applications. Works well independently and as a strong team player. Learns new skills and adapts to working environments quickly. Accomplished at designing and developing software with long, stable life after deployment. PhD research: Partial automation of analysis, verification and visualization of Java software dynamic behavior.

Here's a copy of my resume. I am looking for a Software Developer position, ideally a Java Developer position. Best way to reach me is to email me.

Other links:

VERDICTS stands for Visual Exploratory Requirements Discovery and Injection for Comprehension and Testing of Software.

VERDICTS is a prototype tool to demonstrate a new approach to combining software comprehension and testing by visualization and incremental discovery and addition of requirements to existing software.
  • Automated: Requirements are used to automate erroneous behavior detection.
  • Visual: Visualization is used to aid comprehension by providing abundant information in a form that makes it easier to detect common patterns.
  • Live: In one session, new requirements can be discovered, injected into the software, verified (checked against the behavior of the program), and modified without recompilation or restarting the program under test.
VERDICTS gathers live program execution data and interacts with the target program to help developers analyze the aggregate behavior by viewing, statistically analyzing, and testing multiple calls to each function traced. As this approach is closer to execution tracing rather than the debugging, there is no direct quantitative comparison between VERDICTS and a standard IDE (Integrated Development Environment).
For more information and screenshots, please see VERDICTS page.

Research Interests

I'm interested in improving software comprehension and reuse, through partially automated bottom-up (from unit to whole system) approaches for: To answer some questions that arise, I have developed VERDICTS (Visual Exploratory Requirements Discovery and Injection for Comprehension and Testing of Software). This prototype environment in Java allows interactive software comprehension, requirements discovery and verification with the help of various visualizations.

I am also working on questions of assessing specification quality. When specifications are tightly coupled with test cases, specification adequacy is highly correlated with test set adequacy. Test set adequacy can generally be answered with test coverage metrics such as branch coverage, path coverage and mutation testing metrics.


S. Kanat Bolazar, James W. Fawcett. "Measuring Component Specification-Implementation Concordance with Semantic Mutation Testing" in Proceedings of the ISCA 26th International Conference on Computers and Their Applications, CATA 2011, 102-107. (local copy)

Documented specifications can aid in software verification, comprehension, maintenance and reuse. Often, specifications fall out of sync with evolving implementation. Both discovery of missing specifications and corrective maintenance of incorrect specifications require measuring the quality of specifications, not in terms of accurately representing end user needs, but rather, to answer the question of concordance "How faithfully/accurately does this specification represent the behavior of this implementation?" We implemented and tested our prototype system using Design by Contract (DBC) specifications and intermediate language (Java bytecode) manipulation. We consider the traditional source code mutation testing "syntactic mutation testing", and examine its shortcomings. We propose a different failure-injection approach, "semantic mutation testing," to measure component specification-implementation concordance. We demonstrate and compare our approach to traditional mutation testing, using a small function with multiple alternative specifications.

Kanat Bolazar, James W. Fawcett, "VERDICTS: Visual Exploratory Requirements Discovery and Injection for Comprehension and Testing of Software" in Proceedings of The 2010 International Conference on Software Engineering Research and Practice, SERP 2010, part of The 2010 World Congress in Computer Science, Computer Engineering and Applied Computing, WorldComp 2010. (local copy, online)

We introduce a methodology and its prototype implementation for visual exploratory software analysis. VERDICTS combines exploratory testing, tracing, visualization, dynamic discovery and injection of requirements specifications into a live quick-feedback cycle, without recompilation or restart of the system under test. This supports discovery and verification of software dynamic behavior, software comprehension, testing, and locating the defect origin. Our prototype implementation uses aspect-oriented method call interception, functional specification of requirements using dynamically injected Design by Contract, statistical analysis and various forms of visualization. We report on our personal experience.

S. Kanat Bolazar, James Fawcett, "Debugging with Software Visualization and Contract Discovery" in Proceedings of 15th International Conference on Software Engineering and Data Engineering, SEDE 2006, 47-50. (local copy)

Despite advances, debugging remains a drudgery, especially for software without proper documentation. Both top-down visualization-based approaches and bottom-up programmatic automation can improve this process. For a given system under test (SUT), we propose a combined method of:
  • Program trace visualization, with capability to zoom in to method call details (inputs and outputs) Interactive declaration of observables for the internal state of the system
  • Statistical and visual analysis of the collected observable data
  • Programmatic declaration of expected behavior of the system defined through invariant relationships and satisfaction of contracts (Design by Contract) on these observables
  • The ability to modify and repeat these steps without restarting the SUT
We report that instrumentation necessary to collect trace data is feasible; large amounts of data can be gathered without significant performance penalty while the visualizer remains responsive to tester interaction. Our personal experience is that the system is very quick to set up, faults are discovered quickly, and inefficient algorithms (which may produce correct results) become obvious through the visualizer. We are setting up human- interaction experiments to support the claim that our approach improves the efficiency of discovery of fault origin for a given system failure, compared to using a state-of-the-art debugger for Java (Eclipse).

Steven Morphet, James Fawcett, Kanat Bolazar and Murat Gungor, "Neural Net Analysis of the Propensity for Change in Large Software Systems" in Proceedings of 2006 International Joint Conference on Neural Networks, IJCNN 2006, part of IEEE World Congress on Computational Intelligence, WCCI 2006, 2606-2610. (local copy, IEEE explore link)

A novel approach for analyzing the relationship between code metrics and change count histories is presented. Specifically, neural networks are employed to determine a mapping between metrics and change count. While these neural networks can be trained to a high degree of accuracy, their internal workings remain opaque to the user. As such, a fuzzy modeling approach is additionally employed to generate the rules governing the neural computation. These rules are linguistic in nature and are thus more easily interpreted by software project managers. Application of this method to Mozilla change data reveals the importance of fan-out, total lines of code and maximum cyclomatic complexity metrics in predicting amount of change per file.

James Fawcett, Murat Gungor, Arun Iyer, Kanat Bolazar, "Relationship Between Code Metrics And Change History" in Proceedings of 20th International Conference on Computers and Their Applications, CATA 2005, 354-360. (local copy)

This paper studies relationships between code metrics and change count histories for a large open-source project, Mozilla. We examine several structural and code property metrics and construct statistically significant relationships with code base changes. Our results provide one step toward tool support for software managers to detect problems in large development projects.

DOPL at Syracuse University

I conducted my research on software development methodologies at DOPL, Distributed Object Processing Laboratory, under the supervision of Dr. James W. Fawcett.

DOPL is part of the:

It is located at:

Center for Science and Technology 4-116
Syracuse University
Syracuse, NY 13244