@article{behroozi_shirolkar_barik_parnin_2020, title={Debugging Hiring: What Went Right and What Went Wrong in the Technical Interview Process}, DOI={10.1145/3377815.3381372}, abstractNote={The typical hiring pipeline for software engineering occurs over several stages—from phone screening and technical on-site interviews, to offer and negotiation. When these hiring pipelines are “leaky,” otherwise qualified candidates are lost at some stage of the pipeline. These leaky pipelines impact companies in several ways, including hindering a company’s ability to recruit competitive candidates and build diverse software teams.To understand where candidates become disengaged in the hiring pipeline—and what companies can do to prevent it—we conducted a qualitative study on over 10,000 reviews on 19 companies from Glassdoor, a website where candidates can leave reviews about their hiring process experiences. We identified several poor practices which prematurely sabotage the hiring process—for example, not adequately communicating hiring criteria, conducting interviews with inexperienced interviewers, and ghosting candidates. Our findings provide a set of guidelines to help companies improve their hiring pipeline practices—such as being deliberate about phrasing and language during initial contact with the candidate, providing candidates with constructive feedback after their interviews, and bringing salary transparency and long-term career discussions into offers and negotiations. Operationalizing these guidelines helps make the hiring pipeline more transparent, fair, and inclusive.}, journal={2020 IEEE/ACM 42ND INTERNATIONAL CONFERENCE ON SOFTWARE ENGINEERING: SOFTWARE ENGINEERING IN SOCIETY (ICSE-SEIS 2021)}, author={Behroozi, Mahnaz and Shirolkar, Shivani and Barik, Titus and Parnin, Chris}, year={2020}, pages={71–80} }
 @article{shrestha_botta_barik_parnin_2020, title={Here We Go Again: Why Is It Difficult for Developers to Learn Another Programming Language?}, ISSN={["0270-5257"]}, DOI={10.1145/3377811.3380352}, abstractNote={Once a programmer knows one language, they can leverage concepts and knowledge already learned, and easily pick up another programming language. But is that always the case? To understand if programmers have difficulty learning additional programming languages, we conducted an empirical study of Stack Overflow questions across 18 different programming languages. We hypothesized that previous knowledge could potentially interfere with learning a new programming language. From our inspection of 450 Stack Overflow questions, we found 276 instances of interference that occurred due to faulty assumptions originating from knowledge about a different language. To understand why these difficulties occurred, we conducted semi-structured interviews with 16 professional programmers. The interviews revealed that programmers make failed attempts to relate a new programming language with what they already know. Our findings inform design implications for technical authors, toolsmiths, and language designers, such as designing documentation and automated tools that reduce interference, anticipating uncommon language transitions during language design, and welcoming programmers not just into a language, but its entire ecosystem.}, journal={2020 ACM/IEEE 42ND INTERNATIONAL CONFERENCE ON SOFTWARE ENGINEERING (ICSE 2020)}, author={Shrestha, Nischal and Botta, Colton and Barik, Titus and Parnin, Chris}, year={2020}, pages={691–701} }
 @article{barik_ford_murphy-hill_parnin_2018, title={How Should Compilers Explain Problems to Developers?}, DOI={10.1145/3236024.3236040}, abstractNote={Compilers primarily give feedback about problems to developers through the use of error messages. Unfortunately, developers routinely find these messages to be confusing and unhelpful. In this paper, we postulate that because error messages present poor explanations, theories of explanation---such as Toulmin's model of argument---can be applied to improve their quality. To understand how compilers should present explanations to developers, we conducted a comparative evaluation with 68 professional software developers and an empirical study of compiler error messages found in Stack Overflow questions across seven different programming languages. Our findings suggest that, given a pair of error messages, developers significantly prefer the error message that employs proper argument structure over a deficient argument structure when neither offers a resolution---but will accept a deficient argument structure if it provides a resolution to the problem. Human-authored explanations on Stack Overflow converge to one of the three argument structures: those that provide a resolution to the error, simple arguments, and extended arguments that provide additional evidence for the problem. Finally, we contribute three practical design principles to inform the design and evaluation of compiler error messages.}, journal={ESEC/FSE'18: PROCEEDINGS OF THE 2018 26TH ACM JOINT MEETING ON EUROPEAN SOFTWARE ENGINEERING CONFERENCE AND SYMPOSIUM ON THE FOUNDATIONS OF SOFTWARE ENGINEERING}, author={Barik, Titus and Ford, Denae and Murphy-Hill, Emerson and Parnin, Chris}, year={2018}, pages={633–643} }
 @article{ford_barik_rand-pickett_parnin_2017, title={The Tech-Talk Balance: What Technical Interviewers Expect from Technical Candidates}, DOI={10.1109/chase.2017.8}, abstractNote={Software engineer job candidates are not succeeding at technical interviews. Although candidates are able to answer technical questions, there is a mismatch of what candidates think interviewers assess versus what criteria is used in practice. This mismatch in expectations can cost candidates a job opportunity. To determine what criteria interviewers value, we conducted mock technical interviews with software engineer candidates at a university and collected evaluations from interviewers. We analyzed 70 interview evaluations from 9 software companies. Using a grounded theory approach, we compared interviewer interpretations of criteria including: performing a problem solving walkthrough, applying previous experience to problem solving, and the ability to engaging in conversation beyond writing code. From these findings, we provide implications on what candidates can expect to be evaluated on during technical interviews across companies, which can sometimes vary significantly.}, journal={2017 IEEE/ACM 10TH INTERNATIONAL WORKSHOP ON COOPERATIVE AND HUMAN ASPECTS OF SOFTWARE ENGINEERING (CHASE 2017)}, author={Ford, Denae and Barik, Titus and Rand-Pickett, Leslie and Parnin, Chris}, year={2017}, pages={43–48} }
 @article{barik_murphy-hill_2016, title={A process for surviving survey design and sailing through survey deployment}, journal={Perspectives on Data Science for Software Engineering}, author={Barik, T. and Murphy-Hill, E.}, year={2016}, pages={213–219} }
 @article{barik_pandita_middleton_murphy-hill_2016, title={Designing for Dystopia Software Engineering Research for the Post-apocalypse}, DOI={10.1145/2950290.2983986}, abstractNote={Software engineering researchers have a tendency to be optimistic about the future. Though useful, optimism bias bolsters unrealistic expectations towards desirable outcomes. We argue that explicitly framing software engineering research through pessimistic futures, or dystopias, will mitigate optimism bias and engender more diverse and thought-provoking research directions. We demonstrate through three pop culture dystopias, Battlestar Galactica, Fallout 3, and Children of Men, how reflecting on dystopian scenarios provides research opportunities as well as implications, such as making research accessible to non-experts, that are relevant to our present.}, journal={FSE'16: PROCEEDINGS OF THE 2016 24TH ACM SIGSOFT INTERNATIONAL SYMPOSIUM ON FOUNDATIONS OF SOFTWARE ENGINEERING}, author={Barik, Titus and Pandita, Rahul and Middleton, Justin and Murphy-Hill, Emerson}, year={2016}, pages={924–927} }
 @article{barik_song_johnson_murphy-hill_2016, title={From Quick Fixes to Slow Fixes: Reimagining Static Analysis Resolutions to Enable Design Space Exploration}, ISSN={["1063-6773"]}, DOI={10.1109/icsme.2016.63}, abstractNote={Quick Fixes as implemented by IDEs today prioritize the speed of applying the fix as a primary criteria for success. In this paper, we argue that when tools over-optimize this criteria, such tools neglect other dimensions that are important to successfully applying a fix, such as being able to explore the design space of multiple fixes. This is especially true in cases where a fix only partially implements the intention of the developer. In this paper, we implement an extension to the FindBugs defect finding tool, called FixBugs, an interactive resolution approach within the Eclipse development environment that prioritizes other design criteria to the successful application of suggested fixes. Our empirical evaluation method of 12 developers suggests that FixBugs enables developers to explore alternative designs and balances the benefits of manual fixing with automated fixing, without having to compromise in either effectiveness or efficiency. Our analytic evaluation method with six usability experts identified trade-offs between FixBugs and Quick Fix, and suggests ways in which FixBugs and Quick Fix can offer complementary capabilities to better support developers.}, journal={32ND IEEE INTERNATIONAL CONFERENCE ON SOFTWARE MAINTENANCE AND EVOLUTION (ICSME 2016)}, author={Barik, Titus and Song, Yoonki and Johnson, Brittany and Murphy-Hill, Emerson}, year={2016}, pages={212–222} }
 @inproceedings{barik_2016, title={How should static analysis tools explain anomalies to developers?}, booktitle={FSE'16: Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering}, author={Barik, T.}, year={2016}, pages={1118–1120} }
 @inproceedings{barik_deline_drucker_fisher_2016, title={The bones of the system: A case study of logging and telemetry at Microsoft}, booktitle={2016 IEEE/ACM 38th International Conference on Software Engineering Companion (ICSE-C)}, author={Barik, T. and DeLine, R. and Drucker, S. and Fisher, D.}, year={2016}, pages={92–101} }
 @inproceedings{barik_song_johnson_murphy-hill_2016, title={from quick fixes to slow fixes: reimagining static analysis resolutions to enable design space exploration}, booktitle={32nd ieee international conference on software maintenance and evolution (icsme 2016)}, author={Barik, T. and Song, Y. and Johnson, B. and Murphy-Hill, E.}, year={2016}, pages={212–222} }
 @article{barik_lubick_murphy-hill_2015, title={Commit Bubbles}, DOI={10.1109/icse.2015.210}, abstractNote={Developers who use version control are expected to produce systematic commit histories that show well-defined steps with logical forward progress. Existing version control tools assume that developers also write code systematically. Unfortunately, the process by which developers write source code is often evolutionary, or as-needed, rather than systematic. Our contribution is a fragment-oriented concept called Commit Bubbles that will allow developers to construct systematic commit histories that adhere to version control best practices with less cognitive effort, and in a way that integrates with their as-needed coding workflows.}, journal={2015 IEEE/ACM 37TH IEEE INTERNATIONAL CONFERENCE ON SOFTWARE ENGINEERING, VOL 2}, author={Barik, Titus and Lubick, Kevin and Murphy-Hill, Emerson}, year={2015}, pages={631–634} }
 @article{barik_lubick_smith_slankas_murphy-hill_2015, title={FUSE: A Reproducible, Extendable, Internet-scale Corpus of Spreadsheets}, DOI={10.1109/msr.2015.70}, abstractNote={Spreadsheets are perhaps the most ubiquitous form of end-user programming software. This paper describes a corpus, called Fuse, containing 2,127,284 URLs that return spreadsheets (and their HTTP server responses), and 249,376 unique spreadsheets, contained within a public web archive of over 26.83 billion pages. Obtained using nearly 60,000 hours of computation, the resulting corpus exhibits several useful properties over prior spreadsheet corpora, including reproducibility and extendability. Our corpus is unencumbered by any license agreements, available to all, and intended for wide usage by end-user software engineering researchers. In this paper, we detail the data and the spreadsheet extraction process, describe the data schema, and discuss the trade-offs of Fuse with other corpora.}, journal={12TH WORKING CONFERENCE ON MINING SOFTWARE REPOSITORIES (MSR 2015)}, author={Barik, Titus and Lubick, Kevin and Smith, Justin and Slankas, John and Murphy-Hill, Emerson}, year={2015}, pages={486–489} }
 @inproceedings{barik_2015, title={Improving Error Notification Comprehension in IDEs by Supporting Developer Self-Explanations}, booktitle={Proceedings 2015 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC)}, author={Barik, T.}, year={2015}, pages={293–294} }
 @article{barik_lubick_christie_murphy-hill_2014, title={How Developers Visualize Compiler Messages: A Foundational Approach to Notification Construction}, DOI={10.1109/vissoft.2014.24}, abstractNote={Self-explanation is one cognitive strategy through which developers comprehend error notifications. Self-explanation, when left solely to developers, can result in a significant loss of productivity because humans are imperfect and bounded in their cognitive abilities. We argue that modern IDEs offer limited visual affordances for aiding developers with self-explanation, because compilers do not reveal their reasoning about the causes of errors to the developer. The contribution of our paper is a foundational set of visual annotations that aid developers in better comprehending error messages when compilers expose their internal reasoning. We demonstrate through a user study of 28 undergraduate Software Engineering students that our annotations align with the way in which developers self-explain error notifications. We show that these annotations allow developers to give significantly better self-explanations when compared against today's dominant visualization paradigm, and that better self-explanations yield better mental models of notifications. The results of our work suggest that the diagrammatic techniques developers use to explain problems can serve as an effective foundation for how IDEs should visually communicate to developers.}, journal={2014 SECOND IEEE WORKING CONFERENCE ON SOFTWARE VISUALIZATION (VISSOFT)}, author={Barik, Titus and Lubick, Kevin and Christie, Samuel and Murphy-Hill, Emerson}, year={2014}, pages={87–96} }
 @inproceedings{barik_2014, title={Improving error notification comprehension through visual overlays in IDEs}, booktitle={2014 ieee symposium on visual languages and human-centric computing (vl/hcc 2014)}, author={Barik, T.}, year={2014}, pages={177–178} }
 @inproceedings{barik_everett_cardona-rivera_roberts_gehringer_2013, title={A community college blended learning classroom experience through Artificial Intelligence in Games}, ISBN={9781467352611}, url={http://dx.doi.org/10.1109/fie.2013.6685093}, DOI={10.1109/fie.2013.6685093}, abstractNote={We report on the experience of teaching an industry-validated course on Artificial Intelligence in Computer Games within the Simulation and Game Design department at a two-year community college during a 16-week semester. The course format used a blended learning just-in-time teaching approach, which included active learning programming exercises and one-on-one student interactions. Moskal's Attitudes Toward Computer Science survey showed a positive and significant increase in students in both interest (W(10) = 25, p = 0.011) and professional (W(10) = 49.5, p = 0.037) constructs. The Felder-Soloman Index of Learning Styles (n = 14) failed to identify any statistically significant differences in learning styles when compared to a four-year CS1 class. In the final class evaluation, 8 out of 13 students (62%) strongly or very strongly preferred the blended learning approach. We validated this course through four semi-structured interviews with game companies. The interview results suggest that companies are strongly favorable to the course content and structure. The results of this work serve as a template that community colleges can adopt for their curriculum.}, booktitle={2013 IEEE Frontiers in Education Conference (FIE)}, publisher={IEEE}, author={Barik, Titus and Everett, Michael and Cardona-Rivera, Rogelio E. and Roberts, David L. and Gehringer, Edward F.}, year={2013}, month={Oct} }
 @article{murphy-hill_barik_black_2013, title={Interactive ambient visualizations for soft advice}, volume={12}, ISSN={["1473-8724"]}, DOI={10.1177/1473871612469020}, abstractNote={ Some software packages offer the user soft advice: recommendations that are intended to help the user create high-quality artifacts but which may turn out to be bad advice. It is left to the user to determine whether the soft advice really will improve quality and to decide whether to adopt it. Visualizations can help the user in making this decision, but we believe that conventional visualizations are less than ideal. In this article, we describe an interactive ambient visualization to help users identify, understand, and interpret soft advice. Our visualization was developed to help programmers interpret code smells, which are indications that a software project may be suffering from design problems. We describe a laboratory experiment with 12 programmers that tests several hypotheses about our visualization. The findings suggest that our tool helps programmers to identify smells more effectively and to make more informed judgments about the design of the program under development. We then describe an application of our visualization technique in another domain: an English style and grammar advisor. This second application suggests that our technique can be applied to several domains and also suggests how the technique must be varied to make it domain specific. }, number={2}, journal={INFORMATION VISUALIZATION}, author={Murphy-Hill, Emerson and Barik, Titus and Black, Andrew P.}, year={2013}, month={Apr}, pages={107–132} }