{'fraction_non_alphanumeric': 0.023659741954029343, 'fraction_numerical': 0.004024367323021813, 'mean_word_length': 5.34469696969697, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 3, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 8, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Deep Learning&Software Engineering: State of Research and Future Directions

Given the current transformative potential of research that sits at the intersection of Deep Learning (DL) and Software Engineering (SE), an NSF-sponsored community workshop was conducted in co-location with the 34th IEEE/ACM International Conference on Automated Software Engineering (ASE'19) in San Diego, California. The goal of this workshop was to outline high priority areas for cross-cutting research. While a multitude of exciting directions for future work were identified, this report provides a general summary of the research areas representing the areas of highest priority which were discussed at the workshop. The intent of this report is to serve as a potential roadmap to guide future work that sits at the intersection of SE&DL.


Executive Summary
The advent of deep learning (DL) has fundamentally changed the landscape of modern software. Generally, a DL system is comprised of several interconnected computational units that form "layers" which perform mathematical transformations, according to sets of learnable parameters, on data passing through them. These architectures can be "trained" for specific tasks by updating the parameters according to a model's performance on a labeled set of training data. DL represents a fundamental shift in the manner by which machines learn patterns from data by automatically extracting salient features for a given computational task, as opposed to relying upon human intuition. These DL systems can be viewed as an inflection point for software development, as they enable new capabilities that cannot be realized cost-effectively through "traditional" software wherein the behavior of a program must be specified analytically. This has ushered in advancements in many complex tasks, often associated with artificial intelligence, such as image recognition, machine translation, language modeling, and recently, software engineering. DL is fundamentally intertwined with software engineering (SE), primarily according to two major themes.
The first of these two themes is related to DL-techniques when viewed as a new form of software development, and in this report we refer to this as Software Engineering for Deep Learning (SE4DL). In essence, the application of DL to a computational problem represents a new programming paradigm: rather than analytically specifying a program in code, a program is "learned" from largescale datasets. This new form of development carries with a new set of challenges that represent several opportunities for novel research.
The second of these two themes is related to leveraging Deep Learning techniques in order to automate or improve existing software development tasks, which we refer to as Deep Learning for Software Engineering (DL4SE). There currently exists an unprecedented amount of software data that is freely available in open source software repositories. This data spans several different types of software artifacts, from source code and test code, to requirements and issue tracker data. Given the effectiveness by which DL systems are able to learn representations from such largescale data corpora, there is ample opportunity to leverage DL techniques to help automate or improve a wide range of developer tasks. However, with this opportunity also comes a number of challenges, such as curating datasets to develop techniques for particular development tasks, and designing DL models that effectively capture the inherent structure present in a wide range of different software artifacts.
Given the current transformative potential of research that sits at the intersection of DL and SE, an NSF-sponsored community workshop was conducted in co-location with the 34th IEEE/ACM International Conference on Automated Software Engineering (ASE '19) in San Diego California. The goal of this workshop was to outline high priority areas for cross-cutting research that sits at the intersection of Deep Learning and Software Engineering. While a multitude of exciting directions for future work were identified, we provide a general summary of the research areas representing the areas of highest priority which are expanded upon in Section 1. The remainder of the report expands upon these and other areas for future work with high potential payoff.

Community Research Challenges
• Laying the Foundations for SE4DL including defining DL workflows, proper DL abstractions, and theory for DL development. -A systematic taxonomy and understanding of different development workflows for DL-based systems and how these differ from traditional software development practices is needed. Researchers should also look to develop salient DL program abstractions that can be easily constructed and analyzed in a formal manner.
• Identifying failure modes of DL Systems and their corresponding countermeasures -There is a dire need for a detailed categorization and understanding of common types of faults for DL-based systems alongside automated techniques for detecting, debugging, and fixing such faults.
• Furthering DL4SE through the development of tailored architectures, use of heterogeneous data sources, focusing on new SE tasks, and combining DL with existing empirical data. -New DL models designed specifically for given SE tasks that learn orthogonal information from a heterogeneous software artifacts while making use of the specific structural properties of such artifacts. Furthermore, researchers should look for ways to combine existing empirical knowledge into approaches for DL4SE, examine new categories of tasks, and look towards incorporating multi-modal data representations.
• Establishing educational and pedagogical materials to better support training related to DL-based development via academic-industry partnerships -While progress is being made on understanding DL-based development workflows, there should be parallel effort dedicated to developing effective pedagogical and educational material to transfer newly discovered knowledge on to students. Industry-academic partnerships could aid in ensuring the immediate impact of such material.

The Interplay between Deep Learning & Software Engineering
While DL systems bring with them the potential to tackle problem domains generally considered to be outside the realm of "traditional" programs, they represent a radical shift in the manner in which software is created. These changes encompass the emergence of new development workflows, new development artifacts, and new program properties that are, as of yet, not well understood. For example, DL models exhibit (i) a high degree of coupling between different model components, (ii) inherent stochasticity, (iii) distinct computational encodings, (iv) extreme sparseness in their representations of data, and (v) specifications that are inherently difficult to pin down. Because of this, many of the software engineering (SE) techniques and processes that have been developed and refined over decades for traditional software systems are not directly applicable to DL systems. For instance, techniques assuming deterministic behavior of software might fail due to the stochasticity of DL models whereas techniques that might assume a program is well-defined over most of its input domain (such as fuzzing) might fail due to the sparseness. Thus, there are clear challenges that exist related to understanding and supporting a new software development paradigm for DL systems, which we will refer to as Software Engineering for Deep Learning (SE4DL).
While challenges exist in adapting SE techniques and practices to DL systems, the capabilities that DL systems also offer a tremendous opportunity to improve or automate several aspects of the "traditional" software development process. While DL provides a powerful solution to certain complex computational intelligence tasks, it is likely that "traditional" analytical programming methods will be more cost-effective for easily specifiable tasks, such as interfacing with a database. Thus, it would be preferable to automate or improve developer's effectiveness in these tasks. DL is poised to offer transformative techniques for traditional software development due to (i) the scale of software artifact data (e.g., code) in online repositories, (ii) the automated feature engineering provided by DL techniques, (iii) the robustness and scalability of optimization techniques such as gradient descent, and (iv) the transfer-ability of traditional DL applications (such as language modeling) to SE artifacts. These factors indicate the great potential for DL to tangibly improve the traditional software development process, and we refer to this area of research as Deep Learning for Software Engineering (DL4SE).

Summary of Research Opportunities in SE4DL
In this report, we identify pertinent challenges related to SE4DL that were discussed at the workshop and motivate fundamental research to: • Expose the structure, variability, and characteristics of existing workflows for creating DL systems. Decades of empirical research on the development workflows for traditional software engineering systems have provided a wealth of knowledge for such processes. However, given the nascent state of DL-based software systems, there is a need for additional empirical work with the aim of understanding emerging DL-based development workflows. Such work will require close cooperation between academic and industrial researchers, as indicated by early studies [6].
• Identify the abstractions inherent in DL workflows, models, and implementations which form the basis for SE of DL. Much of the automated support for traditional software systems is driven by mature research and techniques for program analysis. These program analysis techniques are often built upon analyzing and manipulating abstract representations of traditional software programs (e.g. using abstract syntax trees or control-flow graphs).
Thus, before work can begin in earnest on new classes of program analysis techniques for DL-based systems, researchers need to understand and define appropriate abstractions that are amenable to more advanced analysis and manipulation than model code or weights.
• Identify modes of failure and their counter-measures within these workflows. While failures and faults in traditional software systems tend to be quite varied, empirical research on understanding software bugs and testing has provided a rich knowledge base of faults across different types of systems. This has led to the formulation of automated techniques for identifying, reporting, triaging, and fixing such faults. However, the failure modes of DL-based systems currently are not well understood. For instance, faults may be highly coupled to the task a given model is employed for, and it may not be clear whether a given fault maps back to problems with a given model or the dataset the model learned from. Further research is needed to better understand the nature of faults for DL-based systems so that new techniques for testing and verification can be developed.
• Establish theoretical foundations upon which cost-effective SE techniques for DL systems can be built. Formal program analysis techniques have become a key building block for scalable and accurate analysis of software systems. However, proper theoretical underpinnings for DL-based software are needed in order to help help drive the next generation of these techniques. For example, defining implicit model-level property specifications is a necessary next step towards driving advancements in the verification and validation of DL-based systems.

Summary of Research Opportunities in DL4SE
Additionally, we identify several promising directions for future work related to DL4SE including: • Combining features learned from large-scale SE data with empirical human knowledge to more effectively solve SE tasks. Decades of research on traditional SE processes and techniques has led to the development of a sizeable knowledge base regarding best practices for various tasks, attributes of effective tools, and understanding of human-centered processes. While DL techniques have shown immense potential in automatically learning features from large datasets, the empirical knowledge from the SE community should not be completely ignored, as such synthesized knowledge may not necessarily be captured by DL techniques. Thus, there is need to develop creative techniques for combining the learned features of DL-based models with empirical knowledge to build more effective automated approaches. Such research could manifest the in the creation of labeled training datasets drawn from existing knowledge bases and taxonomies or in guiding DL techniques to learn specific features through targeted data pre-processing.
• Leveraging heterogeneous sources of SE data (source code, requirements, issues, visual artifacts). While code is generally regarded as the essence of a software system, in no way is it the only representation of software that developers handle in their daily workflows. In fact, software data is contained across three major information modalities: (i) code represents source code and its corresponding abstractions; (ii) natural language manifests across a variety of software artifacts such as requirements, comments, issue trackers, bug reports, among others; finally (iii) graphical artifacts are also abundant in software, comprising user interfaces and design documents among others. Given the inherent diversity among these representations, it stands to reason that these different information modalities capture orthogonal properties or knowledge about a given underlying software system. Thus, future work should look for creative methods of combining these information sources together for richer DL-based representations of software.
• Developing tailored architectures that exploit the unique properties of SE data in order to offer better automated support to developers. DL techniques have largely focused upon sequence-based learning for natural language corpora and spatial-based learning for graphical data. While such techniques can be applied "out of the box" for SE data such as code, requirements, or graphical data, artifacts of traditional software systems exhibit generally well-understood structural properties (e.g., control-flow in code and layouts of widgets in graphical user interfaces). As such, there is a need for researchers to develop techniques that take advantage of these structural properties in order to learn more effective DL-based representations of software artifacts for a variety of uses.
• Defining a systematic and reproducible research methodology for DL applied to traditional SE tasks. Reproducible and replicable research is the driving factor of scientific discovery. While all scientific disciplines face challenges related to the trade-offs of new discoveries versus the verifiability of past results, research involving DL techniques poses further challenges to reproducibility. Extremely large scale datasets, stochastic training processes, and variability in data preprocessing all contribute to unique difficulties in reproducibility of research related to DL4SE. Thus, rigorous research methodologies and transparency in the research process are essential.

Summary of Cross-Cutting Research Opportunities
Finally, this report outlines workshop discussions of several concerns, serving as topics for future work, that cross-cut both SE4DL and DL4SE: • Developing methods to explain how DL-based systems arrive at predictions. Given their complex, high dimensional representations of data, it can be difficult to interpret a given prediction made by a modern DL-based software system. Such opaqueness complicates research that cross cuts both SE4DL and DL4SE. For instance, understanding common failure modes of DL systems will be difficult without some degree of model interpretability, furthermore, DL-based tools to automate traditional development tasks may be difficult to interpret in practice. Thus, interdisciplinary research on model explainability is needed.
• Education for both students who will seek emerging positions that require engineering systems enabled by both DL and software technologies, and researchers who will study the inter-play of DL and SE. Given the rapidly growing popularity of DL-based software systems, it is imperative that educational materials for both students and researchers are developed and widely disseminated. For students, coursework on both fundamental machine learning principles, as well as effective software engineering practices for DL-based systems will be important areas of curriculum development. For researchers, materials that offer guidance on rigorous empirical methods for carrying out research at the intersection of DL and SE are needed.
• Community infrastructure for research in DL applied to SE, and for investigating the engineering fundamentals of DL systems. A shared community infrastructure for managing a variety of DL-based artifacts such as models, code, and evaluation metrics would drastically improve the reproducibility of cross-cutting research.
• The need to foster a cohesive research community, involving both academics and industrial practitioners, in order to move the field forward. The need for academic-industrial partnerships to advance several of the research directions above is immediately clear. For work on SE4DL, there is a need to study and understand current industrial practices and applications, and prove out new methodologies or tools in practice. For work on DL4SE, industrial datasets can be invaluable, as can access to evaluate DL-driven automation with real developers. Such partnerships should be a major goal for research moving forward.

Report Structure
The remainder of this report is structured in a manner that mirrors the breakout sessions of the 2019 NSF Workshop on Deep Learning and Software Engineering (Section 8). That is, each section following the introduction is dedicated to summarizing the discussion and crystallizing detailed directions for future work as specified by the attendees of the workshop. These directions are delineated in the text as discrete points labeled according to the overarching research topic in which they are situated. These sections largely expand upon the summary of research opportunities that are discussed above and in the Executive Summary.

Background
Software engineering (SE) research investigates questions pertaining to the design, development, maintenance, testing, and evolution of software systems. As software applications pervade a wide range of industries, both open-and closed-source code repositories have grown to become unprecedentedly large and complex. This results in an increase of unstructured, unlabeled, yet important data including requirements, design documents, source code files, test cases and defect reports. Previously, the software engineering community has applied traditional machine learning (ML) techniques to identify interesting patterns and unique relationships within this data to automate or enhance many tasks typically performed by developers. Unfortunately, the process of implementing ML techniques is often a tedious exercise in careful feature engineering, wherein researchers experiment with identifying salient pieces of data that can be leveraged to help solve a given problem or automate a given task.
Due to recent improvements in computational power and the amount of memory available in modern computer architectures, the rise of DL has ushered in a new class of learning algorithms particularly suited for large datasets. DL represents a fundamental shift in the manner by which machines learn patterns from data by automatically extracting salient features for a given computational task, as opposed to relying upon human intuition. Deep Learning approaches are characterized by "architectures" comprised of several "layers" that perform mathematical transformations, according to sets of learnable parameters. These computational layers and parameters form models that can be trained for specific tasks, such as image classification, by updating the parameters according to a model's performance on a set of training data. Given the immense amount of data in software repositories that can serve as training data, deep learning techniques have ushered in advancements across a range of tasks in software engineering research including automatic software repair [91], code suggestion [42], defect prediction [95], malware detection [54], feature location [28] among many others [61,94,58,100,105,43,88,59]. This field of research, which we refer to as DL4SE, shows clear potential for transforming the manner by which a variety of specific "traditional" software development tasks are performed. However, there are still several open questions that represent promising opportunities for research moving forward.

Identifying Applicable SE Tasks
One of the first questions that a researcher must ask when working on DL4SE topics is the SE task to which a DL approach will be applied to improve, automate, or study. Recent work from the SE community [37] seems to suggest that applying DL to automate certain SE-related tasks may not provide improvements in either effectiveness or efficiency of techniques. Therefore, researchers must critically analyze the problem domain that they plan to target in order to decide whether or not a DL-based solution is appropriate given the context, and should always compare against a computationally "simpler" baseline. For instance, it may be better to apply more formal static analysis techniques to provide certain guarantees of program behavior, as opposed to DL techniques. Generally, DL models tend to be better applied in tasks where the relevant features for delineating patterns are difficult to engineer, or pin down analytically. This being said, there are a number of un-or under-explored SE tasks that may serve as promising future applications. DL4SE 1 : Potential SE tasks identified as showing promise for automation or improvement via DL techniques include: (i) software testing (in various forms), (ii) troubleshooting tasks (e.g. incident management, resolving deployment bugs), (iii) bug triaging, and (iv) code review. More broadly, any SE task for which it is possible to collect data, but difficult to engineer salient features may be ripe for DL applications.
While choosing an appropriate SE-related problem domain is important to ensure that a DL application is appropriate, there are also downstream questions that must be answered regarding the usability of such systems and fit into modern development workflows. Ultimately, any automated system that is designed with DL underpinnings must somehow fit into the day-today workflow of developers and fundamentally improve the specified task. As such, researchers should be consciously thinking about how the tool they are building will fit into such workflows, and ultimately interface with developers or other relevant software practitioners. The general experience from industrial practitioners thus far has been that tools or approaches that are designed to work synergistically with developers tend to be the ones that are most successful in practice. Automatically performing tasks outright without the potential for developers to intervene can lead to distrust and slow or low adoption. Thus, there is clear need both for existing research on DL-powered tools to consider its practical applicability, and for researchers to study and better understand how to enable synergistic relationships between these DL-powered tools and developers within the context of specific SE tasks. DL4SE 2 : Research into understanding and enabling synergistic relationships between developers and DL-powered SE tools and techniques is needed in order to ensure that such tools are able to effectively support developers in practice.

Data Resources in DL4SE Research
DL techniques are inherently data-centric. As such, the various types of SE data that are being used to drive advancements in DL4SE research are vital to research workflows. As software has continued to grow in its pervasiveness, researchers have been met with a marked increase in the availability of open source software data freely hosted in online repository ecosystems such as GitHub, GitLab, and Sourceforge, just to name a few. The data contained within these software repositories is not solely comprised of code, instead they typically contain a variety of artifacts such as requirements, issues, design documents and even graphical data such as screenshots and videos of user interfaces. While these artifacts represent a rich set of resources to which SE researchers can apply DL, there are a variety of challenges in properly "cleaning" or preparing the data such that relevant patterns can be learned for a particular SE task. The process of sourcing large-scale datasets from open source software repositories brings with it potential pitfalls (e.g., the dangers of code duplication [5]) that must be identified and studied in order to better understand their effects on downstream SE tasks.
There is a need for further research that examines the methods by which large scale datasets are curated from open source software repositories and "cleaned", including the potential (negative or positive) implications on DL-based techniques aimed at improving or automating downstream SE tasks.
Perhaps the most popular form of DL techniques that are applied in practice today are those based on the concept of supervised learning, wherein patterns are learned from data that has been "labeled" with explicit patterns to be learned by the DL system (e.g., labeling images with categories that describe the image). Curating large labeled datasets is typically a time and effortintensive undertaking, as it requires manual labeling of discrete pieces of data. However, due to the structure inherent in software artifacts there is the potential for synthesizing automatically labeled datasets by leveraging this structure. For example, compilers could be used as an "oracle" of sorts for automatically labeling code that is structurally sound, and different types of code constructs could be automatically labeled through representations as Abstract Syntax Trees (ASTs). DL4SE 4 : There are ample research opportunities for synthesizing automatically labeled datasets for SE tasks by exploiting the inherent structure present in a range of software artifacts.
The variety of software artifacts that are available in open source repositories represent an interesting research opportunity for SE researchers. Broadly speaking, the various artifacts that exist (source code, test code, issue tracking data, screenshots, logs, requirements, etc.) belong to one of (or a mixture of) three different information modalities: (i) code, (ii) natural language, and (iii) graphical information. Software systems are complex, and generally leverage abstractions to help developers mentally manage the complexity of a given system. Given the diversity in different software artifacts, and their corresponding representations in the information modalities listed above, it stands to reason that these different representations capture orthogonal attributes or aspects across different software abstraction levels. As such, this would signal the need for research that both attempts to understand what aspects of software these different artifacts capture, and how different artifacts across information modalities might be combined together in order to form more descriptive datasets for DL-based techniques. Past work has shown the potential of combining multiple information sources for tasks related to machine understanding [66,53], and if properly applied to diverse collections of SE data, promising new progress could be made. DL4SE 5 : Future DL4SE work should look for opportunities to combine information from different software artifacts and modalities of information in order to build more descriptive datasets to support the development of tailored DL techniques applied to SE tasks.
While the diverse array of open source data provides a promising vehicle by which DL4SE research can be driven, there is a limit to the types of data which can be collected from them. For instance, it would be difficult to mine fine-grained developer interactions from modern open source software repositories. With this in mind, there is great potential for mining information from new software related sources. One particularly promising information source may be oftenused developer tools, and in particular the IDE. Collecting fine-grained information from IDEs is not an strictly new direction of research [74], however its application in synthesizing datasets for DL-based tools represents a promising avenue of work. For instance, one could envision a proactive IDE assistant that is able to predict context switches between common development tasks and provide developers with optimized suggestions based upon a chain of past fine-grained interactions. DL4SE 6 : Fine-grained instrumentation of often used development tools, such as IDEs, could provide a new, richly detailed source of data to drive DL4SE research. Therefore, future work should examine proper methods of instrumentation to capture relevant data in a privacysensitive manner, and look to utilize this data to drive new innovations for DL-assisted developer tools.

Software Artifact Specific DL Models & Architectures
As stated above, software artifacts, and in particular code, carry with them inherent structural properties that tend to make them unique compared to other forms of unstructured data. However, until very recently, much of the work in applying DL to these structured artifacts has been conducted by applying models primarily targeted at data types that are inherently less structured (e.g., sequence-based language models for natural language). Thus, there is a clear opportunity for future work to design new types of DL architectures that represent or encode software-related artifacts in such a manner that take advantage of their inherent structure or properties. Recent applications of graph-and tree-based neural networks applied to source code represent an early step in this direction. Additionally, the properties of many existing DL architectures may not properly align with target SE tasks. For example, many current models for machine translation are specifically engineered to be "meaning preserving" between translated phrases. However, this property could prove troublesome for certain SE tasks, such as defect repair, given that the translated phrases must by definition have different meanings. Due to such properties of existing DL architectures, future work should also look into their viability for SE data and the potential advancements made by SE-specific architectures. DL4SE 7 : Given the unique context and structure of the many different types of software artifacts, future work should focus upon understanding the implications of applying DL architectures from other domains on SE data and designing architectures that are capable of representing SE-related artifacts in a manner that leverages their unique properties for more effective learning.
As with any type of dataset, in datasets involving SE-related data there will be a distribution of different labeled examples that will impact what is learned by the corresponding models. For example, if one were to task a DL-based system to learn to fix bugs based on a dataset mined from GitHub, it would be expected that such a DL-based system would learn to identify and fix common bugs in a relatively effective manner, whereas lesser seen bugs may give the system more trouble. In the context of automating different software engineering tasks, this phenomenon of the long tail of potentially rare examples should be considered in relation to its practical implications for the approach being developed. For instance, an automated bug fixing approach that is able to pinpoint problems that are easily identifiable by developers may be less valuable than one that is able to to uncover and fix bugs that are harder to spot, or that are of a higher severity level. DL4SE 8 : Researchers should consider the effect of the "long-tail" of the predictive power of DL models when applied to data mined at scale with unknown distributions. Furthermore, future work should examine techniques for mitigating or understanding these effects when DL techniques are applied to SE tasks.
While there is clear potential benefit to customizing DL-based models to better fit SE-related data, there is also an open question of how such models should be evaluated. Traditionally, work on DL4SE has used or adapted effectiveness metrics from the machine learning (ML) and natural language processing (NLP) research communities. However, it is not clear the extent to which this is appropriate for SE-related data and tasks. For example, adapting the relatively popular BLEU [71] metric to source code may not be the best method for measuring the quality of generated code due to its "naturalness" (i.e., repetitiveness) relative to other types of textual data. From this point of view, there is clear need for developing effectiveness metrics specifically for software-related data. For instance, this could be done by comparing a variety of existing and newly proposed metrics to human evaluators in order to determine the metric that best reflects effectiveness of a given task as perceived by a developer.
There is a need for research into designing proper effectiveness metrics for DL techniques that are specifically applied to learning patterns from software-related data, as current metrics from the ML and NLP communities may not be a good fit.

Background
Formal verification and validation approaches have become a key building block for scalable and accurate analysis of software systems, but this did not happen over night. For example, the first applications of symbolic execution to the validation of software appeared in the mid 1970s, e.g., [50,27], but it took three decades for the underlying technologies, e.g., [31,11], to mature to the point where researchers could push symbolic execution further to apply it to realistic software systems or their components, e.g., [49,78,18]. Today, these technologies are applied as a regular component of development workflows to validate software and help verify the absence of faults and security vulnerabilities [20]. We believe that developing cost-effective techniques for verifying and validating realistic deep learning system models will require a sustained long-range program of research, and we outline key elements of such a research program below.

Property Specification
Verification and validation requires an explicit property specification -a precise formal statement of the expected system behavior. Specifying a property of a feed-forward DL model, N : R n → R m , involves the definition, φ ⊆ R n × R m , of the allowable inputs and their associated outputs. Since the process of specification is costly it is commonplace for verification and validation to exploit partial specifications, which define necessary conditions for a system to be correct.
Common sources of such specifications include the semantics of the programming language, e.g., freedom from null pointer dereference or out of bounds array indexing, or the programming environment, e.g., reading is only permitted on a file that was previously opened, in which the system is implemented. Such implicit property specifications are particularly valuable because they are system-independent, for example, any system that dereferences a null pointer is faulty. This allows for such property specifications to be formulated a single time and applied to verifying and validating any system, e.g., [30,8].
DL models can suffer from faults related to violation of implicit specifications in their implementations. For example, the TensorFlow implementation of a model might compute a NaN value when running inference on a particular input. Unlike existing work on implicit specification, in this case such a violation may implicate either the model or its implementation. A key advance in validation and verification of DL models will be to develop the analog of the ubiquitous "freedom from null pointer dereference" property for traditional software for DL models.
Research on defining implicit model-level property specifications for DL systems is needed to drive advances in and broad application of DL verification and validation approaches.
There is a rich literature on languages for stating explicit property specifications, e.g., assertions [75], contracts [63,52]. Such specifications are system-dependent and, consequently, they must be written by system developers prior to verification and validation.
It is challenging to write specifications for traditional software, but the nature of DL models introduces significant new challenges. First and foremost, DL models are used when specifying the target function that the model aims to accurately approximate is effectively impossible. For example, specifying a Boolean classifier for detecting the presence of a pedestrian in an image must account for the distance, orientation, occlusion, and natural variation of the shape and pose of a human -not to mention myriad other factors. Such models are thought to be inherently unspecifiable which is surely true if one seeks a complete specification of a DL model. Yet researchers have made some progress by focusing on partial specifications, for example, defining the maximum allowable steering angle for a regression network [14].
VV 2 : Research on defining explicit property specifications for DL systems should focus on partial specification of necessary conditions for correctness.
Despite the above challenges there has been progress in specifying properties of DL models. Researchers have observed for some time that the continuity of a function means that metamorphic relations, which state that small changes in the input result in small changes in the output, should hold over its input domain [57,67]. The ML community has formulated a variety of such properties which are oriented towards determining a model's robustness to adversarial examples [86,39,70]. Such specifications are sensible for regression models or when interpreting the values in the output layer of a categorical network. However, when applied to the entire input domain robustness properties do not make sense for categorical models. Such a property, e.g., ∀i ∈ R n : ∀r ∈ [− , ] n : N(i) = N(i + r), implies by transitivity that the model can produce a single output value -since the entire input domain can be spanned by overlapping regions of diameter 2 * . This precludes classifiers that define a decision boundary and, consequently, the robustness is typically verified or validated on a very small sample of inputs relative to R n . VV 3 : Research on understanding the value of metamorphic properties for categorical networks that go beyond sampling would be valuable.
To address the challenge of writing property specifications, Ernst and colleagues developed the concept of property specification inference by observing system behavior and generalizing it to a form that can be expressed as an assertion or contract. Research from the ML community on rule extraction, e.g., [80,13] to promote interpretability of models and explainability of their inferences shares a similar aim -explicating the complex inner workings of the system in a set of simpler partial specifications. A first step towards property inference for DL models [40] has been made, however, this direction of work is still in its early stages. VV 4 : Research on inferring concise specifications from model behavior that capture properties of models is a promising direction for overcoming the challenge of specifying their behavior ahead of time.

Adapting Validation to Deep Models
In the past two decades, a key advance in validating software systems has been the development of techniques for forcing the execution or simulation of system behavior. Whether these techniques operate systematically, e.g., symbolic [17] or concolic [78] execution, use randomized approaches, e.g., fuzzing [36], their power lies in being fully automatic. Algorithms and machines force the system through millions, or billions, of behaviors without developer intervention. In addition to reducing developer effort, this also eliminates bias that might cause a developer to miss exercising a particular behavior and lead to latent system faults. Their ability to generate large numbers of behavior means, however, that is infeasible for developers to determine whether the system output is correct -there are simply too many behaviors to consider. Consequently, these techniques rely on the availability of property specifications that can be encoded into monitors that evaluate internal system states or externally visible system behavior relative to properties.
Researchers have begun the process of adapting these methods to DL models, e.g., [84,103,69,104,41], but they would be much more effective with a broad array of meaningful property specifications. As a corollary to the research directions listed above VV 5 : Research on automated test generation for deep models must evolve with and adapt to developments in property specification in order to maximize their impact in validating DL system behavior

Scaling Verification to Realistic Models
It has taken nearly four decades to develop the foundations, algorithms, and efficient implementations for verification and validation of realistic software systems [20]. The importance of DL models has led researchers to seek to adapt such approaches in recent years leading to more than 20 different published verification techniques, e.g., [47,35,102,38,76,82,90,12,34,101,73,96,97,99,45,15,33,16], spanning three major algorithmic categories [56]. The pace of innovation in DNN verification is promising, but to date these techniques cannot scale to realistic DL models -they either exceed reasonable time bounds or produce inconclusive results. Consequently, in applying the techniques developers restrict property specifications to very small fragments of the input domain to gain a measure of tractability [96,82,34], restrict input dimension to facilitate verification [96,76], and only consider networks with a modest number of layers and neurons that do not reflect the rapidly increasing DNN complexity [47,16,48].
Scaling verification and validation for traditional software was achieved in large part through the application of frameworks for abstracting system behavior and performing compositional reasoning that divides the system into parts, reasons about them, and combines their results to reflect system behavior.
Several DNN verification approaches have explored the use of abstraction, e.g., [83,96], to soundly over-approximate model behavior and thereby permit efficient verification. As with traditional software, the key to abstraction is to control the over-approximation so as to preserve the ability to prove properties -coarse over-approximation leads to inconclusive unknown results in verification. One framework for achieving this in traditional systems is counter-example guided abstraction refinement [25] which systematically and incrementally customizes the abstraction based upon both the property and the structure of the system being verified.
VV 6 : Research into abstraction refinement approaches for the verification and validation of DL models is needed to scale to realistic models while preserving the accuracy of verification results.
Reasoning about large software systems requires the ability to divide and conquer. In data flow analysis, this is achieved through sophisticated frameworks for inter-procedural analysis that summarize the behavior of individual functions and then incorporate them into system level reasoning with just the right measure of context to allow for accurate results [68]. The research community has realized that "whole program" verification and validation of software is impractical and there is no reason to believe that "whole DL model" verification and validation will fare any better. However, DL models are built out of components -a graph of layers of varying type. While the nature of these components and their interface to one another varies in significant ways from traditional systems, the component-based nature of DL models may be ripe for exploitation. VV 7 : Research into compositional verification and validation of DL models is needed to scale to realistic DL models.

Benchmarks and Evaluation
Advances in verification and validation techniques for traditional systems have resulted from an ongoing interplay between theoretical and empirical work. An analysis of progress in SAT solving over a period of 6 years convincingly demonstrates how regular empirical evaluation of the state-of-the-art drives the consolidation of the best ideas [9]. Benchmarks are a necessary ingredient in enabling such evaluation and other verification communities, e.g., for SMT [10] and theorem proving [85], have long recognized this and invested in their development.
Most papers published on DL model verification and validation use only a small set of verification problems -a pair of a model and a property specification. For example, the ACAS network from the landmark paper by Katz et al. [47] is still used, e.g, [48,40], despite the fact that it has orders of magnitude fewer neurons than realistic models, e.g., [60,14] -not to mention that it only includes fully connected layers. The existence of benchmarks is not enough. The research community must agree to use them. Appropriate incentives must be put in place to encourage this, for example, requiring that any work accepted for publication perform direct comparison with alternate approaches on benchmarks. In other verification fields establishing yearly competitions has been successful in building such community expectations and in highlighting the state-of-the-art [3, 4, 1, 2]. VV 9 : Researchers should consider establishing regular competitions for DL model verification and validation techniques.

Design for Verification
It is well-understood that verification and validation approaches are undecidable in general, but researchers have pursued them for traditional software because they need only be cost-effective for the software that people write. Taking this line of reasoning further, researchers in highconfidence systems have placed restrictions on the structure of software systems that lend the results amenable to automated verification and validation [23,44,29]. To date DL research has focused primarily on improving the test accuracy of models and, to a lesser extent, their robustness to adversarial examples. As DL model verification and validation matures and an understanding of what types of model structures simplify and complicate verification there is an opportunity to bias model architecture to facilitate verification. VV 10 : Research exploring how model architecture facilitates or complicates verification and validation could pave the way for developers to design models for verification.

Beyond Feed-forward Models
The research on DL model verification and validation described above has focused on feedforward models, but there are other DL paradigms, such as DRL and RNN, that have received some attention, but deserve much more. For example, recent work has applied the concept of policy extraction to DRL models to extract an alternative model, e.g., a program fragment [93], a decision tree [13], that is amenable to verification using existing techniques.
The sequential nature of these paradigms presents challenges for verification and validation, but these are not unfamiliar challenges. Distributed and concurrent programs exhibit the same characteristics and research on their verification and validation gave rise to temporal logics for specification [62] and model checking [26] for verification. VV 11 : Research exploring how to adapt existing specification and verification frameworks for reactive systems to sequential DL models will be needed to broaden the class of DL systems that are amenable to verification and validation.

Background
Testing DL applications using traditional SE infrastructure is hard. They often lack end-to-end formal specifications [87,79,32]. Manually creating a complete specification for complex systems like autonomous vehicles is hard, if not impossible, as it means mimicking all possible real-world scenarios. Researchers from Google Brain observed that while developing DL applications, a developer "had in mind a certain (perhaps informally specified) objective or task"; an accident occurs when the application "that was designed for that task produced harmful and unexpected results" [7]. At a conceptual level, these accidents are analogous to semantic bugs in traditional software. Similar to the bug detection and patching cycle in traditional software development, the erroneous behaviors of DNNs, once detected, can be fixed by either adding the error-inducing inputs to the training data set and/or changing the model structure/parameters. However, a DL is very different from Traditional Software: while human developers manually write the core logic in the former and the logic is encoded in control and data flow, DLs learn their logic from a large amount of training data with minimal human guidance and the logic is encoded in terms of nonlinear activation functions and weights of edges between different neurons. These differences are particularly significant for software testing because testing essentially checks the program logic, which is encoded very differently in these two form of software. For example, code coverage guided testing techniques [46] that rely on control and data-flow logic will likely not work to test DNN logic [72]. Symbolic execution-based testing will also likely be difficult to adapt as it uses SMT solvers that known to have troubles with non-linearity [19].
To this end, DL system-testing consists of addressing the following four challenges: (1) what components/properties of a DL system should be tested?; (2) how should inputs be generated to test them?; (3) how should progress be measured (akin to measuring testing effectiveness for "traditional software")?; and (4) how should debugging proceed when testing techniques uncover problems?

Determining What to Test
The goal of DL system testing is similar to that of exposing defects in traditional software systems. Therefore, the key question that must be answered is: what constitutes a DL system defect.
Such defects could be present in infrastructure (e.g., TensorFlow), DL application code, data distribution, model structure, weight values, and hyper-parameters. They may have various symptoms, including those similar to software 1.0 bugs such as exceptions/crashes, and others unique to the DL semantics, such as low model accuracy, difficulty in convergence, robustness issues, and malicious back-doors. For some of these defects, the oracles (intended properties) can be explicitly defined, whereas for others, defining oracle is a prominent challenge.
T 1 : Future work should focus on achieving a better understanding of the faults that might occur in DL-based systems through empirical work.
Many DL defects are rooted in low model accuracy. For example, many believe that inaccurate models tend to have robustness issues. Hence, a general test oracle may focus on model accuracy. The challenge is to factor in the discrepancy among data distributions during training, testing, and deployment. Metamorphic testing provides a potential solution by asserting model behaviors upon variations. It is also possible to use the software 1.0 version of the application or an interpretable approximation (e.g., decision tree) as the oracle to test a DL model. Specifically, many DL applications have their antecedents in traditional software, which is based on deterministic algorithms or rules. These algorithms and rules provide an approximation of the intended state space, allowing us to test DL models that are largely uninterpretable. When a DL model is potentially malicious, the properties to test may need to change. Low-level hygiene properties analogous to buffer bound checks in traditional software may need to be tested and validated.
T 2 : Researchers should focus on trying to draw analogies between testing practices that have been successfully applied to traditional software systems, and those adapting those to fit the needs of DL-based systems.

Deciding how to Test DL-based Systems
Analogous to testing in traditional software, white-box, black-box, and grey-box testing techniques can be developed to test DL systems. White-box testing is driven by some coverage criteria. A number of such criteria have been proposed in the literature, such as neuron coverage [89], and have demonstrated potential in generating diverse inputs. In traditional software, various coverage criteria have different trade-offs in their cost and capabilities in disclosing software defects. For example, definition-use criterion that aim to cover all the dataflow relations in the subject software is much more expensive than statement coverage but much more effective in exposing bugs. Similar trade-offs exist in DL system white-box testing and hence studying their correlations with capabilities of disclosing model defects is of importance. Existing DL model coverage criteria mainly focus on specific model structures (e.g., CNN) and input modality. They can be extended to other structures such as RNN and other modalities.
There is a need for the development of proper test adequacy criteria for DL-based systems, akin to code coverage, that align with relevant abstractions of DL-based systems.
In traditional software, black-box testing is an important methodology in practice. It does not require access to software implementation or low level design documents. Instead, it directly derives test cases from functional specifications. Existing black-box DL system testing focuses on partitioning a pre-existing data set to training, validation, and test data sets and performs crossvalidation. Data augmentation and GAN can be used to generate additional data. However, it is unclear if such data generation can be driven by model functional specifications. T 4 : Research on evolving practices for Black-box testing of DL systems needs to evolve to provide additional details to developers regarding model performance.
Recently, we have witnessed substantial progress in grey-box testing for traditional software systems. Numerous fuzzing techniques and search-based test generation techniques have advanced the state-of-the-art of traditional bug finding. It is likely that similar techniques can be developed to test DL systems. Model continuity and the presence of gradient information provide unique opportunities for such techniques. It is also foreseeable that many effective software 1.0 testing techniques such as mutation testing, unit testing, and regression testing will have their counter-parts in DL system testing. However, in software 1.0, mutating a program statement and testing a function/unit has clear semantics, the un-interpretability of DL models makes it difficult to associate clear meanings to mutating model weight values, model structures, and testing phases (in the pipeline) and layers in models. There are many reasons to believe that differential testing provides unique benefits as it provides cross-referencing oracles, and leverages counter-factual causality to mitigate the inherent un-interpretability problem in DL systems. Most existing testing techniques focus on testing either DL models or non-model components (in traditional programming languages), co-testing them together as a cohesive system may pose unique challenges.
T 4 : There are many promising avenues of potential work on Grey-box testing of DL-systems, particularly related to techniques that take advantage of model continuity and gradient information to drive automated fuzzers or search-based techniques. Researchers should also look to find design counterparts to different types of traditional software testing (e.g. unit tests, regression tests) for DL-based systems.

Determining How to Measure scientific progress on Testing DL-based Systems
Measuring progress is critical as testing is an iterative procedure that cannot expose all the bugs in the test subject. Hence, we need to know that sufficient progress has been made so that the procedure can be terminated. In software 1.0, error detection rate and coverage improvement are used to measure progress. We need to establish the counter-part in DL system testing. Measuring the improvement of model accuracy over time may not be sufficient as the training may fall into some local optima. Measuring model coverage (e.g., neuron coverage) is a plausible solution, although the correspondence between coverage and various model quality objectives needs to be established. Continuous testing after DL system is deployed is valuable as currently rigorous model testing and retraining (after deployment) only happen when things go very wrong.
T 5 : Research into the design of test effectiveness metrics is important to measure the progress being made in testing research for DL-based systems.

Determining How to Debug DL-based Systems
Once defects are disclosed, the subsequent challenge is how to fix these defects. The current practice in DL model engineering relies on trial and error, meaning that the data engineers make changes to various parts such as training data set, model structure and training parameters, which they believe will lead to defect mitigation based on their experience. It lacks a critical step of identifying the root causes of defects and using that as guidance to fix the problems. Effective diagnosis tools to help point to specific (defective) artifacts in the engineering pipeline and suggest possible fixes are hence of importance. Differential analysis that has been highly effective in diagnosing software 1.0 bugs could be valuable in model and infrastructure defect diagnosis. For example, eliminating features or model components and testing how the system performs could be one form of debugging/testing. In addition, while fixing software 1.0 defects largely lies in changing certain program statements, there is hardly a counter-part in fixing model defects. For example, directly changing some weight values have uninterpretable consequences on the model behaviors.
T 6 : Differential analysis may play a key role in aiding in debugging practices for DL-based systems, and near term research could benefit from building on such techniques.

Background
As DL continues to pervade modern software systems, developers and data scientist are beginning to grapple with development and deployment challenges that are markedly different from traditional processes. While the development process for traditional software systems has gone through many iterations (e.g., waterfall → agile), the steps in these process are generally fairly well-defined. However, for DL-based systems, the process is much more "experimental" in many regards. That is, developers must formulate hypotheses regarding their problem and dataset, create models, and "test" these models against their hypothesis to determine if they are capturing trends in the data effectively and making relevant predictions. Given the relatively experimental nature of the DL development process, there are many open questions regarding effective bestpractices, tooling, and sociotechnical processes that represent promising areas for future work.

Requirements Engineering for DL Systems
Requirements engineering is a critical part of any software development process, as specifying what should be built can often be more difficult than the process of actually instantiating the ideas into code. However, the experimental nature of DL-based systems can make requirements more difficult to pin down. When used in industry, engineers often don't have formal requirements for a DL system [6]. This is due to the fact that, if a team is turning to a DL-based solution for a specific problem, this means that the problem domain is likely too complex to specify analytically. Therefore, teams often have a general goal in mind, and a specific success criteria for that goal. For most DL-based systems this goal is often exceeding a particular threshold for a given effectiveness metric drawn from ML literature, and when this threshold is met, further "optimal" performance is rarely sought after the fact. However, there are two main aspects of requirements engineering for DL systems that are potentially important and serve as areas of future work: (i) delineating and understanding the boundaries of performance of a given model, and (ii) nonfunctional requirements such as model size and inference time. In order to understand whether the predictive performance a given DL-model satisfies the requirements of a given problem, the limits and boundaries of these models must be explored and understood. DD 1 : Research on developing techniques to properly specify the behavioral boundaries and limitations of DL-models will be an important aspect of requirements engineering to ensure proper effectiveness for a given problem domain.
In addition, given the problem domain, there be important non-functional requirements related to aspects such as model size, inference time, privacy and bias considerations, or memory size. Developers will require support in ensuring such requirements are met in practice. DD 2 : Developers will need automated support for building DL-based systems that meet a variety of non-functional requirements including technical considerations such as model size, and non-technical considerations such as issues with privacy or bias.
In addition to requirements engineering, the notion of software traceability is also in its nascent stages for DL-based systems. In traditional software systems, the artifacts typically involved in the traceability process are usually well-defined, and often carry with them an inherent structure. However, this is not necessarily the case for DL-based systems. For instance, one could envision traceability tools that trace from data examples to different abstract data representations within a given model. The data-driven nature of DL also poses new challenges and opportunities for work on traceability. For example, given that understanding and cleaning data is such a large part of the DL development pipelines, traceability approaches could be reworked to offer links between various clusters of a given dataset and testing examples.
There is a need for traceability to be fundamentally rethought for DL-based systems. Researchers should focus on determining what types of trace links are necessary for DL-based systems and work toward automated approaches that can automatically infer and reason about such links.

Sociotechnical Aspects of DL System Development
At its core, any type of software development is a process that is carried out by humans, and more often than not, groups of humans working together toward a common goal. Given this fact, the socio-technical processes of development are critical to successful creation and instantiation of software. With the rise of agile methodologies, and collaborative tools (e.g., issue trackers, software specific task managers) robust methods for cooperative development of traditional software systems have been developed. However, the experimental nature of DL-based systems and their differing iterative processes make it difficult to cleanly transfer many of the existing development processes and tools. DD 4 : Researchers and practitioners should work together to study and understand effective processes and tools for the development of DL systems. This will provide guidance for future work on more intelligent tools that improves or accelerates these processes.
In work that has examined the DL-like development processes carried out by data scientists [6], it is clear that the most time-and effort-consuming portion of the development process is data curation and management. As the popularity of DL-systems have continued to improve, libraries and APIs for creating models have become much easier to use. However, these underlying models only function well if trained on properly curated datasets. Therefore, much of the engineering effort for such systems is focused on data. This is a fundamental shift from more traditional software development workflows, wherein the focus is largely on code. Instead, developers and data scientists must focus on understanding data, and making sure that the data accurately reflects the problem that they are trying to solve, to extent that is possible. This means that various types of exploratory data analysis should be given the same levels of consideration as program analysis techniques have been given for code, if we are properly support these practitioners in their datacentric endeavors.
DD 5 : Given the centrality of data in the development of DL-based systems, and the effort typically spent on data-related tasks, future research should focus on providing tools and techniques for data analysis that allow developers to better understand their datasets, and how the nature of their data will affect their DL-models, and vice-versa. Once a DL system has been created, developers must then test their system to ensure that it is working as intended. While we discuss the various future directions of work for testing-DL based systems, there is one highly related process that is deeply intertwined with testing: debugging. Once developers are able to test their systems, they must then attempt to remedy any detected misbehavior. In traditional software development, this typically means inspecting various aspects of the code, stepping through its execution, and determining failure cases. However, given the data-centric nature of DL systems, "debugging" the data will be nearly as important as debugging model, and it is likely that the two tasks will be highly intertwined with one another. Thus, there are clear research opportunities for developing both processes and tools that aid developers in debugging DL-systems across both models and code. DD 6 : There is a clear need for research into understanding and aiding in the debugging of DL-based systems. Such work will need to account for the data-driven nature of the systems and develop tools and techniques for debugging both models and data, and make considerations for collaborative debugging.

Deployment and Monitoring of DL-based systems
Deployment and monitoring practices for traditional software systems have evolved markedly in recently years with advancements related both to processes and infrastructure supporting continuous integration (CI) and deployment (CD). However, it may difficult for such processes to be readily adapted for use in DL-based systems given the size of typical datasets and computational complexity of training DL models. For example, one could envision a CI system that retrains a series of models given updates to a tracked dataset. However, developer would likely need additional monitoring for training processes, and perhaps training processes would differ dynamically based iterative results during the process. Such support could prove difficult for current popular CI systems. Monitoring also poses unique challenges. While there could still exist field failures (akin to crashes) that signal issues with software, it is likely that unwarranted behavior will be more dependent upon end-users reporting anomalous behavior. Additionally, monitoring for performance-related metrics and making recommendations to assuage any potential issues is also likely to be important. These all challenges represent rich areas of research moving forward. DD 7 : Research should focus on how to adapt current practices for CI/CD to the context of DL-based systems, and develop effective monitoring solutions to capture field failures.

Educational Aspects of the Development and Deployment of DL Systems
It is clear that there are many changes from the traditional software development process reflected in the comparable processes for DL-based systems. As research on these systems continues to evolve, and our understanding advances, the educational materials for students seeking careers in software development or data science must advance alongside it. DD 8 : As advancements in our understanding of effective development processes and techniques manifest, these must be reflected in freely available educational materials that prepare students accordingly. An academia-industry partnership for such materials would be beneficial to provide practical grounding for course materials.

Background
Software maintenance is a key phase of the software development life-cycle wherein a system is modified to correct faults, add features, or to improve various other functional or non-functional properties. It has been estimated that nearly half of all software engineering activities are dedicated to one of the various types of maintenance activities [55]. As such, there has been a tremendous amount of research effort involved in analyzing and improving maintenance-related software engineering tasks. Such work has ranged from automated analysis of issue and bug reports [64,21,22,65], to full-fledged automated repair of faults in software systems [51,98,24]. However, until recently, much of this work has been focused primarily upon traditional software systems written in an analytic nature. As noted at the beginning of this report, as software is applied to tackle increasingly complex tasks, there has been a shift from analytical development to learning-based development, where machine learning algorithms are applied to large datasets to "learn" a program for a given computational task. The popularity of multi-layered Neural Networks and accompanying optimization algorithms (so-called Deep Learning architectures) have been a major driver of this phenomenon. However, such learning-based systems are inherently different from, and often intertwined with, more traditional software systems. Given the relative recency of DL-based software systems, there are many open questions regarding proper maintenance practices. We believe that developing and ensuring proper maintenance practices for DL-based systems is imperative, and we outline the key elements of a proposed research agenda below.

Measuring and Understanding the Evolution of Deep Learning Systems
The maintenance of a software system is tightly coupled to its evolution, i.e., the types and magnitude of maintenance performed and software artifacts present in a system often dictate how that system evolves over time. Different from more traditional software systems, DL systems have additional artifacts that must be accounted for during software evolution. For instance, such systems will typically consist of (i) model code that implements a given DL architecture, (ii) configuration files that specify different model hyper-parameters, (iii) trained models, (iv) datasets split for various use cases (e.g., training/validation/test sets), and (v) performance or effectiveness metrics for different trained models. The process for constructing DL systems also fundamentally differs from more traditional software systems. DL-based systems are inherently more "experimental" in nature, wherein developers will construct, train, test, and tweak several different models and DL architecture configurations. Given the opacity of DL models, and the sometimes surprising nature of model results, engineers often implement a more exploratory process compared to more traditional software systems where the behaviors of analytical code are easier to predict. Given the differences in software artifacts and development pipelines between DL-based systems and traditional software systems, we would expect there to be distinct differences in their evolution and maintenance as well.
However, currently the software engineering research community is still grappling with the differences in process and evolutionary aspects of DL-based systems. We do not know how to precisely track changes nor do we understand how they are typically manifested.
As indicated earlier, ML/DL-based systems are heavily data-centric from the viewpoint of developers [6]. That is, data is a crucial, and often unwieldy, component that enables DL architectures to learn "programs" for complex applications. However, the current state of data management for DL systems is a pain point for many developers, and thus should be a focus area for the research community. However, data is not the only artifact that must evolve over the lifespan of a DL-based software system. There are several interconnected artifacts such as trained models, model test results, hyper-parameter configurations, and model code that must all co-evolve in an efficient manner. The intermingling of these artifacts often results in a large amount of glue-code coupling these artifacts together. Designing both processes and techniques/tools to help measure such co-evolution should be a focus of researchers moving forward to start taming this challenge. M 1 : Researchers should focus on designing techniques for efficient tracking and evolution of the rich and often tightly coupled software artifacts that are associated with DL-based systems.
A recent survey conducted at Microsoft has provided some insight into the processes by which ML/DL components are created and integrated into existing software systems [6]. This work has found three main aspects of ML/DL-based software systems that fundamentally differ from other domains including: (i) discovering, managing, and versioning data, (ii) model customization and reuse, and (iii) the integration of AI components into more traditional software systems. However, while this study begins to scratch the surface of evolutionary aspects of DL systems, there are still many open questions that remain, for instance: What does change look like in a DL-based system?, How do models and datasets co-evolve?, How important is it to maintain a version history for datasets?, How does model code co-evolve with trained models and testing?, Do different types of regressions befall DLbased systems?. To answer such questions it is clear that additional empirical studies are needed to help guide eventual research towards supporting developers with some of the more challenging aspects of such evolution.
M 2 : Research empirically analyzing the evolutionary properties of DL-based systems will provide much needed direction towards understanding and eventually supporting developer needs throughout the software maintenance process.

Grappling with Technical Debt and Maintenance in Deep Learning Systems
Due to the rapid pace of development typically associated with modern software systems, engineers are often seen as facing a tenuous dichotomy: move quickly and ship new features and completed projects or slow down to ensure the quality of engineering and the sound design and implementation of a system. This trade off between sound engineering practices and velocity of progress is often referred to as a concept called technical debt. Technical debt shares several aspects in common with fiscal debt. For example, if poor engineering decisions are made for the sake of development speed and are not corrected in a timely manner, this could result in increasing maintenance costs. Technical debt is an increasingly researched topic within the broader field of software engineering [92]. However, currently there is only an early understanding regarding the types of technical debt incurred specifically by DL-based systems. Recent work from engineers and researchers at Google has shed light on the various forms of debt that more general ML systems can incur [77]. Some of the types of debt explored by this work include (i) the erosion of boundaries between software ML software components, (ii) System-level spaghetti, and (iii) changes in the external world (and representing data). While these types of debt generally apply to DL-based systems, this paper was a wider look at ML-based as a whole. We are also witnessing the emergence of techniques such as refactoring, inspired by those in traditional software, but adapted to work on DL-based systems to address different types of technical debt [81]. There are likely to be even more forms of technical debt that could be incurred by DL-based systems, for instance: What is the impact of a change to the data or the model?, Are the changes to maintain accuracy diminishing robustness?, and What is the effect of using an existing off-the shelf architecture on explainability?. Thus, there needs to be better understanding of the specific types of technical debt that DL systems may incur. M 3 : Research into the trade-offs between development velocity and maintenance costs should be undertaken to empirically determine mechanisms to help developers manage such debt.

Abstractions to enable Analyses
DL-based systems have unique computational encodings that render existing traditional software abstractions largely obsolete. For instance, it is unclear how traditional control and data flow would map to DL architectures made up of several different computational layers that engineers may view as performing discrete functions. However, understanding these abstractions will be key towards enabling automated analysis of such systems in the future. Once a proper set of abstractions have been established, it is critical that work be conducted in order to aid in the automated analysis of DL-based programs. Decades of research on program analysis techniques of more traditional software systems have ushered in several advancements in automated developer tools and frameworks for software maintenance and validation. If we hope to achieve similar levels of advancement in the context of DL-based systems, researchers must work toward designing and building these next-generation analysis techniques. This could come in the form of instrumentation of dynamically running DL models, or via a combination of static analysis of model configuration and dynamic analysis.
Research into program analysis tools for DL-based systems is critical if the research community is to develop automated developer support for software maintenance tasks.

Educational Challenges for Teaching Deep Learning System Maintenance
As with any emerging domain of software development, education is a critical component to ensuring engineers are equipped to work with DL-based systems in as effective and efficient a manner as possible. However, from a researchers perspective, it can be difficult to glean bestpractices and in turn develop effective pedagogical mechanisms for conveying these to students. One potentially promising path forward for tackling the current gap in computer science education is for researchers/educators to collaborate with industry to learn current best practices and co-develop course materials and pedagogical techniques for conveying it. M 6 : Researchers and Industrial practitioners should work together to identify effective development/maintenance practices for DL-based systems and co-design educational and pedagogical materials for conveying these to students.

Background
The task of program synthesis, i.e., automatically generating programs from specifications, is considered a fundamental problem in Artificial Intelligence. In recent years, there has been tremendous research progress in the field across various communities including Software Engineering, Programming Languages, and Artificial Intelligence. The advances in deep learning techniques coupled with neuro-symbolic reasoning techniques offer exciting opportunities to enable new automated code generation paradigms and interfaces for programmer-synthesizer collaboration.

Application Domains
There are a number of different application domains that might be well suited for automated code generation both in near term and longer term research. Some near term opportunities may lie in the areas of: • Program Superoptimization -automatically generating programs that are functionally equivalent to a given implementation but allow for complete transformation of original programs using search unlike traditional compilers.
• Code completion -generating completions of small snippets of code given some code context.
• Repairing programs with small program patches -Instead of generating complete code snippets, synthesis techniques can be used to generate small program patches that satisfy the failing specification or tests.
• End-user programming -Helping millions of end-users who may not necessarily be programmers like spreadsheet users to accomplish programmatic tasks.
• Mobile app development -Helping programmers develop mobile applications using natural language and examples.
Another area of interest was for synthesizing programs in domain-specific languages such as SQL, yaml, and build files was identified as a promising opportunity. In these domains, programmers typically have knowledge about performing tasks in general purpose languages, but often have to look up the syntax and semantics of these domain-specific languages. There could be opportunities in considering natural language as intermediate representations for different computations and use that to transfer implementations in different domain-specific languages. One research challenge here would be on how to enable naturalness and readability of the automatically generated code for maintainability if developers use them as part of a larger workflow. DD 1 : There a number of application domains that represent promising paths forward in DL for code generation including (i) program superoptimization, (ii) code completion, (iii) program repair, (iv) end-user programming, and (v) mobile app development. However, major challenges remain in ensuring that generate code is both easily comprehendable and maintainable.
A key challenge in program synthesis is that of specification, particularly for complex tasks. Even for simple programs, writing a full specification can sometimes be as tedious as writing the complete program in first place. There are several alternate specification mechanisms such as natural language, input-output examples, unit tests, partial implementations, existing implementations, program properties, and user interfaces, where different mechanisms are suited for different synthesis domains. One big opportunity with advances in deep learning techniques is to enable a rich environment that can embed truly multi-modal specifications in various forms as listed above. One particular specification mechanism that may be promising was to start with an existing implementation of code found with some keyword based search and learn to edit it in ways to satisfy the specification. Another important challenge to keep in mind here is that the expertise of users might also influence the types of specification mechanisms that are useful in practice -e.g. inexperienced users might not be familiar with even good keywords. DD 2 : Combining multi-modal DL models that are capable of mixing and taking advantage of different types of program specifications represent a promising path forward for research on code generation. However, researchers should also keep in mind the context of where the approach will be applied and ensure generation mechanism matches the user expertise.
Instead of fully automating the code generation process, we can also consider building an assistive agent for helping developers and focus more on the collaborative and creative aspects of development. Human developers are great at certain aspects of code development workflow and code generators would be good at certain other complementary aspects such as remembering large contexts. Combining the two sets of varying expertise would be an exciting research challenge. Proactive code completion is one such example, where a code assistant can recognize whether certain functionality is incomplete and suggest useful idioms or completions. Writing code is seldom a one-shot process even for human developers -we usually iterate quite a few times before leading to a final implementation. One interesting challenge would be building a mixed-initiative dialog agent that switches between developer and code generator while asking questions to refine the intent and generating the desired implementation. DD 3 : Researchers should carefully consider the interplay between a code generator and enduser developers, and develop mixed-initiative agents that are capable of working in concert with developers, rather than trying to automate end-to-end development tasks outright.
There is also a strong need for benchmarking the progress of the capability of program synthesizers as well as possibly developing some grand challenge problems for the community. One particular grand challenge was to build an intelligent synthesizer that can win a programming contest. Some other suggestions for grand challenge problems included building a synthesizer to pass an introductory programming class, enabling students to automatically generate mobile apps, and automatically answering questions on help forums such as StackOverflow. Evaluating synthesizers that require human interaction is also a complex question, and coming up with metrics to quantify and benchmarking such interactions would also be an interesting direction. DD 4 : There is a need for the research community to develop comprehensive benchmarks or "grand challenges" for code generation to measure and spur progress (akin the imagenet challenge in computer vision research).
There are also many interesting research challenges in developing deep learning architectures that are specialized for embedding programs and specifications. Some recent models have shown that encoding structure and static analysis information about programs is useful for improving the generative process of programs. In addition, developing models that are capable of embedding dynamic and rich semantic information would be crucial for improving current program synthesis models. DD 5 : There is a need for DL models that are able to specifically take advantage of the inherent static structure and dynamic properties of source code.
In summary, the advances in DL techniques offer exciting opportunities for building systems that can understand multi-modal specifications in various forms such as natural language, inputoutput examples and partial programs. Combining DL techniques with symbolic approaches can significantly improve the capabilities of current synthesizers by combining intuition-based reasoning with symbolic logical reasoning. This is an exciting area of research with many open challenges and fundamental problems, and can also be a pillar for advancing DL techniques.

Overview
This report summarizes the findings in the NSF-sponsored "Workshop on Deep Learning & Software Engineering", held in Sand Diego, California on November 10th -12th, 2019. This was a community visioning workshop to identify academic and industrial research challenges and promising future directions for work that sit at the intersection of the disciplines of software engineering and deep learning. the workshop was organized by Denys Poshyvanyk, Baishakhi Ray, Kevin Moran, Prem Devanbu, Matthew Dwyer, Michael Lowry, Xiangyu Zhang, Rishabh Singh, and Sebastian Elbaum. In order to faciltate focused small discussion groups, both days of the workshop were closed to public, and the workshop organizers invited 30 researchers across academia and industry to attend. The workshop was structured into three days. During the first day a series of lightning talks encompassing a range of topics at the intersection of DL & SE were delivered by volunteers from the invited participants. The second day comprised the bulk of the workshop discussion and was organized into several Breakout Group Sessions with smaller groups discussing targeted topics, and Plenary Sessions where all participants convened to discuss the results of the Breakout Group discussions. The second day of the workshop was concluded with a Plenary Session that reflected on the most important aspects of the discussion throughout the day. On the third day of the workshop the organizing committee met to discuss the results of the workshop discussions and to begin drafting this report. We provide the workshop schedule below. This report was shared with all workshop participants before being released to wider community for open comments and discussion. The full workshop program is available at https://dlse-workshop.gitlab.io/schedule/.

Community Contributions to the Report
As indicated by the goals of the workshop, this workshop is meant to serve as a living document wherein community members contribute their views regarding promising research opportunities that sit at the intersection of Deep Learning & Software Engineering. we encourage participation in contributing to this report by filing a Merge Request with the Report paper repository which is hosted on GitLab: https://gitlab.com/dlse-workshop/dlse-workshop-community-report.

Overview & Purpose
The purpose of this section is collect comments and additional points from the broader academic and industrial community conducting research that sits at the intersection of Deep Learning & Software Engineering. Thus, each subsection listed below contains the comments from a different community member. If you would like to contribute, please visit the report GitLab repository (https://gitlab.com/dlse-workshop/dlse-workshop-community-report) and follow the contribution guidelines posted in the repository.