Very often, source code lacks comments that adequately describe its behavior. In such situations developers need to infer knowledge from the source code itself, or to search for source code descriptions in external artifacts. We argue that messages exchanged among contributors/developers, in the form of bug reports and emails, are a useful source of information to help understanding source code. However, such communications are unstructured and usually not explicitly meant to describe specific parts of the source code. Developers searching for code descriptions within communications
face the challenge of filtering large amount of data to extract what pieces of information are important to them. We propose an approach to automatically extract method descriptions from
communications in bug tracking systems and mailing lists. We have evaluated the approach on bug reports and mailing lists from two open source systems (Lucene and Eclipse). The
results indicate that mailing lists and bug reports contain relevant
descriptions of about 36% of the methods from Lucene and 7%
from Eclipse, and that the proposed approach is able to extract such descriptions with a precision up to 79% for Eclipse and 87% for Lucene. The extracted method descriptions can help
developers in understanding the code and could also be used as a starting point for source code re-documentation.
130614 sebastiano panichella - mining source code descriptions from develo...Ptidej Team
This document describes a 5-step approach for mining method descriptions from developer communications:
1. Download emails/bug reports and trace them to classes and methods using heuristics like mentioning class/file names.
2. Extract paragraphs of text from the communications.
3. Trace paragraphs to methods by checking for mentions of "method" and method names.
4. Apply heuristics to score paragraphs associated with methods based on how well they describe the method, like percentage of method parameters mentioned.
5. Rank paragraphs for each method by score to select best descriptions.
This document provides a summary of basic Java concepts including data types, operators, flow control statements, comments, and some key Java packages. It lists common Java operators like arithmetic, relational, logical, and bitwise operators. It also summarizes common statements for flow control including if/else, while, do-while, and for loops. Additionally, it shows how to declare variables, arrays, and classes in Java.
The document discusses defining programmer-defined classes in Java. It provides an example of defining a Bicycle class with data members and methods, and using it to track bicycle ownership. It then expands on this example by defining an Account class and using both classes in a sample program. The key aspects covered include defining classes, using visibility modifiers, passing objects to methods, and differentiating local variables from data members and parameters.
This chapter discusses exceptions and assertions in Java. The key points are:
1. Exceptions represent error conditions and allow for graceful handling of errors rather than program crashes. Exceptions can be caught using try-catch blocks.
2. Checked exceptions must be caught or declared in a method, while unchecked exceptions do not require handling.
3. Assertions allow checking for expected conditions and throwing errors if conditions are not met. Assertions are enabled during compilation and execution.
This document provides an overview of object-oriented programming concepts. It discusses the need for OOP, defining classes and objects, class hierarchies and inheritance, method binding and overriding, exceptions, and abstraction mechanisms. The key concepts covered are objects, classes, encapsulation, inheritance, polymorphism, and abstraction.
The document provides an overview of defining custom classes in Java, including how to return objects from methods, use the 'this' keyword, define overloaded methods and constructors, create class and static methods, implement parameter passing, organize classes into packages, and document classes with Javadoc comments. Key concepts like inheritance, polymorphism, and abstraction are not discussed. The chapter aims to describe the basics of defining custom classes in Java.
This document provides information about a lab manual for an Object Oriented Programming lab through Java at Guru Nanak Engineering College for the 2007-2008 academic year. It includes the lab objectives, guidelines for students, a list of lab exercises to be completed over 15 weeks, descriptions of OOP concepts, and solutions to sample programs. The document was prepared by D. Rama Rao and approved by G. Prabhakar Raju for use in the Department of Information Technology.
130614 sebastiano panichella - mining source code descriptions from develo...Ptidej Team
This document describes a 5-step approach for mining method descriptions from developer communications:
1. Download emails/bug reports and trace them to classes and methods using heuristics like mentioning class/file names.
2. Extract paragraphs of text from the communications.
3. Trace paragraphs to methods by checking for mentions of "method" and method names.
4. Apply heuristics to score paragraphs associated with methods based on how well they describe the method, like percentage of method parameters mentioned.
5. Rank paragraphs for each method by score to select best descriptions.
This document provides a summary of basic Java concepts including data types, operators, flow control statements, comments, and some key Java packages. It lists common Java operators like arithmetic, relational, logical, and bitwise operators. It also summarizes common statements for flow control including if/else, while, do-while, and for loops. Additionally, it shows how to declare variables, arrays, and classes in Java.
The document discusses defining programmer-defined classes in Java. It provides an example of defining a Bicycle class with data members and methods, and using it to track bicycle ownership. It then expands on this example by defining an Account class and using both classes in a sample program. The key aspects covered include defining classes, using visibility modifiers, passing objects to methods, and differentiating local variables from data members and parameters.
This chapter discusses exceptions and assertions in Java. The key points are:
1. Exceptions represent error conditions and allow for graceful handling of errors rather than program crashes. Exceptions can be caught using try-catch blocks.
2. Checked exceptions must be caught or declared in a method, while unchecked exceptions do not require handling.
3. Assertions allow checking for expected conditions and throwing errors if conditions are not met. Assertions are enabled during compilation and execution.
This document provides an overview of object-oriented programming concepts. It discusses the need for OOP, defining classes and objects, class hierarchies and inheritance, method binding and overriding, exceptions, and abstraction mechanisms. The key concepts covered are objects, classes, encapsulation, inheritance, polymorphism, and abstraction.
The document provides an overview of defining custom classes in Java, including how to return objects from methods, use the 'this' keyword, define overloaded methods and constructors, create class and static methods, implement parameter passing, organize classes into packages, and document classes with Javadoc comments. Key concepts like inheritance, polymorphism, and abstraction are not discussed. The chapter aims to describe the basics of defining custom classes in Java.
This document provides information about a lab manual for an Object Oriented Programming lab through Java at Guru Nanak Engineering College for the 2007-2008 academic year. It includes the lab objectives, guidelines for students, a list of lab exercises to be completed over 15 weeks, descriptions of OOP concepts, and solutions to sample programs. The document was prepared by D. Rama Rao and approved by G. Prabhakar Raju for use in the Department of Information Technology.
- The document is a lab manual for an introductory Java programming course that provides instructions on installing Java, using an IDE, and writing simple Java programs.
- It explains how to create a "Hello World" Java program using BlueJ or JCreator IDEs, compile and run the program, and addresses common errors students may encounter.
- The document provides an example "Hello World" Java program and explains the key components of a basic Java class including the class definition, main method, and use of System.out.println to display output.
C++ is an object-oriented programming language that is an incremented version of C with classes added. Some key differences between C and C++ are that C++ uses object-oriented programming with classes that can contain both data and functions, while C focuses more on procedures/functions and allows any function to access data. The document then discusses the basic concepts of object-oriented programming in C++ including classes, objects, polymorphism, inheritance, encapsulation, and data abstraction. It provides examples of classes, objects, reference variables, default arguments, and dynamic memory allocation in C++.
Multi-dimensional exploration of API usage - ICPC13 - 21-05-13Coen De Roover
Presented at the 21st IEEE International Conference on Program Comprehension (ICPC 2013), San Francisco (USA). Website of the paper: http://softlang.uni-koblenz.de/explore-API-usage/
This document contains 55 questions and answers related to core Java concepts. Some key topics covered include threads and concurrency (questions 3, 5, 39), exceptions (question 41), collections and generics (questions 13, 15, 19), and GUI components and layouts (questions 2, 9, 10). The questions cover a wide range of fundamental Java topics for interview purposes.
The document is a lab manual for Java programming that includes 12 experiments. The first experiment involves creating a Java package with Stack and Queue classes that demonstrate LIFO and FIFO principles respectively using methods like push(), pop() and enqueue(), dequeue(). The second experiment involves designing a ComplexNumber class with constructors to perform addition, subtraction and multiplication of complex numbers.
This document discusses input/output and exception handling in Java. It covers reading and writing text files, including using Scanner and PrintWriter classes. It provides examples of reading numbers from a file and writing them out with formatting. It also discusses different file formats like text, HTML, and XML files. Finally, it covers techniques for reading text files like reading words, characters, and lines of text.
The document discusses implementing classes in Java. It begins with an example class called Counter that models a tally counter. It then covers key concepts for implementing classes like instance variables, methods, constructors, and encapsulation. It provides examples of implementing a simple Counter class with methods like click(), getValue(), and reset(). It also discusses specifying the public interface of a class before implementation, using a hypothetical BankAccount class as an example.
The document provides the syllabus for a Java lab course. It outlines 11 programming assignments that students must complete, including developing classes for rational numbers, dates, Lisp-like lists, stacks, vehicles, currency conversion, and a scientific calculator. It provides sample code and algorithms for implementing a rational number class, date class, Lisp list operations, stack data structure using arrays and linked lists, vehicle class hierarchy demonstrating polymorphism, currency classes for serialization, and a basic calculator using event-driven GUI programming.
The document discusses object oriented programming and Java. It provides a history of Java, describing how it was created at Sun Microsystems in the 1990s to be a simpler alternative to C++ that was architecture neutral, portable, distributed and secure. It then summarizes Java's key features including being object oriented, robust, simple, secure, portable and interpreted. It also describes Java's basic data types and how variables are declared and initialized in Java.
The document provides details of programs to be implemented in C++ and Java as part of an Object Oriented Programming lab. The C++ programs include implementations of inline function overloading, complex numbers using operator overloading, friend functions, string concatenation using dynamic memory allocation, type conversion using complex numbers, managing bank accounts using inheritance, and a stack class with exception handling. The Java programs include writing simple programs, palindrome checking using strings, interfaces, inheritance, exception handling, and multithreaded programs.
This document provides a lab manual for the fourth semester computer science engineering course on Object Oriented Technology. It includes the syllabus, rationale for object oriented programming, hardware and software requirements, a list of practical experiments to be conducted, and sample code for some of the experiments. The experiments cover topics like function overloading, inheritance, polymorphism, constructors, destructors, copy constructors, friend functions, and use of local, static and global objects. Each experiment is followed by sample output and questions related to the concepts covered in the program. The document aims to provide guidance to students on the practical implementation of object oriented programming concepts using C++.
This document contains lecture notes on Java programming divided into 6 units. Unit 1 provides an overview of Java and covers data types, variables, arrays, operators, control statements and classes. It also discusses I/O operations like reading console input/output and files. Unit 2 covers string handling and the StringBuffer class. Unit 3 discusses packages, interfaces and exception handling. Unit 4 focuses on multithreading concepts. Unit 5 covers applets, event handling and the Abstract Window Toolkit. Unit 6 introduces Swing and JDBC. The document also includes examples of Java programs and lists lab experiments and reference books.
This document summarizes key points about inheritance in Java from a chapter in a textbook. It discusses how a subclass inherits characteristics from its parent class, including methods and data. It also covers abstract classes, polymorphism through method overriding in subclasses, and how polymorphic references allow different methods to be called depending on the actual object type.
Java interfaces were created to solve the "Deadly Diamond of Death" problem that can occur with multiple inheritance in some object-oriented languages. An interface in Java is an abstract class that defines methods but does not provide implementations. Classes can implement multiple interfaces, inheriting their abstract methods without inheriting implementation details. This allows classes to gain functionality from multiple sources while avoiding conflicts between inherited properties. Interfaces in Java establish an "has-a" relationship between classes rather than a "is-a" relationship like inheritance.
The document provides definitions and explanations of various C# concepts including polymorphism, abstract methods, virtual methods, objects, classes, static methods, inheritance, virtual keyword, abstract classes, sealed modifiers, interfaces, pure virtual functions, access modifiers, reference types, overloading, overriding, encapsulation, arrays, array lists, hash tables, queues, stacks, early binding, late binding, sorted lists, and delegates. Key points covered include the differences between abstract and virtual methods, what defines a class versus an object, when to use static versus non-static methods, inheritance implementation in C#, and the purpose of interfaces.
Constructors and destructors in Python.
Constructors are special methods that are called automatically when an object is created. They initialize variables and ensure objects are properly initialized. There are two types of constructors: default and parameterized. Default don't take arguments, parameterized do.
Destructors are called when an object is destroyed. Defined using __del__(), they are useful for releasing resources like closing files before a program exits.
The document then provides code examples of classes with constructors, parameterized constructors, and destructors. It also discusses Python's garbage collection and how the collector deletes unneeded objects to free memory space.
The document provides an overview of object oriented programming and network programming concepts. It discusses topics like IP addresses, ports, sockets, client-server programming, and the java.net and java.util packages. The java.net package contains classes for network programming in Java like Socket, ServerSocket, URL, and InetAddress. The java.util package contains general-purpose utility classes like ArrayList, HashMap, Properties and Date.
This document provides information on several summer promotion tour packages in Vietnam between May 1st and September 30th, 2013.
The first package is a 3 day, 2 night tour of Ho Chi Minh City for $121 per person. It includes accommodation, meals, transportation and sightseeing activities in and around Ho Chi Minh City.
The second package is a 4 day, 3 night tour of Ho Chi Minh City and the Mekong Delta for $214 per person. It includes accommodation, meals, transportation and sightseeing in both Ho Chi Minh City and the Mekong Delta region.
The third and most comprehensive package is a 7 day, 6 night "Best of Vietnam" tour for
The document provides details on the planning and process for creating a watercolor character design. It describes collecting reference images, compiling mood boards, and choosing specific images to inspire the character's clothing design. The planning focused on designing a long coat, shoulders, hood, and other clothing elements. Reference images from games like Assassin's Creed were used. Sketches and scans of the watercolor process were included to show how different shades and colors were applied layer by layer to create the final character design.
Este documento describe tres paradigmas fundamentales que surgieron a mediados del siglo XX: el positivismo, el materialismo histórico y el historicismo. El positivismo de Comte y Durkheim buscaba entender y interactuar con la realidad estudiando científicamente los hechos. El materialismo histórico de Marx analizaba la sociedad desde la lógica de las contradicciones de clase. El historicismo se ubicó en el campo historiográfico y estudió los hechos clave como producto de su época.
- The document is a lab manual for an introductory Java programming course that provides instructions on installing Java, using an IDE, and writing simple Java programs.
- It explains how to create a "Hello World" Java program using BlueJ or JCreator IDEs, compile and run the program, and addresses common errors students may encounter.
- The document provides an example "Hello World" Java program and explains the key components of a basic Java class including the class definition, main method, and use of System.out.println to display output.
C++ is an object-oriented programming language that is an incremented version of C with classes added. Some key differences between C and C++ are that C++ uses object-oriented programming with classes that can contain both data and functions, while C focuses more on procedures/functions and allows any function to access data. The document then discusses the basic concepts of object-oriented programming in C++ including classes, objects, polymorphism, inheritance, encapsulation, and data abstraction. It provides examples of classes, objects, reference variables, default arguments, and dynamic memory allocation in C++.
Multi-dimensional exploration of API usage - ICPC13 - 21-05-13Coen De Roover
Presented at the 21st IEEE International Conference on Program Comprehension (ICPC 2013), San Francisco (USA). Website of the paper: http://softlang.uni-koblenz.de/explore-API-usage/
This document contains 55 questions and answers related to core Java concepts. Some key topics covered include threads and concurrency (questions 3, 5, 39), exceptions (question 41), collections and generics (questions 13, 15, 19), and GUI components and layouts (questions 2, 9, 10). The questions cover a wide range of fundamental Java topics for interview purposes.
The document is a lab manual for Java programming that includes 12 experiments. The first experiment involves creating a Java package with Stack and Queue classes that demonstrate LIFO and FIFO principles respectively using methods like push(), pop() and enqueue(), dequeue(). The second experiment involves designing a ComplexNumber class with constructors to perform addition, subtraction and multiplication of complex numbers.
This document discusses input/output and exception handling in Java. It covers reading and writing text files, including using Scanner and PrintWriter classes. It provides examples of reading numbers from a file and writing them out with formatting. It also discusses different file formats like text, HTML, and XML files. Finally, it covers techniques for reading text files like reading words, characters, and lines of text.
The document discusses implementing classes in Java. It begins with an example class called Counter that models a tally counter. It then covers key concepts for implementing classes like instance variables, methods, constructors, and encapsulation. It provides examples of implementing a simple Counter class with methods like click(), getValue(), and reset(). It also discusses specifying the public interface of a class before implementation, using a hypothetical BankAccount class as an example.
The document provides the syllabus for a Java lab course. It outlines 11 programming assignments that students must complete, including developing classes for rational numbers, dates, Lisp-like lists, stacks, vehicles, currency conversion, and a scientific calculator. It provides sample code and algorithms for implementing a rational number class, date class, Lisp list operations, stack data structure using arrays and linked lists, vehicle class hierarchy demonstrating polymorphism, currency classes for serialization, and a basic calculator using event-driven GUI programming.
The document discusses object oriented programming and Java. It provides a history of Java, describing how it was created at Sun Microsystems in the 1990s to be a simpler alternative to C++ that was architecture neutral, portable, distributed and secure. It then summarizes Java's key features including being object oriented, robust, simple, secure, portable and interpreted. It also describes Java's basic data types and how variables are declared and initialized in Java.
The document provides details of programs to be implemented in C++ and Java as part of an Object Oriented Programming lab. The C++ programs include implementations of inline function overloading, complex numbers using operator overloading, friend functions, string concatenation using dynamic memory allocation, type conversion using complex numbers, managing bank accounts using inheritance, and a stack class with exception handling. The Java programs include writing simple programs, palindrome checking using strings, interfaces, inheritance, exception handling, and multithreaded programs.
This document provides a lab manual for the fourth semester computer science engineering course on Object Oriented Technology. It includes the syllabus, rationale for object oriented programming, hardware and software requirements, a list of practical experiments to be conducted, and sample code for some of the experiments. The experiments cover topics like function overloading, inheritance, polymorphism, constructors, destructors, copy constructors, friend functions, and use of local, static and global objects. Each experiment is followed by sample output and questions related to the concepts covered in the program. The document aims to provide guidance to students on the practical implementation of object oriented programming concepts using C++.
This document contains lecture notes on Java programming divided into 6 units. Unit 1 provides an overview of Java and covers data types, variables, arrays, operators, control statements and classes. It also discusses I/O operations like reading console input/output and files. Unit 2 covers string handling and the StringBuffer class. Unit 3 discusses packages, interfaces and exception handling. Unit 4 focuses on multithreading concepts. Unit 5 covers applets, event handling and the Abstract Window Toolkit. Unit 6 introduces Swing and JDBC. The document also includes examples of Java programs and lists lab experiments and reference books.
This document summarizes key points about inheritance in Java from a chapter in a textbook. It discusses how a subclass inherits characteristics from its parent class, including methods and data. It also covers abstract classes, polymorphism through method overriding in subclasses, and how polymorphic references allow different methods to be called depending on the actual object type.
Java interfaces were created to solve the "Deadly Diamond of Death" problem that can occur with multiple inheritance in some object-oriented languages. An interface in Java is an abstract class that defines methods but does not provide implementations. Classes can implement multiple interfaces, inheriting their abstract methods without inheriting implementation details. This allows classes to gain functionality from multiple sources while avoiding conflicts between inherited properties. Interfaces in Java establish an "has-a" relationship between classes rather than a "is-a" relationship like inheritance.
The document provides definitions and explanations of various C# concepts including polymorphism, abstract methods, virtual methods, objects, classes, static methods, inheritance, virtual keyword, abstract classes, sealed modifiers, interfaces, pure virtual functions, access modifiers, reference types, overloading, overriding, encapsulation, arrays, array lists, hash tables, queues, stacks, early binding, late binding, sorted lists, and delegates. Key points covered include the differences between abstract and virtual methods, what defines a class versus an object, when to use static versus non-static methods, inheritance implementation in C#, and the purpose of interfaces.
Constructors and destructors in Python.
Constructors are special methods that are called automatically when an object is created. They initialize variables and ensure objects are properly initialized. There are two types of constructors: default and parameterized. Default don't take arguments, parameterized do.
Destructors are called when an object is destroyed. Defined using __del__(), they are useful for releasing resources like closing files before a program exits.
The document then provides code examples of classes with constructors, parameterized constructors, and destructors. It also discusses Python's garbage collection and how the collector deletes unneeded objects to free memory space.
The document provides an overview of object oriented programming and network programming concepts. It discusses topics like IP addresses, ports, sockets, client-server programming, and the java.net and java.util packages. The java.net package contains classes for network programming in Java like Socket, ServerSocket, URL, and InetAddress. The java.util package contains general-purpose utility classes like ArrayList, HashMap, Properties and Date.
This document provides information on several summer promotion tour packages in Vietnam between May 1st and September 30th, 2013.
The first package is a 3 day, 2 night tour of Ho Chi Minh City for $121 per person. It includes accommodation, meals, transportation and sightseeing activities in and around Ho Chi Minh City.
The second package is a 4 day, 3 night tour of Ho Chi Minh City and the Mekong Delta for $214 per person. It includes accommodation, meals, transportation and sightseeing in both Ho Chi Minh City and the Mekong Delta region.
The third and most comprehensive package is a 7 day, 6 night "Best of Vietnam" tour for
The document provides details on the planning and process for creating a watercolor character design. It describes collecting reference images, compiling mood boards, and choosing specific images to inspire the character's clothing design. The planning focused on designing a long coat, shoulders, hood, and other clothing elements. Reference images from games like Assassin's Creed were used. Sketches and scans of the watercolor process were included to show how different shades and colors were applied layer by layer to create the final character design.
Este documento describe tres paradigmas fundamentales que surgieron a mediados del siglo XX: el positivismo, el materialismo histórico y el historicismo. El positivismo de Comte y Durkheim buscaba entender y interactuar con la realidad estudiando científicamente los hechos. El materialismo histórico de Marx analizaba la sociedad desde la lógica de las contradicciones de clase. El historicismo se ubicó en el campo historiográfico y estudió los hechos clave como producto de su época.
This document discusses the progress and targets of various departments within an organization. It provides updates on several departments' achievements in areas like mentorship programs, fundraising, training initiatives, and relationship building. Key focus areas mentioned include strengthening basic processes, improving winter recruitment and engagement, increasing financial sustainability and impact demonstration, as well as enhancing tools and culture around client feedback.
Development Emails Content Analyzer: Intention Mining in Developer DiscussionsSebastiano Panichella
The document presents an approach called DECA (Development Email Content Analyzer) that uses natural language parsing to classify paragraphs in development emails according to intentions. DECA was evaluated on emails from two open source projects. It achieved good results for classifying email content, outperforming traditional machine learning techniques in terms of precision, recall and F-measure. The study aimed to understand how natural language parsing could help recognize informative text fragments in development discussions to guide software maintenance and evolution.
This document provides a lesson plan for teaching students about food vocabulary and using present and past tenses to describe meals. The objectives are to use food and meal vocabulary in context of present tense and to describe past meals using past tense. The lesson includes activities where students practice describing usual and past meals in pairs and groups, as well as listening and speaking assessments.
The document contains simple Spanish sentences describing what various people wear. It pairs the English and Spanish words for common clothing items like jumpers, skirts, boots, caps, jackets, sweatshirts, socks, dresses and shoes to demonstrate how to say "wear" in Spanish ("llevo/lleva/llevas").
Fse2012 - Who is going to Mentor Newcomers in Open Source Projects?Sebastiano Panichella
This document discusses mentoring newcomers in open source projects. It introduces the challenges of measuring socio-technical balance and how the initial project environment impacts developers' learning trajectories. Specifically, it examines how the relative sociality of a project at the time a developer joins affects their future participation and success. The goal is to better understand training and learning strategies to improve developer capabilities and project success.
- The document summarizes the state of financial affairs as of July 7th, 2014, including a bank balance of 3.06 lakhs and fixed deposits of 8.04 lakhs.
- It analyzes several projects (iGCDP, iGIP), noting gaps in realizations and negative cash flows for some.
- Investments made are outlined, such as flat rent of 84,000 INR and raises of 96,000 INR.
- Upcoming expenses are listed, including those for alumni engagement, office costs, and recruitment.
- The document concludes by thanking the reader.
This document discusses lateral thinking and provides examples of how it can be applied. Lateral thinking involves thinking creatively and unconventionally to solve problems by viewing them from different perspectives. It gives examples of how Einstein, Da Vinci, and Archimedes used lateral thinking to make breakthrough discoveries. The document encourages asking open-ended what-if questions to stimulate lateral thinking and explains that lateral thinking is important for advancing fields like science and medicine through creativity and new ideas.
Easy Bites: Lean Start-Up in Developing CountriesOliver Koch
Easy Bites is an internet startup that provides location-based food delivery services to the local Kurdish community. It follows lean and agile principles, with a build-measure-learn orientation and focus on validated learning. The document outlines Easy Bites' agile development approach, mobile aspects, quality assurance processes, and business model details such as key activities, partnerships, customer segments, and revenue streams.
This document provides guidance for software testing projects at the California Institute of Technology's Information Management Systems & Services (IMSS). It outlines the philosophy, goals, roles and responsibilities for testing. The testing strategy describes the stages of the testing lifecycle including preparation, unit testing, integration testing, system testing and user acceptance testing. Sample test strategies are provided for upgrading Oracle software and testing a data warehouse. The document also describes testing processes, procedures, documentation requirements and the testing environment.
The document defines several key terms related to digital images and file formats:
1. Pixel resolution refers to the number of pixels that can be displayed horizontally and vertically on a screen or image, with higher resolutions showing more detail but requiring larger file sizes.
2. There are two main types of computer graphics - raster (bitmap) images composed of pixels, and vector images composed of geometric paths.
3. Common file formats for digital images include BMP, PNG, GIF, TIFF, JPG, PSD, PDF, EPS and AI. Each has advantages for different types of images and uses.
4. Data compression reduces file sizes by removing unnecessary information, and can be lossless or lossy
The document describes the features of a mini-app for checking accounts, transferring money, managing certificates, and accessing customer support services. It outlines options for users to check balances, wire funds, import/export/manage digital certificates, call customer support, set alarms, and log out of the application. The mini-app provides quick access to common banking tasks through an easy-to-use interface.
Quarto incontro del Progetto TAG in provincia di Arezzo: una guida ad un uso consapevole di Facebook e Twitter.
Privacy, impostazioni, termini e buoni consigli per utilizzare al meglio i social network.
http://grechi.it
The document summarizes the performance of "TheAviator" MLM in the previous quarter, noting what worked well (initial culture, Q2 MLM, correct marketing tools, product repackaging) and what didn't (Q1 MLM, lack of raising drive, not enough forms, low capitalization of tools and events, low member culture and connection). It provides details on member retention, achievements against national targets, current targets, and plans going forward such as implementing teams, feedback systems, and better tool utilization.
This document discusses an automatic code generation tool called UJECTOR that can generate executable Java code from UML diagrams, including class diagrams, sequence diagrams, and activity diagrams. It notes the benefits of automatic code generation in reducing errors compared to manual coding. The paper also discusses some related work, including Enterprise Architect, Eclipse UML Generators, Rhapsody, and dCode - other tools that can generate code from UML models. Overall, the document examines challenges in ensuring consistency, accuracy, maintainability and efficiency when automatically generating code from UML models.
The document discusses object orientation and compares procedural and object-oriented programming. It defines key concepts in object-oriented programming like classes, objects, inheritance, encapsulation, and polymorphism. It also provides an example of a local class in ABAP with methods to retrieve and display data from database tables.
The document discusses object oriented programming concepts in ABAP, including:
1. Classes define objects and contain components like attributes and methods. Objects are instances of classes.
2. Classes can be declared globally or locally. Global classes are stored centrally while local classes are defined within a program.
3. Key object oriented programming concepts like inheritance, abstraction, encapsulation and polymorphism are explained with examples in ABAP.
4. An example program is provided to demonstrate creating a class to manage a bank account balance, with methods to set the balance, deposit amounts, and withdraw amounts.
The document outlines the program structure for the second year of engineering at the University of Mumbai for semesters 3 and 4. It includes details of the courses, teaching scheme, examination scheme, labs, and syllabus. Some of the key courses include Data Structures, Database Management Systems, Principles of Communication, and Paradigms and Computer Programming Fundamentals. The syllabus covers topics like Java fundamentals, OOP concepts, inheritance, packages, interfaces, exception handling, multithreading, I/O streams, and GUI programming using AWT and Swing. Students will complete labs related to the coursework and a mini project to develop a front-end or backend application using Java.
BARRACUDA, AN OPEN SOURCE FRAMEWORK FOR PARALLELIZING DIVIDE AND CONQUER ALGO...IJCI JOURNAL
This paper presents a newly-created Barracuda open-source framework which aims to parallelize Java divide and conquer applications. This framework exploits implicit for-loop parallelism in dividing and merging operations. So, this makes it a mixture of parallel for-loop and task parallelism. It targets sharedmemory multiprocessors and hybrid distributed shared-memory architectures. We highlight the effectiveness of the framework and focus on the performance gain and programming effort by using this framework. Barracuda aims at large public actors as well as various application domains. In terms of performance achievement, it is very close to Fork/Join framework while allowing end-users to only focus on refactoring code and experts to have the opportunity to improve it.
Annotation processing allows for metadata to be added to Java programs without altering the program itself. Annotations can be defined and used to provide information for compilers or allow runtime/compile-time processing. Annotation processors provide a hook into the Java compilation process to generate source code and compile errors/warnings. They work by processing annotated elements in rounds. Testing annotation processors is challenging but libraries like Google's compile-testing library can help. Annotation processing also works on Android by setting up the processor as a Java module and using plugins like android-apt.
The document provides information about object-oriented programming concepts in C#, including classes, objects, methods, constructors, and constructor overloading. It consists of a lab manual with 16 topics on OOP concepts. Each topic is presented on its own page and includes definitions, explanations, examples, and code snippets in C# to illustrate the concept. Constructor overloading allows defining multiple constructors with the same name but different parameters to initialize objects in different ways.
Method-Level Code Clone Modification using Refactoring Techniques for Clone M...acijjournal
Researchers focused on activities such as clone maintenance to assist the programmers. Refactoring is a well-known process to improve the maintainability of the software. Program refactoring is a technique to improve readability, structure, performance, abstraction, maintainability, or other characteristics by transforming a program. This paper contributes to a more unified approach for the phases of clone maintenance with a focus on clone modification. This approach uses the refactoring technique for clone modification. To detect the clones ‘CloneManager’ tool has been used. This approach is implemented as an enhancement to the existing tool CloneManager. The enhanced tool is tested with the open source projects and the results are compared with the performance of other three existing tools.
Don't be fooled by the thumbnail - the first couple of slides are a silly joke I forgot to remove before uploading.
Presentation derived from the "What's new in Python 2.4" document on http://www.python.org/ including much reformatting for presenting and presenter notes.
Please download the Keynote original - that way the presentation notes aren't burned into the slides.
This presentation is aimed at fitting a Simple Linear Regression model in a Python program. IDE used is Spyder. Screenshots from a working example are used for demonstration.
This document discusses defining custom classes in Java. It covers topics like returning objects from methods, using the "this" keyword, overloaded methods and constructors, class methods and variables, and organizing classes into packages. Key points include how objects are passed by value to method parameters rather than by reference, and how to document classes using Javadoc comments.
Configuring Mahout Clustering Jobs - Frank Scholtenlucenerevolution
See conference video - http://www.lucidimagination.com/devzone/events/conferences/ApacheLuceneEurocon2011
For more than a decade internet search engines have helped users find documents they are looking for. However, what if users aren't looking for anything specific but want a summary of a large document collection and want to be surprised? One solution to this problem is document clustering. Clustering algorithms group documents that have similar content. Real-life examples of clustering are clustered search results of Google news, or tag clouds which group documents under a shared label. Apache Mahout is a framework for scalable machine learning on top of Apache Hadoop and can be used for large scale document clustering. This talk introduces clustering in general and shows you step-by-step how to configure Mahout clustering jobs to create a tag cloud from a document collection. This talk is suitable for people who have some experience with Hadoop and perhaps Mahout. Knowledge of clustering is not required.
This document discusses using machine learning to classify malware into families based on the DREBIN dataset. It covers:
1. Preprocessing the dataset, including integer encoding and one-hot encoding to convert categorical data to numeric form for modeling.
2. Addressing overfitting by splitting the data into training and test sets and using cross-validation.
3. Using classifiers like Random Forest and SVM with strategies like one-vs-all and one-vs-one to perform multiclass classification of malware families.
4. The process of using binary classifiers for each family first, then combining the results to classify malware into the appropriate family.
The document discusses application packages and classes in PeopleSoft. It defines what an application package and class are, and explains how to create them using Application Designer. It also covers object-oriented concepts like classes, objects, encapsulation, inheritance, polymorphism. Additionally, it discusses class structure, importing packages and classes, access controls, defining methods, abstract methods, interfaces, constructors, get/set methods, and exception handling.
CORRELATING FEATURES AND CODE BY DYNAMIC AND SEMANTIC ANALYSISijseajournal
One major problem in maintaining a software system is to understand how many functional features in the
system and how these features are implemented. In this paper a novel approach for locating features in
code by semantic and dynamic analysis is proposed. The method process consists of three steps: The first
uses the execution traces as text corpus and the method calls involved in the traces as terms of document.
The second ranks the method calls in order to filter out omnipresent methods by setting a threshold. And
the third step treats feature-traces as first class entities and extracts identifiers from the rest method source
code and a trace-by-identifier matrix is generated. Then a semantic analysis model-LDA is applied on the
matrix to extract topics, which act as functional features. Through building several corresponding
matrices, the relations between features and code can be obtained for comprehending the system functional
intents. A case study is presented and the execution results of this approach can be used to guide future
research.
Summarizing Software API Usage Examples Using Clustering TechniquesNikos Katirtzis
This document presents CLAMS, an approach for automatically mining API usage examples from client code. It clusters API usage sequences, generates summarized snippets from the top clusters, and selects the most representative snippet from each cluster. The methodology can be easily adapted to new programming languages as it relies on abstract syntax trees and API call sequences rather than detailed semantic analysis. The system is evaluated on datasets from several Java libraries and is shown to produce more concise, readable snippets that better match handwritten examples compared to approaches that output API call sequences or less summarized snippets. The clustering approach that allows similar rather than just identical sequences leads to improved results.
Method-Level Code Clone Modification using Refactoring Techniques for Clone M...acijjournal
This document describes a method for modifying code clones using refactoring techniques. It discusses using the CloneManager tool to detect clones and then applying three refactoring patterns (extract method, move method, pull up method) to modify the clones. The approach is implemented as an enhancement to the CloneManager tool, allowing it to both detect clones and modify them using refactoring. The enhanced tool is tested on open source projects and results are compared to other clone detection tools.
Similar to ICPC 2012 - Mining Source Code Descriptions (20)
Maliheh (Mali) Izadi, PhD, Andrea Di Sorbo, and Sebastiano Panichella co-chaired the 3rd Intl. Workshop on NL-based Software Engineering
April 20 2024, Lisbon, Portugal.
Diversity-guided Search Exploration for Self-driving Cars Test Generation thr...Sebastiano Panichella
Timo Blattner, Christian Birchler, Timo Kehrer, Sebastiano Panichella: Diversity-guided Search Exploration for Self-driving Cars Test Generation through Frenet Space Encoding. Intl. Workshop on Search-Based and Fuzz Testing (SBFT). 2024
SBFT Tool Competition 2024 -- Python Test Case Generation TrackSebastiano Panichella
Nicolas Erni, Al-Ameen, Mohammed, Christian Birchler, Pouria Derakhshanfar, Stephan Lukasczyk, Sebastiano Panichella: SBFT Tool Competition 2024 -- Python Test Case Generation Track 17th International Workshop on Search-Based and Fuzz Testing
SBFT Tool Competition 2024 - CPS-UAV Test Case Generation TrackSebastiano Panichella
Sajad Khatiri, Prasun Saurabh, Timothy Zimmermann, Charith Munasinghe, Christian Birchler, Sebastiano Panichella: SBFT Tool Competition 2024 - CPS-UAV Test Case Generation Track 17th International Workshop on Search-Based and Fuzz Testing
Simulation-based Testing of Unmanned Aerial Vehicles with AerialistSebastiano Panichella
Sajad Khatiri, Sebastiano Panichella, Paolo Tonella: Simulation-based Testing of Unmanned Aerial Vehicles with Aerialist. International Conference on Software Engineering. 2024
Testing with Fewer Resources: Toward Adaptive Approaches for Cost-effective ...Sebastiano Panichella
Lecture entitled "Testing with Fewer Resources: Toward Adaptive Approaches for Cost-effective Test Generation and Selection" at the International Summer School
on Search- and Machine Learning-based Software Engineering
June 22-24, 2022 - Córdoba, Spain
Sebastiano Panichella and Christian Birchler
COSMOS:
DevOps for Complex Cyber-physical Systems
Sebastiano Panichella
Zurich University of Applied Sciences (ZHAW)
Workshop on Adaptive CPSoS (WASOS) 2023
Testing and Development Challenges for Complex Cyber-Physical Systems: Insigh...Sebastiano Panichella
Keynote presentation </b>at ICST (AIST workshop) entitled "Testing and Development Challenges for Complex Cyber-Physical Systems: Insights from the COSMOS H2020 Project"
An Empirical Characterization of Software Bugs in Open-Source Cyber-Physical ...Sebastiano Panichella
Presentation at 16th IEEE International Conference on Software
Testing, Verification and Validation (ICST): An Empirical Characterization of Software Bugs in Open-Source Cyber-Physical Systems. Journal of Systems & Software (JSS).
Automated Identification and Qualitative Characterization of Safety Concerns ...Sebastiano Panichella
Presentation at the IEEE/ACM International Conference on
Automated Software Engineering (ASE 2023):
“Automated Identification and Qualitative Characterization of Safety Concerns
Reported in UAV Software Platforms” -
Transactions on Software Engineering and Methodology
This document provides information about the NL-based Software Engineering (NLBSE) '23 workshop to be held on May 20th, 2023. The workshop will have two keynote speakers, two paper presentation sessions, a tool competition, and will be held in a hybrid format with both in-person and remote participation. It outlines the schedule, participating speakers and chairs, instructions for remote participants, and plans for recording and publishing the workshop proceedings.
Simulation-based Test Case Generation for Unmanned Aerial Vehicles in the Nei...Sebastiano Panichella
This document proposes a method called SURREALIST to generate realistic simulated test cases for unmanned aerial vehicles (UAVs) using real flight logs. It aims to address limitations of field testing such as lack of reproducibility and limited test scenarios. SURREALIST works in two steps: 1) It systematically replicates real flights in simulation by finding optimal drone and environment configurations that minimize differences between real and simulated flight trajectories. 2) It generates new challenging test cases by manipulating drone and environment configurations according to a difficulty measure, such as violating safety distances to obstacles. The approach is evaluated on examples of replicating and modifying an existing flight to evaluate its ability to find bugs. SURREALIST aims to generate tests that can discover non
Exposed! A case study on the vulnerability-proneness of Google Play AppsSebastiano Panichella
This study analyzed the vulnerability levels of 1000 mobile apps from Google Play across 23 categories. The key findings were:
1) Medical apps had significantly fewer vulnerabilities than other categories like Finance and Shopping.
2) An app's vulnerability level did not affect its rating, but apps with more downloads tended to have higher vulnerability levels.
3) Contextual information like app description, metadata, and static code features could predict an app's vulnerability level with over 75% accuracy, with market data providing complementary insights to code analysis. Addressing app security is important as users may not be aware of risks when installing apps.
Search-based Software Testing (SBST) '22
Workshop Co-Chairs:
Giovani Guizzo
UNIVERSITY COLLEGE LONDON, UNITED KINGDOM
Sebastiano Panichella
ZURICH UNIVERSITY OF APPLIED SCIENCE, SWITZERLAND
Competition Co-Chairs:
Alessio Gambi
UNIVERSITY OF PASSAU, GERMANY
Gunel Jahangirova
UNIVERSITÀ DELLA SVIZZERA ITALIANA, SWITZERLAND
Vincenzo Riccio
UNIVERSITÀ DELLA SVIZZERA ITALIANA, SWITZERLAND
Fiorella Zampetti
UNIVERSITY OF SANNIO, ITALY
Website Chair:
Rebecca Moussa
UNIVERSITY COLLEGE LONDON, UNITED KINGDOM
Program Committee:
Nazareno Aguirre, Universidad Nacional de Río Cuarto - CONICET, Argentina
Aldeida Aleti, Monash University, Australia
Giuliano Antoniol, Ecole Polytechnique de Montréal, Canada
Kate Bowers, Oakland University, USA
Jose Campos, University of Washington, USA
Thelma E. Colanzi, State University of Maringá, Brazil
Byron DeVries, Grand Valley State University, USA
Gordon Fraser, University of Passau, Germany
Erik Fredericks, Oakland University, USA
Gregory Gay, Chalmers and the University of Gothenburg, Sweden
Alessandra Gorla, IMDEA Software Institute, Spain
Gregory Kapfhammer, Allegheny College, USA
Yiling Lou, Peking University, China
Mitchell Olsthoorn, Delft University of Technology, Netherlands
Justyna Petke, University College London, UK
Silvia R. Vergilio, Universidade Federal do Paraná, Brazil
Simone do Rocio Senger de Souza, University of São Paulo, Brazil
Thomas Vogel, Humboldt-Universität zu Berlin, Germany
Jie Zhang, University College London, UK
Tool Competition
Introduction
NLP-based approaches and tools have been proposed to improve the efficiency of software engineers, processes, and products, by automatically processing natural language artifacts (issues, emails, commits, etc.).
We believe that the availability of accurate tools is becoming increasingly necessary to improve Software Engineering (SE) processes. One important process is issue management and prioritization where developers have to understand, classify, prioritize, assign, etc. incoming issues reported by end-users and developers.
This year, we are pleased to announce the first edition of the NLBSE’22 tool competition on issue report classification, an important task in issue management and prioritization.
For the competition, we provide a dataset encompassing more than 800k labeled issue reports (as bugs, enhancements, and questions) extracted from real open-source projects. You are invited to leverage this dataset for evaluating your classification approaches and compare the achieved results against a proposed baseline approach (based on FastText).
Competition overview
We created a Colab notebook with detailed information about the competition (provided data, baseline approach, paper submission, paper format, etc.).
If you want to participate, you must:
Train and tune a multi-label multi-class classifier using the provided training set. The classifier should assign one label to an issue.
Evaluate your classifier on the provided test set
Write a paper (4 pages max.) describing:
The architecture and details of the classifier
The procedure used to pre-process the data
The procedure used to tune the classifier on the training set
The results of your classifier on the test set
Additional info.: provide a link to your code/tool with proper documentation on how to run it
Submit the paper by emailing the tool competition organizers (see below)
Submissions will be evaluated and accepted based on correctness and reproducibility, defined by the following criteria:
Clarity and detail of the paper content
Availability of the code/tool, released as open-source
Correct training/tuning/evaluation of your code/tool on the provided data
Clarity of the code documentation
The accepted submissions will be published at the workshop proceedings.
The submissions will be ranked based on the F1 score achieved by the proposed classifiers on the test set, as indicated in the papers.
The submission with the highest F1 score will be the winner of the competition.
How to participate?
Email your paper to Oscar Chaparro (oscarch@wm.edu) and Rafael Kallis (rk@rafaelkallis.com) by the submission deadline.
1. Mining Source Code Descriptions
from Developer Communications
Sebastiano Jairo Massimiliano Andrian Gerardo
Panichella Aponte Di Penta Marcus Canfora
2. Context: Software Project
describes
Sequence
diagram Program
Documentation Comprehension
Source Code Class
diagram
Maintenance
Tasks
Difficult
understanding understanding
Developer
3. Context: Software Project
Coming back
to the reality...
describes
Sequence
diagram Program
Documentation Comprehension
Source Code Class
diagram
Maintenance
Tasks
Difficult
understanding understanding
Developer
4. ..................................................
When call the method IndexSplitter.split(File
Idea destDir, String[] segs) from the Lucene cotrib
directory(contrib/misc/src/java/org/apache/luc
ene/index) it creates an index with segments
We argue that messages exchanged wrong data. Namely wrong
descriptor file with among contributors/developers
are a useful source of information to help understanding of segment
is the number representing the name source code.
that would be created next in this index.
..................................................
In such situations developers need to infer knowledge from,
CLASS: IndexSplitter METHOD: split
source code descriptions in external
the source code itself
artifacts.
Developer
6. Step 1: Downloading emails/bugs reports and tracing them
onto classes
The discussion contains a fully-qualified class name (e.g.,
org.apache.lucene.analysis.MappingCharFilter); or the email contains a
Two heuristics file name (e.g., MappingCharFilter.java)
For bug reports, we complement the above heuristic by matching the
bug ID of each closed bug to the commit notes, therefore tracing the bug
report to the files changed in that commit
Developer
Discussion
When call the method IndexSplitter .split(File destDir, String[] segs) from the
Lucene cotrib directory (contrib/misc/src/java/org/apache/lucene/index) it creates
an index with segments descriptor file with wrong data. Namely wrong is the number
representing the name of segment that would be created next in this index.
CLASS: IndexSplitter
public void split(File destDir, String[] segs) throws IOException {
destDir.mkdirs();
FSDirectory destFSDir = FSDirectory.open(destDir);
SegmentInfos destInfos = new SegmentInfos }
If some of the segments of the index already has this name this results either to
impossibility to create new segment or in crating of an corrupted segment.
7. Step 2: Extracting paragraphs
We consider as paragraphs, text section separated by one or more
white lines
Two heuristics
We prune out paragraph description from source code fragments
and/or stack Traces "by using an approach inspired by the work of
Bacchelli et al.
Developer
Discussion
When call the method IndexSplitter.split(File destDir, String[] segs) from the PAR
Lucene cotrib directory (contrib/misc/src/java/org/apache/lucene/index) it creates
an index with segments descriptor file with wrong data. Namely wrong is the number
1
representing the name of segment that would be created next in this index.
public void split(File destDir, String[] segs) throws IOException {
destDir.mkdirs();
PAR
FSDirectory destFSDir = FSDirectory.open(destDir); 2
SegmentInfos destInfos = new SegmentInfos }
If some of the segments of the index already has this name this results either to
PAR
impossibility to create new segment or in crating of an corrupted segment. 3
8. Step 3: Tracing paragraphs onto methods
A) A valid paragraph must contain the keyword “method”
These paragraphs must
respect the following
B) and the method name must be followed by a open parenthesis—
two conditions:
i.e., we match “foo(”
Developer
Discussion A) B)
When call the method IndexSplitter.split(File destDir, String[] segs)
PAR
from the Lucene cotrib directory it creates an index with segments1
descriptor file with wrong data. Namely wrong is the number
representing the name of segment that would be created next in this
index.
CLASS: IndexSplitter
METHOD: split(
......................................................................................
......................................................................................
......................................................................................
......................................................................................
9. Step 4: Heuristic based Filtering
We defined a set of heuristics to further filter the paragraphs associated with
methods that assign each paragraph a score:
.......................... a) Method parameters:
Problem seems to come from
1 if the
% of parameters method
MainMethodeSearchEngine in
org.eclipse.jdt.internal.ui.launcher s1= mentioned in the does not
The Method paragraphs. Value have
searchMainMethods(IProgressMonitor, between 0 and 1 parameters
IJavaSearchScope, boolean) ,there's
a call to addSubTypes(List,
IProgressMonitor, IJavaSearchScope)
Method if includesSubtypes flag is
ON. This method add all types sub-
types as soon as the given scope
encloses them without testing if
sub-types have a main! After return
IType[] before the excecution
..........................
CLASS: MainMethodSearchEngine
METHOD: serachMainMethods
% parameter = 100% -> s1= 1
SCORE
10. Step 4: Heuristic based Filtering
We defined a set of heuristics to further filter the paragraphs associated with
methods that assign each paragraph a score:
.......................... a) Method parameters:
Problem seems to come from
1 if the
% of parameters method
MainMethodeSearchEngine in
org.eclipse.jdt.internal.ui.launcher s1= mentioned in the does not
The Method paragraphs. Value have
searchMainMethods(IProgressMonitor, between 0 and 1 parameters
IJavaSearchScope, boolean) ,there's
a call to addSubTypes(List, b) Syntactic descriptions (mentioning return values):
IProgressMonitor, IJavaSearchScope)
Method if includesSubtypes flag is check whether the Equal to one if
ON. This method add all types sub- paragraph contains the the method is
types as soon as the given scope s2= keyword “return”. If YES
encloses them without testing if
void.
sub-types have a main! After return Value equal 1, 0 otherwise
IType[] before the excecution
..........................
CLASS: MainMethodSearchEngine
METHOD: serachMainMethods
% parameter = 100% -> s1= 1
SCORE = 1+
11. Step 4: Heuristic based Filtering
We defined a set of heuristics to further filter the paragraphs associated with
methods that assign each paragraph a score:
.......................... a) Method parameters:
Problem seems to come from
1 if the
% of parameters method
MainMethodeSearchEngine in
org.eclipse.jdt.internal.ui.launcher s1= mentioned in the does not
The Method paragraphs. Value have
searchMainMethods(IProgressMonitor, between 0 and 1 parameters
IJavaSearchScope, boolean) ,there's
a call to addSubTypes(List, b) Syntactic descriptions (mentioning return values):
IProgressMonitor, IJavaSearchScope)
Method if includesSubtypes flag is check whether the Equal to one if
ON. This method add all types sub- paragraph contains the the method is
types as soon as the given scope s2= keyword “return”. If YES
encloses them without testing if
void.
sub-types have a main! After return Value equal 1, 0 otherwise
IType[] before the excecution c) Overriding/Overloading:
.......................... 1 if any of the “overload” or
CLASS: MainMethodSearchEngine s3=“override” keywords appears
METHOD: serachMainMethods in the paragraph, 0 otherwise
% parameter = 100% -> s1= 1 d) Method invocations:
SCORE = 1+ 0+ 1 = 2 1 if any of the “call” or
s4=“excecute” keywords appears
in the paragraph, 0 otherwise
12. Step 4: Heuristic based Filtering
We defined a set of heuristics to further filter the paragraphs associated with
methods that assign each paragraph a score:
a) Method parameters:
We selected paragraphs that have: % of parameters
1 if the
method
s1= mentioned in the does not
1. s1 ≥ thP = 0.5 paragraphs. Value have
between 0 and 1 parameters
2. s2 + s3 + s4 ≥ thH = 1 b) Syntactic descriptions (mentioning return values):
check whether the Equal to one if
paragraph contains the the method is
s2= keyword “return”. If YES void.
Value equal 1, 0 otherwise
OK c) Overriding/Overloading:
1 if any of the “overload” or
s3=“override” keywords appears
in the paragraph, 0 otherwise
% parameter = 100% -> s1= 1 ≥ 0.5 d) Method invocations:
SCORE = 1+ 0+ 1 = 2 ≥ 1 1 if any of the “call” or
s4=“excecute” keywords appears
in the paragraph, 0 otherwise
13. Step 5: Similarity based Filtering
We rank filtered paragraphs through their textual similarity with the method they
are likely describing.
METHOD PARAGRAPH SCORE Similarity Removing:
- English stop words;
Method_3 Paragraph_4 2.5 96.1%
- Programming
Method_1 Paragraph_1 2.5 95.6% language keywords
Method_2 Paragraph_2 1.5 97.4% Using:
Method_3 Paragraph_3 1.5 86.2% - Camel Case
splitting the on
Method_1 Paragraph_3 1.5 79.0%
remaining words
Method_3 Paragraph_2 1.5 77.5%
- Vector Space Model
Method_2 Paragraph_4 1.5 64.3%
Method_2 Paragraph_3 1.3 83.2%
Method_3 Paragraph_1 1.3 73.9% th>=0.80
Method_2 Paragraph_1 1.3 68.7%
Method_1 Paragraph_4 1.3 53.6%
14. Empirical Study
• Goal: analyze source code descriptions in developer
discussions
• Purpose: investigating how developer discussions
describe methods of Java Source Code
• Quality focus: find good method description in
messages exchanged among contributors/developers
• Context: Bug-report and mailing lists of two Java
Project
Apache Lucene and Eclipse
16. Research Questions
RQ1 (method coverage): How many methods from
the analyzed software systems are described by the
paragraphs identified by the proposed approach?
RQ2 (precision): How precise is the proposed approach
in identifying method descriptions?
RQ3 (missing descriptions): How many potentially
good method descriptions are missed by the approach?
17. RQ1: How many methods from the analyzed software
systems are described by the paragraphs identified
by the proposed approach?
18. RQ2: How precise is the proposed approach in identifying
method descriptions?
We sampled 250 descriptions from each project
19. RQ3: How many potentially good method descriptions are
missed by the approach?
We sampled 100 descriptions from each project
TABLE III
The analysis of a sample of 100 paragraphs traced to methods,
but not satisfying the Step 4 heuristic
System True Negatives False Negatives
Eclipse 78 22
Apache Lucene 67 33