Qualification: 
Ph.D, M.Tech, MSc, BSc
Email: 
swaminathanj@am.amrita.edu
Phone: 
+91 476 280 2123

Dr. Swaminathan is an Associate Professor from the Department of Computer Science and Engineering, Amrita Vishwa Vidyapeetham, Amritapuri Campus located at Kollam, Kerala. He has an overall experience of 22 years, 11 years with IT major Wipro Technologies and 11 years in Amrita. He is passionate about teaching and his teaching interests include computational thinking, programming, algorithms, data structures, networking and distributed computing. He also leads the Code @Amrita club specially dedicated to competitive programming at the campus that trains students to take part in national and international coding competitions. Apart from these, he guides B. Tech. projects, M. Tech. dissertations and Ph. D. thesis. Dr. Swaminathan is part of numerous initiatives at Amrita including Ahead programs, designing curricula for UG and PG programs, process initiatives, course content development, and mentoring junior faculty members. His latest interview on Concise Introduction to Computer Science & Engineering can be watched from YouTube.

Teaching Interests: Programming, Algorithms, Automata, Compliers, Distributed Computing

Courses

Publications

Publication Type: Conference Proceedings

Year of Publication Title

2021

Shobitha M, Sidharth R Prakash, Sreesruthi P K, Varun Raj P, and Swaminathan J., “Comparison of Concurrent Program Behavior using Java Interactive Visualization Environment”, 3rd International Conference on Inventive Computation and Information Technologies, 2021 (To appear). 2021.

2021

Shruti Dixit, T K Geethna, Swaminathan J., and Vipin Pavithran, “AngErza: Automated Exploit Generation”, 12th International Conference on Computing Communication and Networking Technologies, 2021 (To appear). 2021.

2021

Sappa Saran, Mullapudi T. Vignesh, Gurijala V. S. Sundar, Sandeep Naidu, and Swaminathan J., “An Optimal Algorithm to Maximize Vaccine Production in a Distributed Environment”, 12th International Conference on Computing Communication and Networking Technologies, 2021 (To appear). 2021.

2021

Bhamidipati Satwik, Girija Manoj Kuma Kalakoti, Sai Rajendra Immadi, and Swaminathan J., “Visualization of Distributed Program Execution”, 12th International Conference on Computing Communication and Networking Technologies, 2021 (To appear). 2021.

2020

L. S. Nair and Swaminathan J., “Towards Reduction of Software Maintenance Cost through Assignment of Critical Functionality Scores”, 2020 5th International Conference on Communication and Electronics Systems (ICCES). Coimbatore, India, pp. 199-204, 2020.[Abstract]


Software maintenance incurs a significant cost during the life cycle of any software product. This is due to multiple factors such as addition of features demanded by new requirements, modification of existing features triggered by fixing of defects in the code and extending product support to newer platforms. These factors cause the testing phase to be repeated each time thereby increasing the maintenance cost. The quality of the code compounds to the maintenance cost since poorly written code are hard to comprehend and work with. This paper proposes a methodology to reduce the testing effort through successive releases by determining a set of most significant functionalities by computing scores based on the usage frequency, code maintainability and change vulnerability. The scores are recomputed as the software evolves over successive releases to keep the testing effort minimal.

More »»

2020

M. Pugalia, A. Ashok, and Swaminathan J., “A Hybrid Algorithm for Optimized Resource Allocation under Constrained Task Schedule”, 2020 Fourth International Conference on Computing Methodologies and Communication (ICCMC). IEEE, Erode, India, pp. 136-141, 2020.[Abstract]


We present a novel hybrid algorithm for optimal resource allocation for scheduling tasks that satisfy a variety of diverse constraints. The problem is pitched in geometrical domain and has direct application to several areas including, and not limited to physical resource allocation, crowd sourcing and distributed/cloud computing. The fundamental problem is to complete a set of N tasks at geographically separate locations in a two-dimensional plane where each task takes a fixed duration, requires certain number resources and must be completed within a specified time window. The goal is to maximize the profit by efficient utilization of resources and reducing the cost of movement between locations and waiting at each location. In this paper, we propose multiple strategies with each one progressively better than the previous. The main contribution of the paper is the novel hybrid algorithm that combines the traditional greedy approach with chunk allocation and random tie-breaking scheme to achieve maximal profit by efficient resource allocation.

More »»

2020

K. Karippara, A. D. Nayar, V. Illikkal, N. Vasudevan, and Swaminathan J., “Synthesis, Analysis and Visualization of Networked Executions”, 2020 5th International Conference on Communication and Electronics Systems (ICCES). pp. 430-435, 2020.[Abstract]


With the rise in interconnected systems, networked programs have now become commonplace. While it is possible to get a complete visualization of standalone programs using software such as JIVE, it becomes difficult to get an overall view of networked programs. The communicating processes are distributed across different hosts and therefore only fragmented views of the execution are possible. This paper extends the capability of JIVE to synthesize client and server executions from multiple machines that run concurrently and communicate with each other by message passing. The crux of the technique that underlies the synthesis is a novel segmenting algorithm that partitions an execution trace tacitly so that partial order relationship between send and receive at each message passing point is preserved. The synthesized execution is then portrayed in the form of sequence diagram enabling debugging and analysis.The proposed work has demonstrated the efficacy of the synthesis by presenting two case studies. that provide deeper insights into the execution such as occurrence of race conditions.

More »»

2020

N. S. Nair, A. Mohan, and Swaminathan J., “Interactive Exploration of Compact Sequence Diagrams - JIVE based approaches”, 2020 Third International Conference on Smart Systems and Inventive Technology (ICSSIT). Tirunelveli, India, pp. 907-912, 2020.[Abstract]


Sequence diagrams are a popular visualization notation to refine and describe use case scenarios for object oriented application development. They are used to model/specify object-to-object interactions in clear sequence. Tools such as JIVE can be used to re-construct back the scenario from a real program execution in the form of sequence diagram. The sequence diagrams thus obtained tend to be large and hence JIVE provides novel options to compact the visualization structure without distorting the semantics. In this paper, an interactive technique to explore compact sequence diagrams that allows users to expand and examine the compacted portions on demand is presented. At the heart of the technique is the call tree implementation that forms the back-end of the visualization. The call tree is extended to work with the sequence diagram at the front-end in the symbiotic manner enabling interactive exploration. The utility of the technique is demonstrated through experiments with a variety of programs.

More »»

2019

A. A. Aziz, M. Unny, S. Niranjana, M. Sanjana, and Swaminathan J., “Decoding Parallel Program Execution by using Java Interactive Visualization Environment (JIVE): Behavioral and Performance Analysis”, 2019 3rd International Conference on Computing Methodologies and Communication (ICCMC). IEEE, Erode, India, pp. 792-797, 2019.[Abstract]


With the proliferation of multi-core systems in the last decade or so even the personal computers have acquired the capability of supporting parallel programs. However, most applications are simply not designed to take advantage of this capability. This is firstly due to the difficulty in comprehending parallel programs. Secondly, the speed-up achieved due to parallelism is diminished by the overhead incurred. We study both these aspects in the context of fork/join, the parallel programming framework supported by Java and Java Interactive Visualization Environment (JIVE), a dynamic analysis framework for debugging and visualizing Java programs. In this paper, we demonstrate how JIVE can be used to decode parallel program execution and their behavior on single, dual and quad core systems. We also present the results of the performance study undertaken to compare the performance of parallel programs against their sequential and multi-threaded counterparts for small, medium and large sized executions.

More »»

2017

M. Mithun and Swaminathan J., “Comparison of sequence diagram from execution against design-time state specification”, Proceedings of International Conference on Advances in Computing, Communications and Informatics (ICACCI). IEEE, Udupi, India, pp. 1387 - 1392, 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 »»

2017

Aparna K Das and Swaminathan J., “Building a common notation for enabling comparison of design and execution”, Proceedings of International Conference on Advances in Computing, Communications and Informatics (ICACCI). IEEE, Udupi, India, pp. 1609 - 1612, 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 »»

2015

Swaminathan J., Dinoop Hari, and Bharat Jayaraman, “Consistency of Java run-time behavior with design-time specifications”, Proceedings of Eighth International Conference on Contemporary Computing (IC3). IEEE, Noida, India, pp. 548-554, 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 »»

2014

Swaminathan J., Kishor Kamath Diwakar, and Bharat Jayaraman, “Towards program execution summarization: Deriving state diagrams from sequence diagrams”, Proceedings of Seventh International Conference on Contemporary Computing (IC3), 2014 . IEEE, Noida, India, 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 »»

Publication Type: Journal Article

Year of Publication Title

2021

K. P. Jevitha, Swaminathan J., Jayaraman, B., and M, S., “Finite-state model extraction and visualization from Java program execution”, Software: Practice and Experience, vol. 51, pp. 409-437, 2021.[Abstract]


Abstract Finite-state models are extensively used for discrete systems and they have also been adopted for the analysis and verification of concurrent systems. Programs that have a repetitive cycle, such as event-driven servers and controllers, lend themselves to finite-state modeling. In this article, we use the term model extraction to refer to the construction of a finite-state model from an execution trace of a Java program and a set of key attributes, that is, a subset of the fields of the objects in the program execution. By choosing different sets of attributes, different finite-state models (or views) of the execution can be obtained. Such models aid program comprehension and they can also be used in debugging a program. We present algorithms for model extraction and also for model abstraction in order to reduce the size of the extracted models so that they are amenable to visualization. For long executions, we show how to minimize the overhead of execution trace collection through a bytecode instrumentation technique; and, for large models, which are not amenable to visualization, we show how key properties of the extracted model can be checked against declarative specifications. We have implemented our techniques in the context of JIVE, an Eclipse plugin that supports runtime visualization and analysis of Java program executions. We illustrate our techniques through a collection of case studies of varying size and complexity, from classic problems of concurrency control to a medium-size protocol for authorization (OAuth2.0 protocol) to a large-scale software that underlies web applications (Apache Tomcat server).

More »»

2017

Swaminathan J., Bharat Jayaraman, and Demian Lessa, “Compact visualization of Java program execution”, Software - Practice and Experience, vol. 47, pp. 163-191, 2017.[Abstract]


The context of this work is a practical, open-source visualization system, called JIVE, that supports two forms of runtime visualizations of Java programs - object diagrams and sequence diagrams. They capture, respectively, the current execution state and execution history of a Java program. These diagrams are similar to those found in the UML for specifying design-time decisions. In our work, we construct these diagrams at execution time, thereby ensuring continuity of notation from design to execution. In so doing, a few extensions to the UML notation are proposed in order to better represent runtime behavior. As sequence diagrams can become long and unwieldy, we present techniques for their compact representation. A key result in this paper is a novel labeling scheme based upon regular expressions to compactly represent long sequences and an O(r2) algorithm for computing these labels, where r is the length of the input sequence, based upon the concept of 'tandem repeats' in a sequence. Horizontal compaction greatly helps minimize the extent of white space in sequence diagrams by the elimination of object lifelines and also by grouping lifelines together. We propose a novel extension to the sequence diagram to deal with out-of-model calls when the lifelines of certain classes of objects are filtered out of the visualization, but method calls may occur between in-model and out-of-model calls. The paper also presents compaction techniques for multi-threaded Java execution with different forms of synchronization. Finally, we present experimental results from compacting the runtime visualizations of a variety of Java programs and execution trace sizes in order to demonstrate the practicality and efficacy of our techniques. © 2016 John Wiley & Sons, Ltd.

More »»

Publication Type: Book Chapter

Year of Publication Title

2018

Devi Sree Rajan and Swaminathan J., “Construction of Activity Diagrams from Java Execution Traces”, in Ambient Communications and Computer Systems, In: Perez G., Tiwari S., Trivedi M., Mishra K. (eds), Advances in Intelligent Systems and Computing, vol. 696, Singapore: Springer Singapore, 2018, pp. 641-655.[Abstract]


The aim of the work is to construct an activity diagram from the execution trace of Java programs to provide better program comprehension through visualisation. The execution trace is obtained during run-time when the Java program is debugged and the Java Interactive Visualisation Environment (JIVE) produces the details corresponding to the execution. The information from the trace is observed to develop an algorithm for the activity diagram construction. The reliance on PlantUML syntax has significantly guided in activity diagram notations used. Several basic programs containing the different constructs in Java are chosen for the analysis of the execution trace, and the events generated for these are studied to develop the algorithm. The execution trace is a collection of various fields which retrieves valuable information regarding the execution. The fields deliver relevant information regarding the control flow of the program and has majorly contributed for the diagram construction. However, the execution trace does not reveal particulars of some of the constructs in Java program and hence constructs have been categorised into two. The available constructs’ execution traces are taken and studied, whereas the unavailable ones are kept aside. The algorithm thus developed is allowed to test with multiple programs to identify its correctness.

More »»

2016

Lukasz Ziarek, Bharat Jayaraman, Demian Lessa, and Swaminathan J., “Runtime visualization and verification in JIVE”, in In: Falcone Y., Sanchez C. (eds), Runtime Verification, RV 2016, Lecture Notes in Computer Science, vol. 10012, Springer Cham, 2016, pp. 491-494.[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 »»
Faculty Research Interest: