Presentation of paper on "pitfalls in aspect mining" at the Working Conference on Reverse Engineering (WCRE), Antwerp, Belgium, 2008.
The research domain of aspect mining studies the problem of (semi-)automatically identifying potential aspects and crosscutting concerns in a software system, to improve the system’s comprehensibility or enable its migration to an aspect-oriented solution. Unfortunately, most proposed aspect mining techniques have not lived up to their expectations yet. In this paper we provide a list of problems that most aspect mining techniques suffer from and identify some of the root causes underlying these problems. Based upon this analysis, we conclude that many of the problems seem to be caused directly or indirectly by the use of inappropriate techniques, a lack of rigour and semantics on what is being mined for and how, and in how the results of the mining process are presented to the user.
Virtual functions allow dynamic binding to occur. This means that the function called is determined at runtime based on the actual object type, rather than static binding which determines the function at compile time. Some key points:
1) A virtual function tells the compiler to create a pointer to the function but not fill it in until called.
2) Classes with virtual functions are called polymorphic classes and allow overriding derived class functions.
3) Virtual functions are useful for polymorphism when subclasses need to provide unique implementations of the same method name.
The document discusses modeling industry data using Eclipse modeling tools and frameworks. It describes how EMF, GMF, TMF, M2M, and M2T were used to design domain-specific languages for an application originally built with Oracle Forms and Database. Domain models were created from 1722 tables and 19572 columns in the database. Graphical modeling tools allowed generating Java code and GUI views from these models, simplifying development and reducing code.
Object Oriented Solved Practice Programs C++ ExamsMuhammadTalha436
The question asks to create classes to represent publications, books, and tapes. The Publication class has title and price attributes. The Book class inherits from Publication and adds a noOfPages attribute. The Tape class inherits from Publication and adds a playingTime attribute.
This document provides an agenda for a presentation on esoteric LINQ and structural madness. The agenda includes background information on data structures like graphs, trees, and lists. It also covers design patterns like iterator, observer, visitor, and specification. The document then provides primers on LINQ and how it can be applied to functions, graphs, and specifications. The presentation aims to explore advanced and unconventional applications of LINQ through functional combinators and predicate logic.
Here are some suggested exercises to reinforce the concepts covered in this document on defining classes in C#:
1. Define a class to represent a mobile phone with properties for model, manufacturer, price, owner, battery, and display. The battery and display should be separate classes that are instantiated as properties of the phone class.
2. Define multiple constructors for each class - one that takes all required properties, one that takes a subset, and a default constructor. For example, the phone class could have a constructor that takes just the model and manufacturer or one that initializes all properties.
3. Add validation to property setters to ensure values are within acceptable ranges, e.g. price is greater than 0, battery life is
This document discusses principles of clean code based on the book "Clean Code" by Robert C. Martin. It provides examples of good and bad practices for naming variables and functions, structuring functions, using comments, and other topics. Key points include using meaningful names, keeping functions small and focused on a single task, avoiding deeply nested code and long argument lists, commenting to explain intent rather than state the obvious, and other guidelines for writing clean, readable code.
This document discusses functions, arrays, and structures in C++. It covers:
- Declaring and defining functions
- Passing arrays and structures as arguments to functions
- Returning arrays and structures from functions
- Using multidimensional arrays as function parameters
- Examples of functions that read/write arrays and structures
Virtual functions allow dynamic binding to occur. This means that the function called is determined at runtime based on the actual object type, rather than static binding which determines the function at compile time. Some key points:
1) A virtual function tells the compiler to create a pointer to the function but not fill it in until called.
2) Classes with virtual functions are called polymorphic classes and allow overriding derived class functions.
3) Virtual functions are useful for polymorphism when subclasses need to provide unique implementations of the same method name.
The document discusses modeling industry data using Eclipse modeling tools and frameworks. It describes how EMF, GMF, TMF, M2M, and M2T were used to design domain-specific languages for an application originally built with Oracle Forms and Database. Domain models were created from 1722 tables and 19572 columns in the database. Graphical modeling tools allowed generating Java code and GUI views from these models, simplifying development and reducing code.
Object Oriented Solved Practice Programs C++ ExamsMuhammadTalha436
The question asks to create classes to represent publications, books, and tapes. The Publication class has title and price attributes. The Book class inherits from Publication and adds a noOfPages attribute. The Tape class inherits from Publication and adds a playingTime attribute.
This document provides an agenda for a presentation on esoteric LINQ and structural madness. The agenda includes background information on data structures like graphs, trees, and lists. It also covers design patterns like iterator, observer, visitor, and specification. The document then provides primers on LINQ and how it can be applied to functions, graphs, and specifications. The presentation aims to explore advanced and unconventional applications of LINQ through functional combinators and predicate logic.
Here are some suggested exercises to reinforce the concepts covered in this document on defining classes in C#:
1. Define a class to represent a mobile phone with properties for model, manufacturer, price, owner, battery, and display. The battery and display should be separate classes that are instantiated as properties of the phone class.
2. Define multiple constructors for each class - one that takes all required properties, one that takes a subset, and a default constructor. For example, the phone class could have a constructor that takes just the model and manufacturer or one that initializes all properties.
3. Add validation to property setters to ensure values are within acceptable ranges, e.g. price is greater than 0, battery life is
This document discusses principles of clean code based on the book "Clean Code" by Robert C. Martin. It provides examples of good and bad practices for naming variables and functions, structuring functions, using comments, and other topics. Key points include using meaningful names, keeping functions small and focused on a single task, avoiding deeply nested code and long argument lists, commenting to explain intent rather than state the obvious, and other guidelines for writing clean, readable code.
This document discusses functions, arrays, and structures in C++. It covers:
- Declaring and defining functions
- Passing arrays and structures as arguments to functions
- Returning arrays and structures from functions
- Using multidimensional arrays as function parameters
- Examples of functions that read/write arrays and structures
Network vs. Code Metrics to Predict Defects: A Replication StudyKim Herzig
The document discusses a replication study of a previous work that found network metrics outperformed code metrics in defect prediction models. The replication study makes several contributions: it uses random sampling on the same release like the original, predicts defects across different releases of the same project, and predicts defects across different projects. It collects both code and network metrics using various tools and from various levels of granularity, with some differences from the original study such as language and projects used.
Model-Driven Software Development - Pretty-Printing, Editor Services, Term Re...Eelco Visser
The document discusses three topics: pretty-printing, editor services, and term rewriting. Pretty-printing involves transforming abstract syntax trees to concrete syntax. Editor services define behaviors for syntax highlighting, code folding, outlines, and completions. Term rewriting uses rewrite rules and strategies to transform abstract syntax trees.
This document discusses inheritance and polymorphism in Java. It describes using inheritance to define subclasses that extend existing superclasses in order to avoid code redundancy when multiple classes share common properties and behaviors. The key concepts covered include defining subclasses, invoking superclass constructors and methods using the super keyword, overriding methods in subclasses, polymorphism and dynamic binding, and casting between subclasses and superclasses.
The document discusses C++ strings and the string class. It covers string formats, the string class in the C++ standard library, string constructors, assigning and comparing strings, and input/output with strings using the insertion and extraction operators. It also covers using the getline function to read entire lines of input into string variables.
The document discusses classes and files in C++. It covers:
1) Classes in C++, including declaring classes, private, protected, and public members, and examples of classes.
2) Files in C++, including streams, reading from and writing to files, and the standard input/output streams.
3) Specific file classes in C++ - ifstream for input, ofstream for output, and fstream for both. It also covers opening files using the open() function.
This document discusses arrays and functions. It covers various topics related to arrays including declaring and manipulating multidimensional arrays, array parameters in functions, and converting between array types. It also provides an overview of functions, describing them as subparts of a program for obtaining input, performing calculations, and displaying output. Examples are given throughout to demonstrate array and function concepts.
The document provides an overview of the Java Persistence API (JPA) and how to use it for object-relational mapping. It discusses mapping entities to database tables, relationships like many-to-one and one-to-many, and managing persistence with an EntityManager. The key aspects covered are configuring JPA, writing entity classes, performing CRUD operations, querying entities, and dealing with detached and merged states.
The document discusses various design patterns in JavaScript including creational patterns like constructor, prototype, and singleton patterns. It also covers structural patterns such as decorator, facade, and flyweight patterns as well as behavioral patterns like observer and mediator patterns. Examples are provided for how to implement common patterns like module, revealing module, observer, and decorator patterns in JavaScript code.
The document provides an overview of basic Java programming concepts including:
1) The first Java program displays a window with a title and size set using the JFrame class. Object declaration and creation are described.
2) Key Java program components like comments, import statements, and class declarations are explained. The main method and its components are also outlined.
3) Common standard Java classes like JOptionPane, String, Date, and SimpleDateFormat are introduced and their basic usage is demonstrated through examples. Key string methods like substring, length, and indexOf are defined.
TDC2016POA | Trilha .NET - C# como você nunca viu: conceitos avançados de pro...tdc-globalcode
The document discusses concepts of functional programming in C# and .NET, including:
- Using functions as first-class citizens and higher-order functions like Map and Where
- Directing code towards immutability using concepts like Option and Either to represent failure
- Handling concurrency issues through immutable and referentially transparent functions
- Combining functions through combinators like Print and Time to add logging and profiling
The document discusses procedural abstraction and predefined functions in computer programming. It provides examples of for loops and nested for loops to iterate through ranges of values. The for loop examples demonstrate how the initialization, boolean expression, and update components work together to execute the loop body. Tracing is used to step through multiple iterations of the for loops.
This document discusses structures in C++. It defines a structure as a collection of related data items stored together under one name. It shows how to declare a structure with members, declare structure variables, assign and access values of structure members, and use arrays of structures. The objectives are to declare and use structure variables, understand the difference between structures and arrays, and use arrays in structures.
This document describes a presentation on using the Tagless Final style in the Play Framework for purely functional programming.
The presentation introduces Play Framework and how it uses Google Guice for dependency injection. It discusses separating the program from its execution using techniques like the Reader Monad and Free Monad. However, these have drawbacks like being difficult to use with multiple dependencies.
The presentation then introduces Tagless Final style as an alternative that has less boilerplate than Free Monad and allows separating program and implementation. It demonstrates a basic example of a UserRepository trait and implementation.
The rest of the agenda covers practicing Tagless Final style in the Play Framework, discussing its advantages but also that it is not a silver bullet
Agenda:
Getting Started with Standard Query
Operators
Language features supporting the LINQ Project like:
Lambda Expressions and Expression Trees
Extension Methods
Deferred Query Evaluation
Then touch on XLINQ and DLINQ
TDC2016POA | Trilha .NET - CQRS e ES na prática com RavenDBtdc-globalcode
The document discusses implementing CQRS and event sourcing patterns using RavenDB for persistence. It begins with a simple employee management prototype and evolves it to use domain-driven design principles like separating commands from queries and modeling entities to emit domain events in response to state changes. The events are stored as documents in RavenDB and are used to update entity state and project read models. It also covers loading entities from their event streams and saving event streams back to documents in the database.
The document discusses user-defined data types in C++ including defined constants (#define), defining own types (typedef), constants (const), enumerations (enum), scope of variables, and structures (struct). The key objectives are to understand how to create user-defined data types.
The document compares and contrasts VARCHAR and NVARCHAR data types in SQL Server. It discusses how NVARCHAR stores Unicode data using 2 bytes per character compared to 1 byte for VARCHAR, the maximum character limits of 4000 for NVARCHAR and 8000 for VARCHAR, and how the data types handle optional size parameters and functions like CAST.
The document also compares SQL Server to MySQL. It highlights differences in functions like NOW() vs GETDATE(), LIMIT vs TOP for pagination, auto-increment fields, character replacement functions, and more.
Finally, the document discusses the difference between SET QUOTED_IDENTIFIER ON and OFF in SQL Server. It explains that with it ON, characters in double quotes are treated as identifiers while with it OFF
The document discusses various concepts related to objects and classes in C++ including copy constructors, shallow vs deep copy, customizing copy constructors, immutable objects, static vs instance members, friend functions and classes, const member functions and objects, and the difference between structs and classes. Specifically, it provides examples to illustrate deep copying of objects containing dynamic memory, implementing copy constructors for deep copy, using static member functions and data, allowing access to private members using friend functions and classes, and ensuring objects are immutable using const.
This document introduces key concepts of object-oriented programming in Java including classes, objects, encapsulation, and inheritance. It discusses how classes are used to define objects and their properties (data fields) and behaviors (methods). Constructors are introduced as special methods used to initialize objects. The document provides examples of defining classes like Circle and TV, creating objects, and accessing object data and methods. It also discusses reference variables, the null value, default values, and differences between primitive types and reference types. Finally, core classes like Date, Random, and JFrame from the Java library are mentioned.
C# generics allow the specification of type parameters for classes, interfaces, and methods. This allows types to be deferred until runtime, providing type safety. Generics eliminate the need to use base object types and casts. Well-known generic collections like List<T> are provided in the System.Collections.Generic namespace.
The document summarizes new features in .NET 3.5 including implicitly typed local variables, automatic properties, object and collection initializers, extension methods, lambda expressions, query syntax, and anonymous types. Key features are variables that infer type from initialization value, simplified property declarations, initializing objects and collections in a single statement, extending types without inheritance, lambda functions, LINQ query syntax, and anonymous class types without names.
Network vs. Code Metrics to Predict Defects: A Replication StudyKim Herzig
The document discusses a replication study of a previous work that found network metrics outperformed code metrics in defect prediction models. The replication study makes several contributions: it uses random sampling on the same release like the original, predicts defects across different releases of the same project, and predicts defects across different projects. It collects both code and network metrics using various tools and from various levels of granularity, with some differences from the original study such as language and projects used.
Model-Driven Software Development - Pretty-Printing, Editor Services, Term Re...Eelco Visser
The document discusses three topics: pretty-printing, editor services, and term rewriting. Pretty-printing involves transforming abstract syntax trees to concrete syntax. Editor services define behaviors for syntax highlighting, code folding, outlines, and completions. Term rewriting uses rewrite rules and strategies to transform abstract syntax trees.
This document discusses inheritance and polymorphism in Java. It describes using inheritance to define subclasses that extend existing superclasses in order to avoid code redundancy when multiple classes share common properties and behaviors. The key concepts covered include defining subclasses, invoking superclass constructors and methods using the super keyword, overriding methods in subclasses, polymorphism and dynamic binding, and casting between subclasses and superclasses.
The document discusses C++ strings and the string class. It covers string formats, the string class in the C++ standard library, string constructors, assigning and comparing strings, and input/output with strings using the insertion and extraction operators. It also covers using the getline function to read entire lines of input into string variables.
The document discusses classes and files in C++. It covers:
1) Classes in C++, including declaring classes, private, protected, and public members, and examples of classes.
2) Files in C++, including streams, reading from and writing to files, and the standard input/output streams.
3) Specific file classes in C++ - ifstream for input, ofstream for output, and fstream for both. It also covers opening files using the open() function.
This document discusses arrays and functions. It covers various topics related to arrays including declaring and manipulating multidimensional arrays, array parameters in functions, and converting between array types. It also provides an overview of functions, describing them as subparts of a program for obtaining input, performing calculations, and displaying output. Examples are given throughout to demonstrate array and function concepts.
The document provides an overview of the Java Persistence API (JPA) and how to use it for object-relational mapping. It discusses mapping entities to database tables, relationships like many-to-one and one-to-many, and managing persistence with an EntityManager. The key aspects covered are configuring JPA, writing entity classes, performing CRUD operations, querying entities, and dealing with detached and merged states.
The document discusses various design patterns in JavaScript including creational patterns like constructor, prototype, and singleton patterns. It also covers structural patterns such as decorator, facade, and flyweight patterns as well as behavioral patterns like observer and mediator patterns. Examples are provided for how to implement common patterns like module, revealing module, observer, and decorator patterns in JavaScript code.
The document provides an overview of basic Java programming concepts including:
1) The first Java program displays a window with a title and size set using the JFrame class. Object declaration and creation are described.
2) Key Java program components like comments, import statements, and class declarations are explained. The main method and its components are also outlined.
3) Common standard Java classes like JOptionPane, String, Date, and SimpleDateFormat are introduced and their basic usage is demonstrated through examples. Key string methods like substring, length, and indexOf are defined.
TDC2016POA | Trilha .NET - C# como você nunca viu: conceitos avançados de pro...tdc-globalcode
The document discusses concepts of functional programming in C# and .NET, including:
- Using functions as first-class citizens and higher-order functions like Map and Where
- Directing code towards immutability using concepts like Option and Either to represent failure
- Handling concurrency issues through immutable and referentially transparent functions
- Combining functions through combinators like Print and Time to add logging and profiling
The document discusses procedural abstraction and predefined functions in computer programming. It provides examples of for loops and nested for loops to iterate through ranges of values. The for loop examples demonstrate how the initialization, boolean expression, and update components work together to execute the loop body. Tracing is used to step through multiple iterations of the for loops.
This document discusses structures in C++. It defines a structure as a collection of related data items stored together under one name. It shows how to declare a structure with members, declare structure variables, assign and access values of structure members, and use arrays of structures. The objectives are to declare and use structure variables, understand the difference between structures and arrays, and use arrays in structures.
This document describes a presentation on using the Tagless Final style in the Play Framework for purely functional programming.
The presentation introduces Play Framework and how it uses Google Guice for dependency injection. It discusses separating the program from its execution using techniques like the Reader Monad and Free Monad. However, these have drawbacks like being difficult to use with multiple dependencies.
The presentation then introduces Tagless Final style as an alternative that has less boilerplate than Free Monad and allows separating program and implementation. It demonstrates a basic example of a UserRepository trait and implementation.
The rest of the agenda covers practicing Tagless Final style in the Play Framework, discussing its advantages but also that it is not a silver bullet
Agenda:
Getting Started with Standard Query
Operators
Language features supporting the LINQ Project like:
Lambda Expressions and Expression Trees
Extension Methods
Deferred Query Evaluation
Then touch on XLINQ and DLINQ
TDC2016POA | Trilha .NET - CQRS e ES na prática com RavenDBtdc-globalcode
The document discusses implementing CQRS and event sourcing patterns using RavenDB for persistence. It begins with a simple employee management prototype and evolves it to use domain-driven design principles like separating commands from queries and modeling entities to emit domain events in response to state changes. The events are stored as documents in RavenDB and are used to update entity state and project read models. It also covers loading entities from their event streams and saving event streams back to documents in the database.
The document discusses user-defined data types in C++ including defined constants (#define), defining own types (typedef), constants (const), enumerations (enum), scope of variables, and structures (struct). The key objectives are to understand how to create user-defined data types.
The document compares and contrasts VARCHAR and NVARCHAR data types in SQL Server. It discusses how NVARCHAR stores Unicode data using 2 bytes per character compared to 1 byte for VARCHAR, the maximum character limits of 4000 for NVARCHAR and 8000 for VARCHAR, and how the data types handle optional size parameters and functions like CAST.
The document also compares SQL Server to MySQL. It highlights differences in functions like NOW() vs GETDATE(), LIMIT vs TOP for pagination, auto-increment fields, character replacement functions, and more.
Finally, the document discusses the difference between SET QUOTED_IDENTIFIER ON and OFF in SQL Server. It explains that with it ON, characters in double quotes are treated as identifiers while with it OFF
The document discusses various concepts related to objects and classes in C++ including copy constructors, shallow vs deep copy, customizing copy constructors, immutable objects, static vs instance members, friend functions and classes, const member functions and objects, and the difference between structs and classes. Specifically, it provides examples to illustrate deep copying of objects containing dynamic memory, implementing copy constructors for deep copy, using static member functions and data, allowing access to private members using friend functions and classes, and ensuring objects are immutable using const.
This document introduces key concepts of object-oriented programming in Java including classes, objects, encapsulation, and inheritance. It discusses how classes are used to define objects and their properties (data fields) and behaviors (methods). Constructors are introduced as special methods used to initialize objects. The document provides examples of defining classes like Circle and TV, creating objects, and accessing object data and methods. It also discusses reference variables, the null value, default values, and differences between primitive types and reference types. Finally, core classes like Date, Random, and JFrame from the Java library are mentioned.
C# generics allow the specification of type parameters for classes, interfaces, and methods. This allows types to be deferred until runtime, providing type safety. Generics eliminate the need to use base object types and casts. Well-known generic collections like List<T> are provided in the System.Collections.Generic namespace.
The document summarizes new features in .NET 3.5 including implicitly typed local variables, automatic properties, object and collection initializers, extension methods, lambda expressions, query syntax, and anonymous types. Key features are variables that infer type from initialization value, simplified property declarations, initializing objects and collections in a single statement, extending types without inheritance, lambda functions, LINQ query syntax, and anonymous class types without names.
Dart, le nouveau langage Web de Google présenté au public en octobre 2011 a pour objectif de proposer une alternative au JavaScript.
Bien que la version finale ne soit pas encore disponible (pour cela il faudra attendre cet été), Dart est utilisable dès aujourd'hui.
Au cours de cette présentation nous verrons :
comment Dart permet de développer des applications clientes aussi bien que serveurs,
quelques éléments du langage,
mais aussi les outils permettant un développement industrialisé et une productivité accrue.
Spring Data is a framework that unifies access to data stores and repositories. It provides templates for data access, object mapping to data stores, and repository support with CRUD and query methods. Spring Data supports both relational and NoSQL databases. Repositories provide a common interface for data access while templates handle store-specific operations like queries. Object mapping annotations map domain objects to different data models. Spring configuration enables transactions and scans for repositories. Unit tests validate data access and repositories.
This lab report discusses object-oriented programming concepts like classes, objects, inheritance, and constructors in Java. It includes:
1) A class defines common properties and behaviors for a group of objects, while an object is an instance of a class. A house is an object with state like address and behavior like opening doors.
2) A constructor initializes an object when it is created and can be overloaded with different parameters. Getter and setter methods are used to access private variables.
3) Inheritance allows a subclass to inherit properties and behaviors from a parent class in a hierarchical relationship. This lab report provides examples of single, multilevel, and hierarchical inheritance in Java code.
The document discusses defining classes and objects in Java. It covers defining simple classes, class elements like fields and methods, constructors, properties, static members, and using classes by creating instances and calling methods. Key points include classes define the structure of objects, constructors initialize object state, properties encapsulate fields, and static members are associated with a class not individual objects.
This C# code defines constants, variables, methods, classes, and other elements within the myApplication namespace. It declares a constant string for a first name, a variable for a last name, and initializes the last name in the constructor. It also defines an enum with some common names and a delegate that can be used as a callback with an integer parameter.
Defining Simple Classes
Using Own Classes and Objects
Access Modifiers
Constructors and Initializers
Defining Fields
Defining Properties, Getters and Setters
Defining Methods
Exercises: Defining and Using Own Classes
Guided by practical examples this talk conveys the value of how code can become clearer when focusing on behavior, language, responsibility and the chosen model to implement. The clarity that ensues can lead to a more supple design allowing to implement - or assess the effort required to implement - future functionality faster.
The document discusses inheritance in C++. It shows how a derived class can inherit properties and behaviors from a base class, while also adding its own properties and overriding or specializing inherited behaviors. Examples include a Polygon base class that is derived into Rectangle and Triangle classes, and a Time base class derived into an ExtTime class that adds time zone tracking. Inheritance allows defining hierarchies of related classes to reduce duplication and extend functionality.
The document discusses inheritance in C++. It shows how a derived class can inherit properties and behaviors from a base class, while also adding its own private data members and defining its own public member functions, including overriding virtual functions from the base class. The key aspects covered are:
- Defining derived classes that inherit publicly or privately from a base class
- Access control of inherited members depending on inheritance type
- Calling base class constructors from derived class constructors
- Derived classes augmenting the base class with additional data and functions
- Overriding functions to specialize behavior while reusing the base class interface
This document provides an introduction to Groovy for Java developers. It discusses Groovy's features such as closures, optional typing and syntax, and how it compiles to Java bytecode. It then provides examples of writing a simple Groovy script to generate XML, using closures, mocking objects in tests, and building projects with Ant.
Create a class named Student that has the following member variables.pdfarrowvisionoptics
Create a class named Student that has the following member variables: first name (string), last
name(string), student identification number(int), an integer array where the grades of all classes
are stored, grade point average (gpa) (float). Write appropriate constructor, mutator and accessor
functions for the class along with the following A function that inputs all values from the user
(except for gpa) A function that outputs the names and gpa of students
Solution
/* Java Programme for Grades Calculation */
import java.util.Scanner;
public class Student
{
//Private varibles declaration
private String firstName;
private String lastName;
private int sid;
private int[] grades= new int[10];
int[] tempgrades= new int[10];
int noc;
private float gpa=0;
//Constructor method
Scanner in=new Scanner(System.in); //scanner class object for reading input
public static void main(String[] args)
{
Student st=new Student(); //creating object and calling default constructor
st.readInput();
st.calgpa();
}
//Mutator for firstName
public void setfirstName(String firstName)
{
this.firstName = firstName;
}
//Mutator for lastName
public void setlastName(String lastName)
{
this.lastName = lastName;
}
//Mutator for sid
public void setsid(int sid)
{
this.sid = sid;
}
//Mutator for grades
public void setgrades(int[] grades)
{
this.grades = grades;
}
void readInput() //Function to read input data
{
System.out.println(\"Enter First Name\ \"); //Prompt for name
String temp=in.nextLine(); //reading name
setfirstName(temp); //calling mutator for firstName
System.out.println(\"Enter Last Name\ \"); //Prompt for last name
String temp1=in.nextLine(); //read last anme
setlastName(temp1); //calling mutator for lastName
System.out.println(\"Enter Student ID\ \"); //prompt for student id
int temp2=in.nextInt(); //read student id
setsid(temp2); //calling mutator for sid
System.out.println(\"Enter Number of classes ID\ \"); //Prompt for Number of classes
noc=in.nextInt(); //read Number of classes
System.out.println(\"Enter Grades of classes ID\ \"); //Prompt for Grades of classes
for(int i=0;i Gpa : \" + gpa+\"\ \"); //Dispaly output
}
}
Output :
javac Student.java //Compilation of java programme
java Student //running java programme
Sample output :
Enter First Name
Ashok
Enter Last Name
Kumar
Enter Student ID
101
Enter Number of classes ID
4
Enter Grades of classes ID
10
9
8
7
First Name : Ashok Last Name : Kumar Student Id : 101 --> Gpa : 8.5.
The document defines classes and methods in Java.
It discusses:
1) The syntax for defining a class with modifiers, data declarations, and method definitions.
2) How a class can contain data declarations and method declarations to store information and perform behaviors.
3) The structure of a method including the header, parameters, and body.
4) How to define constructors, static methods, and overload methods in a class.
Paulo Morgado presented an overview of new features in C# 6.0. Some key points:
- The .NET Compiler Platform ("Roslyn") reimplements the C# and VB compilers in C# with public APIs.
- New C# 6.0 features include auto-property initializers, primary constructors, string interpolation, null propagation, expression-bodied members, and await in catch/finally blocks.
- Many features are still being implemented or considered for inclusion in C# 6.0 based on the April 2014 preview release.
- The presentation demonstrated examples of the new C# 6.0 language features and their syntax. Attendees were encouraged to try
1) The document discusses user-defined classes in Java, including defining classes with modifiers, data declarations, and method definitions. It provides examples of class definitions with private instance variables and public methods.
2) It describes the syntax for defining methods, including the method header with return type and parameters. The document explains value-returning methods, void methods, and use of return statements.
3) The document shows an example class definition for a Rectangle with constructor, getter, and calculateArea methods to demonstrate object instantiation and method calls.
The document discusses generics in C#, explaining that generics allow defining type-safe data structures without committing to actual data types, improving performance and code quality. It covers why generics are required by discussing issues with non-generic stacks, and describes generic type parameters, constraints, methods, delegates and event handling using generics.
These slides, covering the topics of Software Maintenance and Evolution, are introductory slides to the course LINGI2252 “Software Maintenance and Evolution”, given by Prof. Kim Mens at UCL, Belgium
An introductory lecture on Context-Oriented Programming, part of the course LINGI2252 “Software Maintenance and Evolution”, given by Prof. Kim Mens at UCL, Belgium. This particular lecture was made by Dr. Sebastian Gonzalez in close collaboration with Prof. Kim Mens.
Software Reuse and Object-Oriented Programmingkim.mens
These slides on Software Reuse and Object-Oriented Programming are part of the course LINGI2252 “Software Maintenance and Evolution”, given by Prof. Kim Mens at UCL, Belgium
These slides on Object-Oriented Design Heuristics are part of the course LINGI2252 “Software Maintenance and Evolution”, given by Prof. Kim Mens at UCL, Belgium.
The document discusses refactoring code to improve its internal structure without changing external behavior. It defines refactoring and provides reasons for refactoring like improving design and readability. It also categorizes different types of refactorings like decomposing methods, moving features between objects, and organizing data. Specific refactorings are explained like extract method, inline method, move method, and encapsulate field.
This presentation on Object-Oriented Application Frameworks is part of a larger course LINGI2252 on Software Maintenance and Evolution, given at UCL university in Belgium.
Towards a Context-Oriented Software Implementation Frameworkkim.mens
Context-aware systems must manage the dynamic selection, activation, and execution of feature variants according to changing contexts, detected from data gathered from their surrounding execution environment. Many context-oriented programming languages focus only on the implementation level by providing appropriate language abstractions for implementing behavioural variations that can adapt dynamically to changing contexts. They often ignore or presuppose the existence of mechanisms to deal with earlier aspects such as the gathering of sensory input and context discovery. In this presentation we discuss a layered software architecture that reconciles all these aspects in a single implementation framework, which can be customised by application programmers into actual context-aware applications. This framework and a simulator to test applications build using this framework we recently implemented in Ruby and Ruby on Rails.
Towards a Taxonomy of Context-Aware Software Variabilty Approacheskim.mens
Modern software systems demand more and more smart capabilities depending on their context of use, as well as the ability to dynamically adapt these capabilities according to sensed context changes. This requires appropriate techniques for modelling, representing and handling context-aware software variability. While traditional variability modelling approaches like feature orientation and software product lines are evolving to address the increased dynamicity and context specificity required for this new generation of software systems, new paradigms such as context-oriented programming have emerged. Although developed independently, since they address similar issues, many similarities exist between these approaches. The purpose of this work is to define, categorise and compare key concepts shared by these approaches.
Such a taxonomy is a first step towards a better understanding of the differences and similarities between different approaches for managing context-aware software variability, and to achieve a cross-fertilisation between them.
An introductory lecture on context-oriented programming, part of a full course on Programming Paradigms at UCL university in Belgium, focussing on reflection and meta programming techniques in a variety of languages. This particular lecture was made by Sebastian Gonzalez in close collaboration with Kim Mens.
This document provides an overview of reflection and metaprogramming by defining key concepts and terminology. It discusses computational systems, programs, meta systems, and meta programs. Reflection is defined as a program examining or changing its own implementation at runtime. For a system to be reflective, its concepts must be reified and it must have a causal connection between the system and what it represents. Types of reflection include introspection, structural reflection, and computational reflection. Reflective systems can be implemented using towers of interpreters or reflective architectures with meta-objects.
This document discusses advanced reflection features in Java, including dynamic proxies, call stack introspection, and instrumentation. It begins with an overview of dynamic proxies using the Proxy class and InvocationHandler interface. It then covers examining the call stack using Throwable and StackTraceElement. Finally, it describes instrumentation using the java.lang.instrument package to modify bytecode at runtime, such as logging class loads or tracing method calls. Examples are provided for each topic.
An introduction to the basics of reflection in the object-oriented programming language Java, part of a full lecture on Programming Paradigms at UCL university in Belgium, focussing on the programming languages Smalltalk, Ruby and Java, with reflection and meta programming as underlying theme.
An introduction to some advanced language features of the object-oriented programming language Ruby, part of a full lecture on Programming Paradigms at UCL university in Belgium, focussing on the programming languages Smalltalk, Ruby and Java, with reflection and meta programming as underlying theme. This lecture looks into the Ruby features of higher-order programming (lambdas), singleton methods, mixin modules, reflection and metaprogramming.
A quick introduction to the object-oriented programming language Ruby, part of a full lecture on Programming Paradigms at UCL university in Belgium, focussing on the programming languages Smalltalk, Ruby and Java, with reflection and meta programming as underlying theme.
A quick introduction to the object-oriented programming language Smalltalk, part of a full lecture on Programming Paradigms at UCL university in Belgium, focussing on the programming languages Smalltalk, Ruby and Java, with reflection and meta programming as underlying theme.
A gentle and intuitive introduction to reflection and meta programming, part of a full lecture on programming paradigms at UCL university in Belgium, with reflection and meta programming as theme. (Further lectures focus more in depth on reflection and meta programming in a variety of languages such as Smalltalk, Ruby and Java.)
Describing and Interpreting an Immersive Learning Case with the Immersion Cub...Leonel Morgado
Current descriptions of immersive learning cases are often difficult or impossible to compare. This is due to a myriad of different options on what details to include, which aspects are relevant, and on the descriptive approaches employed. Also, these aspects often combine very specific details with more general guidelines or indicate intents and rationales without clarifying their implementation. In this paper we provide a method to describe immersive learning cases that is structured to enable comparisons, yet flexible enough to allow researchers and practitioners to decide which aspects to include. This method leverages a taxonomy that classifies educational aspects at three levels (uses, practices, and strategies) and then utilizes two frameworks, the Immersive Learning Brain and the Immersion Cube, to enable a structured description and interpretation of immersive learning cases. The method is then demonstrated on a published immersive learning case on training for wind turbine maintenance using virtual reality. Applying the method results in a structured artifact, the Immersive Learning Case Sheet, that tags the case with its proximal uses, practices, and strategies, and refines the free text case description to ensure that matching details are included. This contribution is thus a case description method in support of future comparative research of immersive learning cases. We then discuss how the resulting description and interpretation can be leveraged to change immersion learning cases, by enriching them (considering low-effort changes or additions) or innovating (exploring more challenging avenues of transformation). The method holds significant promise to support better-grounded research in immersive learning.
Mending Clothing to Support Sustainable Fashion_CIMaR 2024.pdfSelcen Ozturkcan
Ozturkcan, S., Berndt, A., & Angelakis, A. (2024). Mending clothing to support sustainable fashion. Presented at the 31st Annual Conference by the Consortium for International Marketing Research (CIMaR), 10-13 Jun 2024, University of Gävle, Sweden.
Or: Beyond linear.
Abstract: Equivariant neural networks are neural networks that incorporate symmetries. The nonlinear activation functions in these networks result in interesting nonlinear equivariant maps between simple representations, and motivate the key player of this talk: piecewise linear representation theory.
Disclaimer: No one is perfect, so please mind that there might be mistakes and typos.
dtubbenhauer@gmail.com
Corrected slides: dtubbenhauer.com/talks.html
hematic appreciation test is a psychological assessment tool used to measure an individual's appreciation and understanding of specific themes or topics. This test helps to evaluate an individual's ability to connect different ideas and concepts within a given theme, as well as their overall comprehension and interpretation skills. The results of the test can provide valuable insights into an individual's cognitive abilities, creativity, and critical thinking skills
When I was asked to give a companion lecture in support of ‘The Philosophy of Science’ (https://shorturl.at/4pUXz) I decided not to walk through the detail of the many methodologies in order of use. Instead, I chose to employ a long standing, and ongoing, scientific development as an exemplar. And so, I chose the ever evolving story of Thermodynamics as a scientific investigation at its best.
Conducted over a period of >200 years, Thermodynamics R&D, and application, benefitted from the highest levels of professionalism, collaboration, and technical thoroughness. New layers of application, methodology, and practice were made possible by the progressive advance of technology. In turn, this has seen measurement and modelling accuracy continually improved at a micro and macro level.
Perhaps most importantly, Thermodynamics rapidly became a primary tool in the advance of applied science/engineering/technology, spanning micro-tech, to aerospace and cosmology. I can think of no better a story to illustrate the breadth of scientific methodologies and applications at their best.
PPT on Direct Seeded Rice presented at the three-day 'Training and Validation Workshop on Modules of Climate Smart Agriculture (CSA) Technologies in South Asia' workshop on April 22, 2024.
ESR spectroscopy in liquid food and beverages.pptxPRIYANKA PATEL
With increasing population, people need to rely on packaged food stuffs. Packaging of food materials requires the preservation of food. There are various methods for the treatment of food to preserve them and irradiation treatment of food is one of them. It is the most common and the most harmless method for the food preservation as it does not alter the necessary micronutrients of food materials. Although irradiated food doesn’t cause any harm to the human health but still the quality assessment of food is required to provide consumers with necessary information about the food. ESR spectroscopy is the most sophisticated way to investigate the quality of the food and the free radicals induced during the processing of the food. ESR spin trapping technique is useful for the detection of highly unstable radicals in the food. The antioxidant capability of liquid food and beverages in mainly performed by spin trapping technique.
EWOCS-I: The catalog of X-ray sources in Westerlund 1 from the Extended Weste...Sérgio Sacani
Context. With a mass exceeding several 104 M⊙ and a rich and dense population of massive stars, supermassive young star clusters
represent the most massive star-forming environment that is dominated by the feedback from massive stars and gravitational interactions
among stars.
Aims. In this paper we present the Extended Westerlund 1 and 2 Open Clusters Survey (EWOCS) project, which aims to investigate
the influence of the starburst environment on the formation of stars and planets, and on the evolution of both low and high mass stars.
The primary targets of this project are Westerlund 1 and 2, the closest supermassive star clusters to the Sun.
Methods. The project is based primarily on recent observations conducted with the Chandra and JWST observatories. Specifically,
the Chandra survey of Westerlund 1 consists of 36 new ACIS-I observations, nearly co-pointed, for a total exposure time of 1 Msec.
Additionally, we included 8 archival Chandra/ACIS-S observations. This paper presents the resulting catalog of X-ray sources within
and around Westerlund 1. Sources were detected by combining various existing methods, and photon extraction and source validation
were carried out using the ACIS-Extract software.
Results. The EWOCS X-ray catalog comprises 5963 validated sources out of the 9420 initially provided to ACIS-Extract, reaching a
photon flux threshold of approximately 2 × 10−8 photons cm−2
s
−1
. The X-ray sources exhibit a highly concentrated spatial distribution,
with 1075 sources located within the central 1 arcmin. We have successfully detected X-ray emissions from 126 out of the 166 known
massive stars of the cluster, and we have collected over 71 000 photons from the magnetar CXO J164710.20-455217.
Sharlene Leurig - Enabling Onsite Water Use with Net Zero Water
Pitfalls In Aspect Mining
1. Pitfalls in
Aspect Mining
Pr. Kim Mens Dr. Andy Kellens Dr. Jens Krinke
Université catholique de Louvain Vrije Universiteit Brussel King’s College London
B-1348 Louvain-la-Neuve Belgium United Kingdom
Belgium akellens@vub.ac.be krinke@acm.org
kim.mens@uclouvain.be
WCRE 2008, 15th Working Conference on Reverse Engineering
October 15th – 18th, 2008 Antwerp, Belgium
1
2. What’s this paper doing here?
Reverse engineering is about
“recovering information from existing software and systems”
WCRE studies innovative
methods for extracting such information and
ways of using that information for system renovation and program
understanding
Aspect mining tries to
identify potential aspects and crosscutting concerns from existing
software systems
in order to improve the system's comprehensibility or
to enable its migration to an aspect-oriented solution
2
3. Why did we write this paper?
Partly out of frustration
Prior research on aspect mining
Co-authored ~8 papers since 2004,
including some survey papers
Variety of techniques
based on FCA, clustering, clone detection, ...
No satisfactory results : Why ?
3
4. Our goal
Most proposed aspect mining techniques have not lived up to
their expectations yet
Draw list of problems that most aspect mining techniques
suffer from
Identify root causes underlying these problems
Provide suggestions for improvements
Moment of reflection on state of research in aspect mining
no big “surprises”
provide broader basis for discussion
4
5. Aspects in a nutshell
implementing a notify/listener
the
public abstract class Customer {
private CustomerID id;
private Collection listeners;
public Address getAddress() {
OO return this.address; } public abstract class Customer {
the
public void setLastName(String name) { private CustomerID id;
this.lastName = name; }
way
public Address getAddress() {
public void setCustomerID(String id) { return this.address; }
AO
this.id = id; public void setLastName(String name) {
notifyListeners();
} public class PrivateCustomer { this.lastName = name; }
...
... public void setCustomerID(String id) {
way
private String lastName;
public class CorporateCustomer { this.id = id; }
private String firstName;
... ...
...
private String companyName; public void setLastName(String name) {
private CompanyName taxNumber; this.lastName = name; public class PrivateCustomer {
... notifyListeners();
} public class CorporateCustomer { ...
public void setCompanyName(String name) { public void setFirstName(String name) { ... private String lastName;
this.companyName = name; this.firstName = name; private String companyName; private String firstName;
notifyListeners();
} notifyListeners();
} private CompanyName taxNumber; ...
public void setTaxNumber(String nr) { } ... public void setLastName(String name) {
this.taxNumber = nr;
public void setCompanyName(String name) { this.lastName = name; }
notifyListeners();
}
this.companyName = name; } public void setFirstName(String name) {
}
public void setTaxNumber(String nr) { this.firstName = name; }
public class CustomerListener {
this.taxNumber = nr; } }
}
public void notify(Customer modifiedCustomer) {
System.out.println(quot;Customer quot; + modifiedCustomer.getID() + quot; was modifiedquot;);
} public aspect ChangeNotification {
} pointcut stateUpdate(Customer c) :
pointcut
execution(* Customer.set*(..)) &&
this(c);
after(Customer c): stateUpdate(c) {
tangling for (Iterator iterator = c.listeners.iterator(); iterator.hasNext();) {
advice
CustomerListener listener = (CustomerListener) iterator.next();
listener.notify(c);
}
code in one region addresses }
sca ttering
multiple concerns ... some interclass definitions here ...
code addressing one concern
clean separation of concerns
is spread around the system
5
6. Aspect Mining
Note:
If you want to migrate towards aspects,
aspect mining is only the first step.
aspect 3
aspect 1
You still need to “extract” aspect 2
the actual aspects from the
discovered aspect
6
7. Why Aspect Mining?
Legacy systems
large, complex systems
Not always clearly documented
Program understanding
useful to find crosscutting concerns (what?)
useful to find extent of the crosscutting concerns (where?)
First step in migration to aspect-oriented solution
or just to document the croscutting concerns
7
8. How does it work?
(mostly) Variety of techniques from data mining, code
analysis, reverse engineering
specifically redesigned to identify potential aspect
candidates in software source code
by looking for symptoms of crosscutting concerns
(scattering, tangling, code duplication, ...)
Semi-automated: manual intervention required to
set thresholds, fine-tune filters to apply, ...
verify, select and complete reported results
8
9. Problems with aspect mining
Poor precision
(At different levels of granularity)
Poor recall
Subjectivity
Scalability
Empirical validation
Comparability
Composability
9
10. Consequence:
Levels of granularity - difficult to compare
- difficult to combine
- technique may not return what you look for
Make sure that you know what you are mining for
joinpoints = places in the code
that address a particular aspect
aspects = what aspects are
implemented in the source code
crosscutting sorts = all aspects
or concerns of a given kind
Different techniques may work at different levels of granularity
Example of aspects:
Example of joinpoints: Contract enforcement =
- change notification,
- all mutators that notify a listener The sort of all aspects that check a
synchronisation, logging
(“change notification aspects”) common condition for a set of methods.
Example of such an aspect; before
updating a view check whether it is
necessary to update. 10
11. Poor precision and poor recall
Precision = relevant candidates ÷ reported candidates
Poor precision => false positives => more user involvement
Recall = discovered aspects ÷ all aspects
Poor recall => false negatives => incomplete results
Hard to calculate
Recall is inversely correlated with precision
Poor precision or recall occurs at different levels of
granularity
11
12. Results marked with ‘M’ belong to the memory handling concer
References
only the lines marked with ‘C’ are included in the clone
s finding the code belonging to a cer- CCFinder allows clones to start and end with little Theme: t
1. Elisa Baniassad and Siobhan Clarke. regard
Example
ore, in our algorithm to select the clone syntactic units. In contrast, Bauhaus’ ccdiml does notand
An approach for aspect-oriented analysis allo
5), we favor coverage and sacrifice pre- design. In Proc. Int’l Conf. Software Engineer-
this, due to its AST-based clone detection algorithm. DC,
ing (ICSE), pages 158–167, Washington,
). Arguably, other goals require differ- USA, 2004. IEEE Computer Society Press.
he clone classes. For example, in order 2. Elisa Baniassad, Paul C. Clements, Joao
M C if (r != OK)
Araujo, Ana Moreira, Awais Rashid, and Bedir
ities for (automatic) refactoring, preci- MC{
Tekinerdogan. Discovering early aspects. IEEE
MC ERXA_LOG(r, 0, (quot;PLXAmem_malloc failure.quot;));
• 3 issue. detection techniques M C ERXA_LOG(VSXA_MEMORY_ERR, r, and Linda Northrop.
rimaryclone We plan to explore these Software, 23(1):61–70, January-February 2006.
ture. 3. Len Bass, Mark Klein,
MC
• 5 known aspects detectors MC (quot;%s: failed to allocated %d bytes.quot;,
Identifying aspects using architectural reason-
ate to what extent the clone M func_name, toread));
ing. Position paper presented at Early Aspects
vestigate the level of concern coverage M
• 16KLOC C code is the fraction
2004: Aspect-Oriented Requirements Engineer-
M r = VSXA_MEMORY_ERR;
ing and Architecture Design, Workshop of the
sses. Concern coverage M } 3rd Int’l Conf. Aspect-Oriented Software Devel-
e • Aspects manually annotated
code lines that are covered by the first opment (AOSD), 2004.
Figure 3. CCFinder Engelen, and Arie van Deursen, evalua-
4. Magiel Bruntink, Remco
by programmer clone covering memory erro
sses. Using the selection algorithm de- van Tom Tourw´. An
e
handling.
we obtain the results displayed in Fig- tion of clone detection techniques for identify-
• for Bauhaus’ ccdiml and CCFinder,
(b)Precision and recall compared ing crosscutting concerns. In Proc. Int’l Conf.
to manual annotations
Software Maintenance (ICSM), pages 200–209.
Furthermore this IEEE Computerdoes not cover memory e
clone class Society, 2004.
evaluate the precision obtained by the 5. Magiel Bruntink, Arie van Deursen, Remco van
ror handling code exclusively. Tom Figure On the note clone th
Engelen, and In 2(d), use of that
Technique: AS T Token Tourw´.
P D Ge
nique is relatively low. W hile as follows:
classes. Precision is defined this low pre- precision obtained for the firstidentifying cross is roughly 82%
detection for clone class cutting concern
Concern:
on is not a problemthis “ideal” case still
Even for in se, it does imply that code. IEEE Computer Society Trans. Software
Through inspection Engineering, .63we .81
Memory handling of the code
.65 31(10):804–818, 2005. some of th
found that
ect mining techniques tend to return a lot
concernLines(n)
alse positives, which can be detrimental to ->
n(n) = relatively poor precision
, clones do not cover M. Ceccato, error handling code Moonen, bu
Null pointer checking .99 .97 Marin, K. Mens, L. at all,
6. memory M. .80
totalLines(n)
code that checking at the syntacticalTourw´. yetmining tech-
Range is similar P. Tonella, and T. .42 e Applying and
.71 .59
ir scalability and ease-of-use. Especially for level, semantical
combining three different aspect
E xception handling .38 .36 .35
eniquesnthat returnclone classes, concern-
first selected a large number of results, different. niques. Software Quality Journal, 14(3):209–
Tracing .62 .57 .68
lack of precision can be problematic, since 231, September 2006.
mber of concern code lines covered by Table 1. A verage precision of K. Mens, and P. Tonella. A survey of
7. A. Kellens, each technique
ay require an important amount of user in- 6.2. Parameter Checking
clone classes, andthe false positives from
ement to separate likewise totalLines for each of the five concerns
automated code-level aspect mining techniques.12
13. Subjectivity and scalability
Subjectivity in interpretation of results
Filters, threshold values and blacklists configured by users
Ambiguity in interpretation of what is valid aspect candidate
“if it is part of the core functionality, it is not an aspect”
e.g. “Moving Figures” in JHotDraw
Scalability can be problematic due to user involvement
often many results to be validated / refined by user
looking for false positives / completing the aspect seeds
13
14. Evaluate, compare and combine
Empirical validation
no common benchmark
subjectivity in interpretation
results at different levels of detail and granularity
Comparability
how to compare the quality of mining techniques?
Composability
how to combine the results of different mining techniques?
14
15. Causes of the problems
Inappropriate techniques
Too general-purpose
Too strong assumptions
Too optimistic approaches
Scattering versus tangling
Lack of use of semantic information
Imprecise definition of what is an aspect
Inadequate representation of results
15
16. Aspect mining problems and causes
Inadeq.
Inappropriate techniques Imprecise
Cause repres. of
definition
too general too strong too optimistic no attention lack of use of
results
purpose assumptions approaches to tangling sem. info
Problem What can we learn from this table?
- - - - - -
poor precision
- - - -
poor recall
- - -
subjectivity
Poor precision negatively affects scalability: more user involv.
(-) (-) (-) (-) - (-)
scalability
- -
emp. valid.
- -
comparability Most causes Only this one
These three cause most problems
negatively affect seems specific
- -
either precision, recall
composability to aspects
or both
16
17. How to improve? (1)
Provide more rigourous definition of aspect
Dedicated mining techniques may be more successful than
general-purpose ‘one size fits all’ aspect mining techniques
Rely on semantics rather than on code structure
need for stable semantic foundation
Desired quality depends on purpose of mining
what is it that you want to do with the mined information?
initial understanding vs. migration towards aspects
17
18. How to improve? (2)
Leave room for variability
Look for counter-evidence
Look for symptoms of tangling
Choose adequate and uniform way of presenting the results
enough detail but not too much
Combine results of different techniques
Provide common framework to compare and evaluate mining
techniques
18
19. Conclusion
Most encountered pitfalls not specific to “aspect mining”
relevant to any discovery / reverse engineering process
especially present in aspect mining due to relative
immaturity of domain
potential for cross-fertilisation?
A word of warning
If you want to use aspect mining, don’t apply tools blindly
If you want to research aspect mining, still many research
opportunities but also a high risk of failure
19