Ph.D, MSc, M.Tech, BSc

Dr. Swaminathan J. currently serves as an Assistant Professor (Sl. Gr.) at the Department of Computer Science Engineering at Amrita School of Engineering, Amritapuri. He has completed M. Tech. in Computer Science.


Publication Type: Journal Article

Year of Publication Title


Swaminathan J., Sree, D., and Bharat Jayaraman, “Exploring Java Program Execution using Activity Diagrams”, Advances in Intelligent Systems & Computing, vol. 696, pp. 641-655, 2018.

Publication Type: Conference Paper

Year of Publication Title


M. Mithun and Swaminathan J., “Comparison of sequence diagram from execution against design-time state specification”, in 2017 International Conference on Advances in Computing, Communications and Informatics (ICACCI), Udupi, India, 2017.[Abstract]

Simulating real world applications containing many functionalities using programs tend to become very complex in structure and behaviour. Validating such programs for its correctness require correct outputs and their ability to cope with erroneous scenarios. This work proposes a methodology for the verification of such programs defined using Java, based on their design-time and run-time model, where both the models are defined using the behavioural Unified Modeling Language state and sequence diagrams. The design-time behaviour is depicted by the state diagram and the run-time behaviour by sequence diagram, which is defined over the execution trace of the program. This work includes an automated and algorithmic approach to perform validation of application software.

More »»


K. Aparna and Swaminathan J., “Building a common notation for enabling comparison of design and execution”, in 2017 International Conference on Advances in Computing, Communications and Informatics (ICACCI), Udupi, India, 2017.[Abstract]

Design and implementation are two major aspects of the software development and the deviation between them needs to be minimized to the best extent possible. Of the many difficulties in detecting the deviation is the absence of common notation to compare the implementation artefact (code) against the design artefact. In this paper we present an approach to bridge the gap by providing a methodology to construct call trees from both the artefacts and thus enabling comparison of both using a common notation. Design is usually captured as scenarios and hence we use sequence diagrams for its specification. An implementation is accurately understood when it is executed and hence we use execution events to capture it. Building on these two artefacts, we provide a systematic procedure to construct call trees that can be compared against each other for deviation. This paper is an outcome of our ongoing work towards automatic detection of deviations and our experiments in designing and implementing several scenarios confirm the utility of this methodology towards this goal. While we demonstrate the methodology in the UML and Java setting, the technique is generic and can be applied in the context of any language.

More »»


Swaminathan J., Hari, D., and Jayaraman, B., “Consistency of Java run-time behavior with design-time specifications”, in 2015 Eighth International Conference on Contemporary Computing (IC3), Noida, India, 2015.[Abstract]

We present a novel framework for formal verification of run-time behaviour of Java programs. We focus on the class of programs with a repetitive behaviour, such as servers and interactive programs, including programs exhibiting concurrency and non-determinism. The design-time specifications for such programs can be specified as UML-like finite-state diagrams, or Kripke structures, in the terminology of model checking. In order to verify the run-time behavior of a Java program, we extract a state diagram from the execution trace of the Java program and check whether the run-time state diagram is consistent with the design-time diagram. We have implemented this framework as an extension of JIVE (Java Interactive Visualization Environment), a state-of-the-art dynamic analysis and visualization tool which constructs object, sequence, and state diagrams for Java program executions. JIVE is available as an open-source plugin for Eclipse and makes available the execution trace for facilitating analyses of program executions. We have tested our extension on a number of programs, and our experiments show that our methodology is effective in helping close the gap between the design and implementation of Java programs.

More »»

Publication Type: Conference Proceedings

Year of Publication Title


La Ziarek, Jayaraman, Ba, Lessa, Da, and Swaminathan J., “Runtime visualization and verification in JIVE”, 16th International Conference on Runtime Verification, RV 2016 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), vol. 10012 LNCS. Springer Verlag, Madrid, Spain, pp. 493-497, 2016.[Abstract]

Jive is a runtime visualization system that provides (1) a visual representation of the execution of a Java program, including UML-style object and sequence diagrams as well as domain specific diagrams, (2) temporal query-based analysis over program schedules, executions, and traces, (3) finite-state automata based upon key object attributes of interest to the user, and (4) verification of the correctness of program execution with respect to design-time specifications. In this paper we describe the overall Jive tool-chain and its features. © Springer International Publishing AG 2016.

More »»


Swaminathan J., D Kamath, K., and Jayaraman, B., “Towards program execution summarization: Deriving state diagrams from sequence diagrams”, Seventh International Conference on Contemporary Computing (IC3), 2014 . IEEE, Noida, pp. 299-305, 2014.[Abstract]

We propose a summarization technique that provides a clear and concise picture of the history of program execution with respect to entities of interest to a programmer. We develop our technique in the context of JIVE, a tool for Java execution visualization that renders execution states and history using UML object and sequence diagrams respectively. While these notations have been developed for specifying design-time decisions, the distinguishing aspect of our work is that we adapt their use for execution-time. Sequence diagrams tend to be long and unwieldy, and often exhibit a repetitive structure, hence we develop a novel procedure to summarize the sequence diagram in the form a state diagram with finite states. This summarization is user-driven, in that the user annotates the key variables of interest in the source code. This information together with an execution trace of the program for a particular input enables us to systematically construct a state diagram that summarizes the program behavior for that input. Using multiple execution traces, we show how an integrated state summarization can be obtained. Finally, by choosing different sets of variables, the user may view different summarizations, or perspectives, of the execution. This paper presents our technique along with experimental results from summarizing several different program executions in order to illustrate the benefit of our approach.

More »»
Faculty Research Interest: