Developers spend most of their time maintaining code, with little tool support. To maintain code, one must understand it. Clear code is easier to read and understand, and therefore less expensive and risky to evolve and maintain; it is also notoriously difficult to write. We will help developers write clearer code to speed maintenance, and increase developer productivity. Source code unites two channels - the programming language and natural language - to describe algorithms. LUCID will advance the state of the art in software engineering by developing new analyses that exploit the interconnections between these channels to find uninformative names, stale comments, and bugs that manifest as discrepancies between the two channels.

A fundamental aspect of many large scale systems is that the input to these systems are inherently "dynamic" in nature. Indeed, this happens to be the case with social networks like Facebook and Twitter, transport networks that are meant to be tracked in google maps, and data centres which support the increasingly popular cloud computing services. All these systems need to cope with the fact that the input data changes very rapidly over time. Friendship links get created and destroyed in the social networks every moment, the congestion on any given road in a transport network changes from one time of the day to another, and a cloud computing system like Microsoft Azure has to serve users that arrive and depart in an online manner. This leads us to one of the key challenges in dealing with "big data" under limited computational resources: How can an algorithm quickly update the solution to a computational problem after observing an update (i.e., change in its input)? A naive solution here will be to recompute the solution from scratch after every update. Is there any way one can do significantly better than this naive approach? The project will lead to major advances in our understanding of "dynamic algorithms", which is an important research area within theoretical computer science that is concerned with addressing precisely the question described above. The project will consist of three strands of work. The first two strands will develop a unified framework for dynamic algorithm design for fundamental computational problems, by exporting the popular paradigms for designing efficient static algorithms into the dynamic world. Specifically, it will focus on problems that admit fast primal-dual and greedy algorithms in the static setting, and convert them into fast algorithms in the dynamic setting. This will improve the state of the art dynamic bounds for multiple fundamental computational problems such as maximum matching, packing/covering linear programs, maximal independent set and finding dense subgraphs. The third strand will consider dynamic resource allocation problems that are of relevance to data centres and cloud systems, and it will build efficient dynamic algorithms for these problems. The project deals with a fundamental research topic and it will contribute towards significant advances in this important research area within Theoretical Computer Science.

"Leave no one behind" has been a key objective of the recently agreed UN 2030 Sustainable Development Goals (SDGs). As the poor, in particular the youth and women, are often being marginalised and excluded from market participation due to unequal access to education, resources and information, empowering and including these segments into the main stream market and income creation activities turns out to be an important imperative to achieve SDGs and build an inclusive society. This is important as developing countries are witnessing an upsurge of young people in rather inadequate labour market. While emerging digital technologies can become both an equaliser and a disruptive factor in labour markets, they can empower both women and youth. The decreasing cost of digital technology should thus foster and support new exchange mechanisms that will generate new models of value creation (Amit and Zott, 2012) and will lead business organisations towards network based systems (Dafe & Lewin, 1993; Dunbar & Starbuck, 2006). Many new digital technology-based business models have already been developed. These developments not only create new drivers for economic growth, but also lead to upgrading of capabilities of small business owners. Such increased capabilities will in turn enhance the welfare of the poor (Sen, 1999). However, there are a number of gaps to fill in order for this potential to fully materialise. (1) Most of the research focuses on the evaluation of the impact of technology on development. Little is known about the business models that are needed to transform the benefits of technology into jobs, income and a driver for growth for the poor (Seelos & Mair, 2007). (2) The existing studies mostly focus on e-trading businesses that sell products or services online, and normally require considerable initial capital investment to start the business. What type of new business model can help the poor to benefit from digital technology? This is an under-explored area for inclusive development. (3) Some research is available on how to use business models for digital innovations to support growth of new businesses and employment. How is it possible to design a business model to empower the poor who have no initial capital to benefit from technological progress is missing. What underlying institutional, regulatory and capability conditions are needed to ensure the success of such digital technology-based new business model? What role can the state and Multinational Enterprises (MNEs) play in this process? These questions will fill the significant gap and provide important policy and managerial implications. Drawing on inter-disciplinary research from technology, development studies and responsible business studies, this project aims to fill in the gap in the literature with an Inclusive Digital Model (IDMODEL) that will particularly include deprived youth and women. In particular, it will: 1) Develop, test and finalise a digital technology-based new business model which enables poor people to start a business based on their skills and experiences, while requiring minimum capital investment. 2) Evaluate the impact of this DT-based business model on jobs, income creation and capabilities building. 3) Analyse the underlying regulatory and capability conditions that are needed to ensure its success and scale up, and the possibility to replicate in other developing countries. 4) Examine how the state, MNEs and civil society can collaborate for inclusive development. The project will be supported by a multi-disciplinary team of researchers from the universities of Oxford and Birmingham, and collaborators in Bangladesh and China from both the private and public sectors. It will contribute to the literature by filling current gaps on technology, business model and inclusive development and its impact as well as producing novel datasets and robust empirical evidence to elaborate relevant policies for development.

Programming is hard. Adding new functionality to an existing, large, and perhaps poorly-understood system is a challenge, even for the most competent human programmer. Despite much progress in software development environments, programming still includes many human activities that are dull, unproductive and tedious. The GGGP project is motivated by the frustration often expressed as questions such as "Why do software engineers spend so long repeatedly performing the same tedious low level software development tasks?" and "How many times do programmers work out how to express the idea of null pointer checking in a particular context or adapt existing code for searching an iterated data structure?" We want to find a radically new approach to software development, supported by automated search that, we believe, will yield a dramatic reduction in development time. We propose a new approach to software development: Grow and Graft Genetic Programming (GGGP), in which a new feature is grown (using genetic programming) and subsequently grafted into an existing system. This grow and graft development approach aims to reduce the amount of tedious effort required by human programmer in order to develop and add new functionality into an existing system. Our initial proof of concept work found that surprisingly little human guidance and domain knowledge is required from the programmer to guide Grow and Graft Genetic Programming. We therefore believe that it can radically change programming, making it faster and less error prone, with a consequent transformative effect on the software industry. We also believe it may make it more enjoyable to a wider range of people, with potentially transformative impact on the wider public involvement in (and understanding of) software development. Our approach can be best understood in the context of the recent trend in Search Based Software Engineering (SBSE) called "genetic improvement", which uses existing code as "genetic material" that helps to automatically improve existing software systems, which has achieved several recent notable breakthroughs, such as speed ups of 7 to 70 times on real-world systems, human competitive results in optimising constraint solvers, and automated bug fixing and repair work on existing systems.

Testing is a crucial part of any software development process. Testing is also very expensive: Common estimations list the effort of software testing at 50% of the average budget. Our society increasingly depends on a working information infrastructure for more and more aspects of civic, commercial, and social life, while software at the same time becomes ever more complex. For example, a modern car has up to 100 million lines of software code, and software errors can easily lead to fatal consequences. Improving techniques to identify errors in software is therefore of utmost importance. Manual testing is common practice in software development. As manually testing a program is a laborious and error prone task, automation is desirable. However, automation requires the user to specify the correct behaviour up-front in terms of a specification, or later by adding test oracles to automatically generated tests - both alternatives are difficult. This problem is obliterated as test quality is usually measured with oracle-agnostic code coverage metrics. In truth, however, a test without a good oracle cannot find software bugs. This is the oracle problem, one of the longest standing and greatest remaining challenges in software testing. As both writing specifications and writing test oracles is difficult and needs to be done manually, this proposal aims to push automation further by exploring the middle ground: The novel concept of an oracle template allows to specify what should be tested and checked, but crucially, it does not require specifying the expected behaviour. Instead, automated test generation instantiates user-specified oracle templates to concrete tests with oracles, and the developer decides case by case about correctness. Thus, programs can be tested without the developer needing to write a specification or having to suffer through seemingly purposeless generated tests. Because test generation is driven by oracles, all tests have a purpose and the essential oracles required to be effective at finding software bugs. The novel concept of oracle templates requires extension of the current state of the art in test generation, as current techniques either assume the existence of an automated oracle (e.g. a specification) or focus exclusively on the code. This creates three challenges, which will be addressed in this project: -- Existing code-based testing techniques focus on reaching points in the code. This project will define the concept of oracle templates, and will explore test generation based on oracle templates as a search problem. Given an oracle template, search-based testing techniques will automatically create instances, which are test cases with oracles. -- Systematic testing is traditionally driven by the idea that a good test set covers all the code, which completely ignores the test oracle problem. This project will define systematic criteria and corresponding search-based test generation techniques to thoroughly test programs based on oracle templates. These criteria will ensure coverage of oracle templates, but will also ensure that the code is executed and checked by oracles (e.g. by applying mutation and data-flow analysis). -- It is impossible to take the human out of the software testing loop completely. Oracle templates are an attempt at minimizing the human effort, but the task of writing oracle templates still requires manual effort. Therefore, this project will explore strategies to automatically synthesise oracle templates based on standard testing patterns and usage examples. Ultimately, a developer would have all tests and oracles generated automatically on the click of a button, leaving only the task of confirming correctness of the produced examples. The success in addressing these challenges will be measured using automated experiments, controlled studies with student subjects, and industrial case studies at Google and Microsoft.