Seminars

Dr. Diana Kirk   (Auckland University, Aotearoa New Zealand)

Code Style Principles for Programming Educators and Practitioners

24 Nov. 3-4pm

It is widely acknowledged that code style is an important aspect of text based programming. We believe programs written with good style are easier to understand and change and so programmers are able to modify code quickly and correctly. As code changes occur whenever programmers extend functionality or resolve defects, code style is important from the earliest stages of development, before the first commit, through product maintenance. However, it is not entirely clear what is meant by ‘code style’ and advice on how to achieve it is often vague and/or conflicting. We have created a set of code style principles that we believe capture the essential characteristics of code style at an abstract level. Our objective is to provide a means of assessing code with respect to style that is programming language agnostic and allows implementation choices that are context-specific (for example, reader experience). I describe the principles and our approach to creating, evaluating and refining these.
Bio: Diana received an Honours degree in Mathematics from the Open University of Great Britain, an M.Sc. in Intelligent Knowledge Based Systems from the University of Edinburgh and a Ph.D. in Computer Science from the University of Auckland. Her industry background includes C programming (8 years), software process design (4 years) and software quality management (4 years). Her tertiary teaching and research experience spans 18 years. Research interests include the study of situated software practices, software code quality (both a consequence of her experiences in industry) and computer science education (a consequence of teaching experiences in tertiary education).

Prof. Dr. Dirk Riehle   (Univ. Erlangen / Bayave GmbH, Germany)

Open Source Compliance

27 Oct. 3-4pm

Open source gets complicated if you are shipping code to customers. Web apps, mobile apps, container images, and sometimes even server code trigger the full brunt of license obligations of the open source code they build on. In this talk, I will review open source license obligations, business risks from failing to comply with the licenses, and how to get on the path of shipping products correctly.
Bio: Prof. Dr. Dirk Riehle, M.B.A., is the Professor of Open Source Software at the Friedrich-Alexander University of Erlangen-Nürnberg. Before joining academia, Riehle led the Open Source Research Group at SAP Labs, LLC, in Palo Alto, California (Silicon Valley). Riehle founded the Open Symposium, now the international conference on open collaboration. He was also the lead architect of the first UML virtual machine. He is interested in open source and inner source software engineering, agile software development methods, complexity science and human collaboration, and software system architecture, design, and implementation. Prof. Riehle holds a Ph.D. in computer science from ETH Zürich and an M.B.A. from Stanford Graduate School of Business. He welcomes email at dirk@riehle.org, blogs at https://dirkriehle.com, and tweets as @dirkriehle

Dr. Rita Garcia   (Unity & Victoria University of Wellington)

Gender Influence on Student Teams’ Online Communication

29 Sept. 3-4pm

Collaboration is important during software development, but related work has found gender differences can influence the collaboration process, creating inequality in the teams’ dynamics. This talk presents findings from a study on gender differences emerging from team collaboration, focusing on student teams’ online communications during collaborative software development. The study involved 39 students, examining eight teams of 4-6 Software Engineering students communications using an online messaging platform, Slack, to complete an eight-week project. The talk will discuss how students responded to the initiated communication, and showed their help seeking behaviours. Discussion with educators is encouraged during the presentation, to consider how the findings can help administer and monitor group work in the classroom. Link to slides.
Bio: Dr Rita Garcia has worked over fifteen years in the film industry in DevOps and Release Engineering, supporting and establishing good software engineering practices at Pixar Animation Studio, Weta Digital, and Marvel Studios. Her experience motivated her PhD field of research in Computer Science Education (CSE) to support diversity in the Computer Science and Software Engineering disciplines. Her research focuses on helping Computer Science (CS) students build problems-solving skills that will help them organise and plan programming solutions. She developed a pedagogy that introduces introductory programming students to the software design process earlier in their studies. This pedagogy was applied within Canvas, a Learning Management System (LMS), so that students could be supported in a learning environment with minimal supervision. She also investigates the presentation of programming assignments designed to help CS students identify the problem’s goals and provide additional assistance to students to better understand the problem. Her work also focuses on students’ collaboration processes performed during group work. The goal of this work is to help reduce language during group work that might exclude women and underrepresented minorities from pursuing careers in the Tech field. Currently, Dr Garcia works at Unity as a Senior Software Engineer and is an Adjunct Research Fellow at Victoria University of Wellington. She remains involved in the academic community, promoting diversity and developing teaching strategies that can support students’ development of collaborative software development skills.

Dr. Fabian Gilson   (University of Canterbury, Aotearoa New Zealand)

Model-Driven Engineering for Agile Software Development

25 Aug. 3-4pm

The Model-Driven Engineering for Agile Software Development (MDE4ASD) project is about bringing semi-formal modelling practices into agile software development. As a main objective, we look into extracting information and generating models from textual input (e.g., user stories, design decisions) for further analysis. In this seminar, we will present two specific contributions within the MDE4ASD framework. First, we will present an approach to generate scenarios in the form of adapted robustness diagrams from user stories. We will discuss how a complete backlog can be transformed into graphical models where actors, entities and common processes are identified. Then we will introduce a non intrusive tool that record design decisions from conversation on online messaging services (i.e. Slack). This software bot uses natural language processing and machine learning techniques to decompose and classify decisions into formal decision models.
Bio: Fabian is a Senior Lecturer at the University of Canterbury, Aotearoa New Zealand. His main research interests are in model-driven software engineering (MDE), continuous integration and software engineering education. Fabian received his PhD from the University of Namur (Belgium) where he worked on model-driven techniques to formally transform software architecture models. He is now working in bridging MDE and agile software development, applying natural language processing and machine learning techniques to extract conceptual data from textual input.

Assoc.Prof. Thomas Kühne   (Victoria University of Wellington, Aotearoa New Zealand)

Taming the Complexity of Digital Twins

28 July 3-4pm

Digital twins (DTs) lie at the heart of a new vision to support manufacturing and cyber-physical systems. The realization of their full potential requires complex technical solutions, due to unprecedented synchronization requirements, the need to support scenario playing and solution space exploration, and their nature as hubs that tie together numerous heterogeneous technological spaces. Hence, a key factor in making the notion of DTs succeed in large scale scenarios is to manage overall system complexity. It is therefore critical that DT standards support DTs and their integration with other systems by introducing as little accidental complexity as possible. Unfortunately, the DT standards developed to date are based on architectures that have been shown to be detrimental to this goal. I first briefly elaborate on why current DT standards do not sufficiently address the faced challenges and subsequently present two modelling paradigms that synergistically reduce and manage complexity. I will specifically focus on multi-level modelling as an approach to avoid accidental complexity when modelling domains.
Bio: Thomas has been an Associate Professor at Victoria University of Wellington since November 2007. Before that he was an Assistant Professor at the Technische Universität Darmstadt (Germany) and an Acting Professor at the Software Engineering Department of the University of Mannheim (Germany). Thomas received a ten year most influential regular paper award from the Springer journal Software and Systems Modeling. He furthermore received two ACM SIGSOFT distinguished paper awards.

Assoc. Prof Tony Savarimuthu   (University of Otago, Aotearoa New Zealand)

Mining facets of decision-making in Python’s evolution – A story of three related projects

30 June 3-4pm

Success of an open source software (OSS) development community is often attributed to the underlying governance model, and a key component of this model is the decision-making process. In OSS projects, details relating to decision-making such as the decision-process that are made available to stakeholders are at times incomplete and may remain buried and hidden in large amounts of archived data. This talk aims to provide an overview of three projects that aim to unearth three facets of decision-making during the evolution of the Python language: decision-making processes, decision-rationale, and the influence of different roles on decision-making.
Bio: Associate Professor Tony Savarimuthu works in the Information Science department at the University of Otago. Tony conducts research in Software Engineering, Multi-Agent Systems and Information Systems. In Software Engineering, his works explore the role of human-centric aspects in software development such as social norms, expectation violations, decision-making processes, and detecting toxicity in project communication. His works employ data science approaches to extract insights from large software repositories such as Python development archives. A spotlight of his works can be found here.

Assoc. Prof Tony Clear   (Auckland University of Technology, Aotearoa New Zealand)

Do Scaling Agile Frameworks Address Risk in Global Software Development? An Empirical Study

26 May 3-4pm

Driven by the need to coordinate activities of multiple agile development teams cooperating to produce a large software product, software-intensive organizations are turning to scaling agile software development frameworks. Despite the growing adoption of various scaling agile frameworks, there is little empirical evidence of how effective their practices are in mitigating risk, especially in global software development (GSD), where project failure is a known problem. In this study, we develop a GSD Risk Catalog of 63 risks to assess the degree to which two scaling agile frameworks–Disciplined Agile Delivery (DAD) and the Scaled Agile Framework (SAFe)–address software project risks in GSD. We examined data from two longitudinal case studies implementing each framework to identify the extent to which the framework practices address GSD risks. Scaling agile frameworks appear to help companies eliminate or mitigate many traditional risks in GSD, especially relating to users and customers. However, several important risks were not eliminated or mitigated. These persistent risks in the main belonged to the Environment quadrant highlighting the inherent risk in developing software across geographic boundaries. Perhaps these frameworks (and arguably any framework), would have difficulty alleviating, issues that appear to be outside the immediate control of the organization.
Bio: Tony Clear is an Associate Professor in the School of Engineering, Computer and Mathematical Sciences and Co-Director of the Software Engineering Research Lab at Auckland University of Technology. He is an Associate Editor for ACM Transactions on Computing Education, for Computer Science Education, and ACM Inroads and a steering committee member for the ICGSE conference. He is active in the research topics of global software engineering, and collaborative computing. This combines with interests in teaching within the GSE education, software engineering and computer science education communities. He is currently working with Prof Daniela Damian as a visiting RSNZ Catalyst International Leadership Fellow on a joint project Leading the Way in Software Ecosystems for NZ.

Dr. Daniel Alencar da Costa   (Universtity of Otago, Aotearoa New Zealand)

The promises and downsides of Continuous Integration

28 April 3-4pm

Continuous Integration (CI) is a set of practices that support development teams to continuously and successfully build their software. To properly employ Continuous Integration, a series of tools are required, such as automated tests, build systems, communication bots and many more. While there has been a wide adoption of CI in the practice, it is still not clear yet, from an empirical point of view, whether Continuous Integration is really the “silver bullet” in software development. In this talk, I’ll discuss what my research can tell us about the usage of Continuous Integration.
Bio: Dr. Daniel Alencar da Costa is a Senior Lecturer in the Information Science department at the University of Otago. Daniel is passionate about release engineering and software debugging. More recently, most of his research has focused on Continuous Integration. Software engineering if far from being the his only passion as Daniel also loves writing, games, and going to the gym.

Dr. Valerio Terragni   (University of Auckland, Aotearoa New Zealand)

Leveraging Evolutionary Computation To Automate Test Oracle Generation and Improvement

31 March 3-4pm

The challenge of distinguishing correct from incorrect test executions is called the (test) oracle problem and it is recognised as one of the fundamental challenges in software testing. It is the major obstacle to full software test automation. In this talk, Valerio will present his recent research project GAssert [ESEC/FSE 2020, ICSE 2021, GECCO 2021], the first technique to automatically improve assertion oracles. Assertion oracles are executable boolean expressions placed inside the program that should pass (return true) for all correct executions and fail (return false) for all incorrect executions. Because designing perfect assertion oracles is difficult, assertions often fail to distinguish between correct and incorrect executions. In other words, they are prone to false positives and false negatives. Given an assertion oracle and evidence of false positives and false negatives, GAssert implements a novel co-evolutionary algorithm that explores the space of possible assertions to identify one with fewer false positives and false negatives. An empirical evaluation on 34 Java methods from 7 different Java projects shows that GAssert effectively improves assertion oracles. GAssert outperforms two baselines (random and invariant- based oracle improvement), and is comparable with and in some cases even outperformed human-improved assertions. The results also show that GAssert can generate effective assertion oracles starting from an empty assertion, thus also addressing the automated test oracle generation problem.
Bio: Valerio is a Lecturer in Software Engineering at The University of Auckland, New Zealand since February 2021. From 2017 to 2020, he was a Senior Research Fellow at USI in Lugano, Switzerland. In 2017, he obtained his PhD at The Hong Kong University of Science and Technology (HKUST) in Hong Kong. He received his B.Sc. and M.Sc. degrees in Computer Science from The University of Milano-BICOCCA, Italy. His research has been published in top software engineering venues, such as ICSE, ESEC/FSE, ASE, ISSTA, among others.

Dr. Marco Servetto   (Victoria University of Wellington, Aotearoa New Zealand)

Forty2: Enforcing modular security

24 Feb. 3-4pm

The main point of the language 42 is that it enforces modular security; that is: a security architect can set up specific object capabilities that are mathematically guaranteed to enforce customised security guarantees, and the rest of the code, even if adversarial, can not break those guarantees. While the normal security model is ‘the clean garden’ in 42 we live in the ‘dark forest’ security model: In the clean garden you consider your local machine to start from a clean uncompromised state and work toward keeping it clean. This mindset may work (at least in the short term) if you are running a server and you own/control the machine. In the dark forest model the local machine is considered already compromised (the root still is safe, otherwise all bets are off). This mindset makes sense if you are simply shipping software to your users, or if you have the very reasonable fear that your ‘clean’ server may actually be already compromised… because eventually it will be. That is, with 42 even if adversarial code is running in a security critical process, such a process will still be unable to do any wrong action. That is, the process may become unable to do any action/crash or loop, but it will not interact with the outside world in an incorrect way. In 42, thanks to reference and object capabilities and secure handling of native code this is possible: A little part of the code can define security actions: what actions are available and what constraints must be respected for those actions to be allowed to run. Then, all the rest of the code will be unable to break those constraints. Main language website at https://Forty2.is. Youtube channel about 42: https://www.youtube.com/MarcoServetto.
Bio: Marco completed his PhD in Genova Italy in 2011 and then moved to New Zealand to become a lecturer in Engineering and Computer Science (ECS) in Victoria University of Wellington (VUW) in New Zealand. Marco worked on programming language design for more than 10 years, and now believes that programming languages are discovered, not invented. He is very talkative, and enjoys breaking incorrect mathematical models.

Prof. Daniela Damian   (University of Victoria, Canada)

Co-innovation and software engineering in open software platform ecosystems

28 Oct. ’21 3-4pm

Software development is experiencing a paradigm shift from the more traditional bespoke or market-driven model to a software platform model that uses open innovation within an ecosystem of third party extensions and integrations to create value for a much larger customer market. This talk describes insights from a recent study from two service software platform ecosystems. In particular, it provides a discussion of (1) the co-innovation process that takes place within such ecosystems and (2) software engineering challenges and tradeoffs experienced as a direct consequence of openness in these ecosystems.
Bio: Daniela Damian is a Professor of Software Engineering in University of Victoria’s Department of Computer Science, in Canada, where she leads research in the Software Engineering Global interAction Laboratory (SEGAL). Her research interests include Empirical Software Engineering, Requirements Engineering, Computer-Supported Cooperative Work and more recently software ecosystems. Her recent work has studied the developers’ socio-technical coordination in large, geographically distributed software projects, as well as stakeholder management in large software ecosystems. Daniela has served on the program committee boards of several software engineering conferences. She is currently serving on the editorial boards of Transactions on Software Engineering, the Journal of Requirements Engineering, is the Requirements Engineering Area Editor for the Journal of Empirical Software Engineering, and the Human Aspects Area Editor for the Journal of Software and Systems. She will be ICSE 2022 Program Co-Chair.

Prof. John Grundy   (Monash University, Australia)

Impact of end user human aspects on software engineering

30 Sept. ’21 3-4pm

Software is designed and built to help solve human problems. However, much current software fails to take into account the diverse end users of software systems and their differing characteristics and needs eg. age, gender, culture, language, educational level, socio-economic status, physical and mental challenges, etc. I give examples of some of these diverse end user characteristics and the need to better incorporate them into requirements engineering, design, implementation, testing, and defect reporting activities in software engineering. I report on some of our work trying to address some of these issues, including: use of personas to better characterise diverse end user characteristics; extending requirements and design models to capture diverse end user needs; analysis of app reviews and JIRA logs to identify problems and ways developers try to address them; analysis of approaches to improve the accessibility of software designs for diverse end users; improved human-centric defect reporting approaches; and use of living lab co-design approaches to ensure end users are first class contributors during all phases of software development. I finish by outlining a research roadmap aiming to improve the incorporation of end user human aspects into software engineering.
Bio: Grundy is Australian Laureate Fellow and Professor of Software Engineering at Monash University, Melbourne, Australia. His five year Laureate programme on Human-centric Model-driven Software Engineering aims to address some of the deficiencies in current software development practices that fail to take account of diverse software developer human characteristics and diverse software end user human characteristics. He leads the Human-centric Software Engineering (HumaniSE) lab and has published over 500 refereed papers in software tools, visual modelling languages, model-driven software engineering, software architecture, requirements engineering, and software security. He is a Fellow of Automated Software Engineering and Fellow of Engineers Australia.

Nick Cameron   (Microsoft, Aotearoa New Zealand)

Rust: a revolutionary systems programming language

29 July ’21 3-4pm

Rust is a modern systems programming language. It offers high performance and low-level control of memory, making it suitable for applications such as operating systems, web browsers, databases, games, etc. It is memory safe and guarantees data race freedom, meaning it offers huge security advantages over other languages in the systems domain. The language and tooling are expressive, ergonomic, and sound; meaning higher productivity. This talk will give an introduction and overview of the language and its applications, outline current developments, and discuss some of the interesting corners of the language found when using Rust for large, real-world projects.
Bio: Nick Cameron is a principal engineer at Microsoft working on Rust. He helped develop Rust at Mozilla through the 1.0 release and 2018 edition. He was a member of the Rust core team and has contributed to its language design, compiler, tools, and project governance. He has worked on distributed databases at PingCAP, and layout and rendering in Firefox at Mozilla. He has a PhD in type systems from Imperial College London.

Patrick Lam   (University of Waterloo, Canada)

Ask not what you can do for tests; ask what tests can do for you

24 June ’21 3-4pm

Tests are a ubiquitous feature of modern software. We are under-using this promising source of developer-provided information about our software. In this talk, I will sketch a research programme that leverages the full potential of tests in the context of program analysis. Tests provide valuable information about actual concrete program executions. This information has been used by dynamic analysis tools, e.g. Daikon for inferring program invariants, and Tamiflex for summarizing uses of Java reflection. Furthermore, at the limit, exhaustive test generation can even show the absence of some kinds of bugs. I believe that we can do much more than test generation: good tools can help developers write well-targeted test cases and explore key parts of a program’s behaviour. To that end, I’ll talk about some of my ongoing work on automatically adding sibling tests, as well as test refectoring. Getting back to what tests can do for you: tests can enable dynamic analyses to delimit API surfaces of libraries as they are used by their clients. But I’m even more excited about combining the strengths of static analysis and the information provided by tests, and I’ll conclude by speculating about novel static analyses with drastically fewer false alarms than at present.
Bio: Patrick Lam is an Associate Professor of Electrical and Computer Engineering at the University of Waterloo and a Visiting Scholar at VUW, having just completed his term a Director of Waterloo’s Software Engineering Program. His research interests focus on static analysis, particularly of developer-supplied information like annotations and test cases. Patrick has been making a concerted effort to enjoying New Zealand’s outdoors.

Jeremy Ginsberg   (Auckland, Aotearoa New Zealand)

The Making of Flu Trends

27 May ’21 3-4pm

Launched in 2008, Google Flu Trends was one of the earliest systems demonstrating the power of “big data”, harnessing the collective intelligence of 100’s of millions of search users to accurately track the spread of disease outbreaks. When the first cases of H1N1 Swine Flu emerged in 2009, the United States CDC and health agencies around the world relied on Flu Trends to help inform key public health decisions. In this talk, I cover the origins of the project and the methodology we developed, along with a retrospective on some of the lessons learned.
Bio: Jeremy Ginsberg is a software leader with 17 years of experience building products and leading teams in Silicon Valley. Most recently, Jeremy served as Head of Engineering and Data Science at Color, a fast-growing health tech startup in California. Jeremy now lives in Auckland, New Zealand and works with Movac as CTO-in-Residence. Previously, Jeremy was a Vice President at Twitter where he led the global revenue engineering teams. Jeremy also spent 9 years as a software engineer and technical lead at Google, where he led projects focused on machine learning, search quality, survey analytics, and a novel disease surveillance project called Flu Trends. Jeremy holds a M.S. in Computer Science and a B.S. in Symbolic Systems from Stanford University. Jeremy’s connection to New Zealand dates back to 2002, when he taught computer science at Victoria University of Wellington.

Rob O’Callahan   (Pernosco, Aotearoa New Zealand)

The Future of Debugging

25 Mar. ’21 3-4pm

Developers spend a lot of time debugging. Lots of research has been done on record-and-replay systems and other advanced debugging tools, but industry adoption has been slow. We’ll talk about ongoing efforts to improve debugging in practice in the context of the “rr” and “Pernosco” debuggers. rr is a state-of-the-art open-source record/replay/reverse debugger for C/C++/Rust on Linux which is seeing a lot of adoption. Pernosco is a considerably more ambitious cloud-based omniscient debugger for a similar target market. I will give an overview of the technology behind these debuggers, their strengths and weaknesses, and what we’re learning from the people using (and not using) them.
Bio: Robert O’Callahan obtained a PhD in static program analysis from CMU in 2001, advised by Daniel Jackson and Jeannette Wing. He worked on dynamic analysis at IBM Research, then dived into full-time browser engine development for Mozilla for ten years, where he became a Distinguished Engineer and also led the development of rr. In 2016 he left Mozilla to work on debugging full time, cofounding the Pernosco project.

Robert Biddle   (Carleton University, Canada)

Clickety-Click: Improving Collaborative Software Development

25 Feb. ’21 3-4pm

Successful software involves several different perspectives and sources of expertise. Agile Software Development emphasizes collaboration, but our studies show many opportunities are missed, and many beneficial practices are not recognized. In this talk, I will review some of our research findings, and suggest how better understanding of human behaviour can lead to collaboration, and better software.
Bio: Robert Biddle is a Professor in the School of Computer Science and Institute of Cognitive Science at Carleton University in Ottawa, Canada. His research is in Software Design and Human-Computer Interaction. His current research projects are on usable security, especially authentication and security decision-making, and on human factors in software design and development. Robert has Bachelors and Masters degrees in Mathematics and Computer Science from the University of Waterloo in Canada, a PhD from the University of Canterbury in New Zealand, and has diplomas in both childhood and adult education. He has awards for research, teaching, and graduate mentorship; he is a Commonwealth Scholar, and a Fellow of the New Zealand Computer Society.