Subhajit Datta

Software Engineering: Concepts and Applications by Subhajit Datta (Oxford University Press, 2010)

This is a book about bridging the critical gap between software engineering as taught in the classroom, and as practiced in the real world. In its five logical parts, the book covers important topics related to understanding the realm of software engineering, planning and managing software development, making software, testing, maintaining, and modifying software systems, and the latest trends of software development. Each of the chapters starts with a motivation to engage the reader’s interest and ends with exercises to test the reader’s understanding. Many of the chapters have case studies for highlighting the application of significant ideas in real world scenarios.

You may refer to the table of contents: brief and detailed; learn more about the book from the publisher's website, Amazon, or Google books; check out if it is available at a library near you from WorldCat; stay tuned to the latest updates at the book's Facebook page; add to the errata.

Metrics-Driven Enterprise Software Development by Subhajit Datta (J.Ross Publishing, 2007)

This is not a book about how enterprise software should be built. This is a book about how enterprise software is built, and how metrics can help make a difference. There are many books harping on the “should”of enterprise software development. The fact that there are many books implies: a. there are many strong feelings about the subject, and b. there is very little consensus. This book illustrates how simple and intuitive techniques can go a long way in meeting customer expectations better, building systems that are easier to evolve and improve, and cause developers less pain and penance.

You may refer to the table of contents and a collection of reviews; learn more about the book from Amazon or Google books; check out if it is available at a library near you from WorldCat; stay tuned to the latest updates at the book's Facebook page. The book has been featured in "great success metrics titles" and "all-time success metrics list" at Amazon.

[Datta et al., 2019]

Datta, S., Lakdawala, R., Sarkar, S. (2019). Understanding the Inter-Domain Presence of Research Topics in the Computing Discipline. Accepted at the IEEE Transactions on Emerging Topics in Computing.

Interdisciplinarity is the zeitgeist of our times. Calls for grant proposals and job postings indicate a demand for da Vincis. Looking at a microcosm of the phenomenon, we analyze large corpora of research publications across multiple domains of the computing discipline. We discover factors that influence whether and how some topics are more likely to transcend domain boundaries; and arrive at an eclectic cocktail of insights that include reflections on Berlin's hedgehog and the fox question!

[Datta and Sarkar, 2019]

Datta, S., Sarkar, P. (2019). Evolutionary Trends in the Collaborative Review Process of a Large Sofware System. ISEC 2019: Proceedings of the 12th Innovations on Software Engineering Conference (formerly known as India Software Engineering Conference), DOI: 10.1145/3299771.3299792 Article No.: 22.

Software systems supporting wide user bases are developed and maintained over considerable periods of time. Over such time-spans, patterns of developer interactions evolve in various ways. We examined the evolutionary trends in the collaborative review process of a large open source software system. We found that even as developers become more connected to their peers over time, the level of clustering between them decreases, contrary to expectations. This lead us to stumble upon some of the underlying -- and often overlooked -- dynamics of the review process!

[Kurniawan et al., 2018]

Kurniawan, O., Tiong Seng Lee, N., Datta, S., Sockalingam, N. (2018). Effectiveness of Physical Robot Versus Robot Simulator in Teaching Introductory Programming. TALE 2018: Proceedings of the 2018 IEEE International Conference on Teaching, Assessment, and Learning for Engineering, DOI: 10.1109/TALE.2018.8615190 1251-1257.

The first course in programming can be as challenging for teachers, as it is for students. We explored how effective physical robots vis-a-vis robot simulators are, in imparting foundational concepts of programming to a large cohort of first year undergraduate students. Our results surprised us, making us look anew at how programming is taught and learnt.

[Datta, 2017]

Datta, S. (2017). How does Developer Interaction Relate to Software Quality? An Examination of Product Development Data. Empirical Software Engineering: An International Journal, DOI: 10.1007/s10664-017-9534-0.

Much of large scale software engineering today, is largely social. Tools and processes are accordingly tailored to facilitate enhanced interaction among developers, especially in distributed teams. But does enhanced developer interaction necessarily enable better quality software? Pursuing this question across thousands of work products from tens of teams, leads to unexpected findings.

[Sarkar et al., 2017]

Sarkar, S., Lakdawala, R., Datta, S. (2017). Predicting the Impact of Software Engineering Topics: An Empirical Study. BigScholar 2017: Proceedings of the 4th WWW Workshop on Big Scholarly Data, WWW '17 Companion, pages 1251-1257.

We build a case for considering topics - rather than papers - as the publication unit of interest. An established model for predicting the number of citations of papers is customized for topics. Applying the model on a corpus of software engineering publication data reveals a set of insights indicating the promise of topic oriented approaches.

[Datta et al., 2017]

Datta, S., Basuchowdhuri, P., Acharya, S., Majumder, S. (2017). The Habits of Highly Effective Researchers: An Empirical Study. IEEE Transactions on Big Data (2017), Vol. 3, No. 1, Jan - Mar 2017, pages 1-15.

Why do few researcher's make it big, while most do not? We confront this question across five different computing domains, by identifying influential researchers using a novel algorithm, and then studying their characteristics. We find that some of the oft repeated prescriptions for research success do not withstand empirical scrutiny!

[Jongeling et al., 2017]

Jongeling, R., Sarkar, P., Datta, S., Serebrenik, A. (2017). On Negative Results when using Sentiment Analysis Tools for Software Engineering Research. Empirical Software Engineering: An International Journal, DOI:10.1007/s10664-016-9493-x.

In an enhanced version of [Jongeling et al, 2015] we find out how identifying sentiments in the software engineering context is hardly tool agnostic. This leads us to uncover how conclusions may differ when tools disagree. So tools can help only when we know which one to use, when.

[Datta et al., 2016]

Datta, S., Sarkar, S., Sajeev, A.S.M. (2016). How long will this live? Discovering the lifespans of software engineering ideas. IEEE Transactions on Big Data (2016), Vol. 2, No. 2, April - June 2016, pages 124-137.

In an enhanced version of [Datta et al., 2015a] we further investigate the myth of rapid obsolescence of software engineering ideas, and arrive at more interesting results.

[Das et al., 2016]

Das, R., Wang, X., Khezri, B., Webster, R.D., Sikdar, P.K., Datta, S. (2016). Mercury isotopes of atmospheric particle bound mercury for source apportionment study in urban Kolkata, India. Elementa: Science of the Anthropocene 4:000098(2016).

Outdoor air pollution is the 5th largest killer in India. Metals binding to the tiny air particulate matter are breathed, and they reach our lungs and mix with blood. In this study, we investigated the sources of heavy metals in the tiny air particulate matter at Kolkata.

[Yoong et al., 2015]

Yoong, C., Ng, G., Cheung, N., Zhang, Y., Lee, H., Datta, S. (2015). Open designettes, flowcharts, and pseudocodes in Python programming with the aid of Finch. ICCE 2015: Proceedings of the 23rd International Conference on Computers in Education (2015).

Teaching the first course in programming teaches me a lot about programming, every time. This time we tried introducing programming concepts through the use of design constructs, and an ornithomorphic robot. The students enjoyed, we liked the experience, and the results were interesting.

[Datta et al., 2015b]

Datta, S., Bhatt, D., Jain, M., Sarkar, P., Sarkar, S. (2015). The importance of being isolated: An empirical study on Chromium reviews. ESEM 2015: Proceedings of the 9th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (2015), pages 1-4.

These days, it is fashionable to be connected. After all, that is how we collect "likes". But can isolation facilitate some types of work? We confront this question with data, and get some provocative results.

[Jongeling et al., 2015]

Jongeling, R., Datta, S., Serebrenik, A. (2015). Choosing your weapons: On sentiment analysis tools for software engineering research. ICSME 2015: Proceedings of the 31st IEEE International Conference on Software Maintenance and Evolution (2015), pages 531-535.

Sentiment analysis is finding application in many areas, and software engineering is no exception. We show how it is important to be careful with sentiments.

[Das et al., 2015]

Das, R., Bahareh, K., Srivastava, B., Datta, S., Sikdar, P.,Webster, R.,Wang, X. (2015). Trace element composition of PM2.5 and PM10 from Kolkata – a heavily polluted Indian metropolis. Atmospheric Pollution Research 6 (2015).

An ode to air; and a foray into interdisciplinary studies.

[Datta et al., 2015a]

Datta, S., Sarkar S., Sajeev, A., Kumar N. (2015). Discovering the rise and fall of software engineering ideas from scholarly publication data. BigScholar 2015: Proceedings of the 2nd WWW Workshop on Big Scholarly Data, WWW '15 Companion, pages 585-590.

"Oh! software engineering is all about fads ..." I have heard this many times, and I suspect this is a general opinion about some aspects of computing. We decided to take a dispassionate look at this allegation, by looking at 19,000+ papers by 21,000+ authors from 1975 to 2010, and calculating a "half-life" of software engineering ideas.

[Datta and Lade, 2015]

Datta, S., Lade, P. (2015). Will this be quick? A case study of bug resolution times across industrial projects. ISEC '15: Proceedings of the 8th India Software Engineering Conference, pages 20-29.

Those of us who have been in the trenches of software development, can recollect hearing ``give this to me yesterday" often, from customers who are always right. Quickness is a virtue in bug resolution, especially in large scale industrial systems. We develop a technique based on processing descriptions in bug reports, to determine how long a bug will take to resolve.

[Datta et al., 2014c]

Datta, S., Sarkar P., Majumder S. (2014). Developer involvement considered harmful? An empirical examination of Android bug resolution times. SSE 2014: Proceedings of the 6th International Workshop on Social Software Engineering, pages 45-48.

One of the biggest promises around large scale interactive software development is that enhanced developer involvement is beneficial to completion of tasks. Is it really so? This paper takes look at the promise, and the pitfalls around it.

[Datta, 2014]

To paraphrase Stroustrup, our civilization increasingly runs on software that runs on mobile devices. Mobile development usually involves a dynamic ecosystem of users and developers. This paper explores the influences on how code reviews get worked on and resolved in mobile software development.

[Rocchi et al., 2014]

Development of a theoretical model for bug resolution remains one of the holy grails of software engineering. This paper studies the maintenance life cycle of a major software product and arrives at an unexpected result reflecting on the similarity between software processes to certain biological and physical phenomena.

[Datta et al., 2014b]

George Mallory, when asked why he wanted to climb Mount Everest, reportedly replied "Because it's there". Mountains of digital data are all around us, ever growing. These are fertile fields for serendipity, as we find out in this paper, setting out to uncover some of the typical tricks in the pursuit of research impact!

[Wagstrom and Datta, 2014]

For large scale software development, distributed teams are a fact of life. Team members can be spread apart over distance, or separated by time zones (or both). Distance and time have been alleged to have dark effects on human relationships. We investigate how distance and time affects developer interactions in a large commercial software projects with a global team.

[Datta et al., 2014a]

Datta, S., Sarkar P., Das S., Sreshtha S., Lade P., Majumder S. (2014). How many eyeballs does a bug need? An empirical validation of Linus' Law. XP 2014: Proceedings of the 15th International Conference on Agile Software Development, pages 242-250.

Software engineering alas, lacks the certainly of universal laws such as Newton's and Ohm's. Software engineering's laws are often observations couched as aphorisms; and how persuasive a law is, hinges on the eminence of the observer or the pithiness of the aphorism. With the increasing availability of development data, it is interesting to validate these laws empirically. In this paper we uncover some insights around whether and how more developer attention leads to quicker resolution of bugs in Android development.

[Datta et al., 2013b]

There are giants and pygmies in the world of software engineering research publications. How some researchers manage to publish so much and/or get cited so many times is of much speculation. We question the conventional wisdom, and uncover some unconventional ones, in an empirical study of software engineering publication data across several decades.

[Datta et al., 2013a]

Over the last couple of decades, software engineering research has become more collaborative. Whether working in large teams or small produces the maximum research impact is an open and interesting question. We explore this question through an empirical study.

[Sarkar and Datta, 2013]

Ours is a networked world. Whatever we do or say - even do not do or do not say - link us to many others. Building networks from software engineering research publications opens interesting possibilities for seeing beyond the obvious.

[Sajeev and Datta, 2013]

Sajeev, A., Datta, S. (2013). Introducing programmers to pair programming: A controlled experiment. XP2013: Proceedings of the 14th International Conference on Agile Software Development, pages 31-45.

That two heads are better than one finds echo in the effectiveness of pair programming in software development. But matchmaking is difficult in software development, as it is in matrimony. Results from our controlled experiment with a cohort of varying industrial programming experience gives some pointers to how best to form pairs (for pair programming).

[Datta et al., 2012b]

Datta, S., Sindhgatta, R., Sengupta, B. (2012). Talk versus work: Characteristics of developer collaboration on the Jazz platform. OOPSLA 2012: Proceedings of the 27th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages and Applications, pages 655-668.

Much of the software that runs our lives today has been developed by people in groups who have never seen one another, and are rarely awake at the same time in a 24 hour cycle. It is a phenomenal how they manage to craft supremely complex products. We look at the phenomenon through the lens of social network analysis and find what a person's interactions in a peer group can tell us about the outcome of his/her work, and what can not be told.

[Datta et al., 2012a]

Datta, S., Kumar, N., Sarkar, S. (2012). The social network of software engineering research. ISEC ’12: Proceedings of the 5th India Software Engineering Conference, pages 61-70.

Does a social network emerge from the world of software engineering publications? Delving into this question gets us to understand what qualifies a network to be a social network in the first place, and how the social aspects of a network influence its characteristics at the individual as well as collective level.

[Sindhgatta et al., 2011]

Sindhgatta, R., Sengupta, B., Datta, S. (2011). Coping with distance: An empirical study of communication on the Jazz platform. OOPSLA Companion 2011: Companion to the 26th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, pages 155-162.

Much of "global" software development is about team members talking across long distances. Every team has its own way of trying to ensure its members talk to and not past one another. Study of one such team reveals what works and what does not.

[Datta et al., 2011]

Datta, S., Sindhgatta, R., Sengupta, B. (2011). Evolution of developer collaboration on the Jazz platform: A study of a large scale agile project. ISEC ’11: Proceedings of the 4th India Software Engineering Conference, pages 21-30.

As we do something over and over, (hopefully!) we get better at it. Whether developers get better at collaborating with one another as they build a software system bit by bit is an open question. We have not closed the question fully in this paper, but opened some new questions.

[Datta et al., 2010]

Datta, S., Kaulgud, V., Sharma, V. S., and Kumar, N. (2010). A social network based study of software team dynamics. ISEC ’10: Proceedings of the 3rd India Software Engineering Conference, pages 33–42.

In a team, who does the work, and who gets the credit? This is a vexing question, often with more vexing answers. We got a taste of how vexing, when one of the team members wanted to have the results suppressed.

[Datta and van Engelen, 2009]

Datta, S. and van Engelen, R. (2009). An examination of the effects of offshore and outsourced development on the delegation of responsibilities to software components. Software Engineering Approaches for Offshore and Outsourced Development, Volume 16 of LNBIP, pages 73–89. Springer.

In this day and age, to outsource or not is a question that intrigues not only princes of Denmark, but presidents and potentates alike. And "offshore" has been, well, verbed. We explore whether and how all this affects software components - entities that do the real work.

[Berkling et al., 2009]

Berkling, K., Kiragiannis, G., Zundel, A., and Datta, S. (2009). Timeline prediction framework for iterative software engineering projects with changes. Software Engineering Approaches for Offshore and Outsourced Development, Volume 16 of LNBIP, pages 15–32. Springer.

Estimating how long it will take to develop a piece of software has been called a black art. Software that is built in bits, integrating user feedback on the way, presents its own estimation challenges. Based on empirical evidence, we develop a framework that can help is estimating some types of software projects.

[Datta and van Engelen, 2008]

Datta, S. and van Engelen, R. (2008). COMP-REF: A technique to guide the delegation of responsibilities to components in software systems. FASE 2008: Proceedings of the 11th International Conference on Fundamental Approaches to Software Engineering, Vol. 4961 of LNCS, pages 332–346. Springer.

When we build a team of people to accomplish a task, we look for those who are specially good at something, yet willing to help others in their work. Can we develop a software system with the same philosophy? We present a technique as a first step in that direction.

[Datta et al., 2007]

Datta, S., van Engelen, R., Gaitros, D., and Jammigumpula, N. (2007). Experiences with tracking the effects of changing requirements on Morphbank: A web-based bioinformatics application. ACM-SE 45: Proceedings of the 45th annual southeast regional conference, pages 413–418.

Apropos of the paper below, we apply our mechanism on another real world application.

[Datta and van Engelen, 2006]

Datta, S. and van Engelen, R. (2006). Effects of changing requirements: A tracking mechanism for the analysis workflow. SAC ’06: Proceedings of the 2006 ACM Symposium on Applied Computing, pages 1739–1744.

Death, taxes, and changing requirements are the invariants in a software engineer's life. Although we can not do much about the first two, may be the latter can be reasonably tamed? We develop a way to isolate the effects of changing requirements.

[Datta, 2006b]

Datta, S. (2006b). Crosscutting score: An indicator metric for aspect orientation. ACM-SE 44: Proceedings of the 44th annual southeast regional conference, pages 204–208.

There are multiple ways of looking at a software ecosystem. We can see objects collaborating by calling methods on one another, or we can see functionality that cuts across components. Which way to see when is what we consider here.

[Datta, 2006a]

Datta, S. (2006a). Agility measurement index: A metric for the crossroads of software development methodologies. ACM-SE 44: Proceedings of the 44th annual southeast regional conference, pages 271–273.

Quo vadis is one of those enduring questions. Which methodology is best for a particular software development scenario is explored through a metric.

[Datta, 2005]

Datta, S. (2005). Integrating the FURPS+ model with use cases - A metrics driven approach. ISSRE 2005: Supplementary Proceedings of the 16th IEEE International Symposium on Software Reliability Engineering, pages 4.51–4.52. IEEE Computer Society.

Use cases see a software system (in fact, any system) outside-in, as users would see and use the system. But users are not only interested in using a system, they also want the system to deliver the "ilities" -- functionality, usability, reliability, performance, and supportability, and more. We suggest a metric to marry use cases with the "ilities".

[Datta and Vaishnavi, 2004]

Datta, S. and Vaishnavi, N. (2004). A process compliance and process improvement algorithm. IT Process Model knowledge network, ICM AssetWeb of IBM.

[Datta and van Engelen., 2009]

Datta, S., van Engelen, R. (2009). Project-entropy: A metric to understand resource allocation dynamics across software projects. Department of Computer Science, Florida State University, Technical Report: TR-090121.

In the industry, it is common to pour more people in projects that need to increase customer satisfaction. Using a physical analogy we explore how far this works.

[Datta et al., 2009]

Datta, S., van Engelen, R., Wang, A. (2009). Predictux: A framework for predicting Linux kernel incremental release times. Department of Computer Science, Florida State University, Technical Report: TR-090120.

Can we predict when the next release of a system will be due? We try to find out, using a real world system.