Variability is omnipresent in numerous kinds of artefacts (e.g., source code, product matrices) and in different shapes (e.g., conditional compilation, differences among product descriptions). For understanding, reasoning about, maintaining or evolving variability, practitioners usually need an explicit encoding of variability (ie a variability model). As a result, numerous techniques have been developed to reverse engineer variability (e.g., through the mining of features and constraints from source code) or for migrating a set of products as a variability system. In this talk we will first present tool-supported techniques for synthesizing variability models from constraints or product descriptions.
Practitioners can build Boolean feature models with an interactive environment for selecting a meaningful and sound hierarchy.
Attributes can also be synthesized for encoding numerical values and constraints among them.
We will present key results we obtain through experiments with the SPLOT repository and product comparison matrices coming from Wikipedia and BestBuy.
Finally we will introduce OpenCompare.org a recent initiative for editing, reasoning, and mining product comparison matrices.
This talk has been done at REVE'15 workshop co-located with SPLC'15 (software product line conference): http://www.isse.jku.at/reve2015/program.html
R, Scikit-Learn and Apache Spark ML - What difference does it make?Villu Ruusmann
This document discusses different machine learning frameworks like R, Scikit-Learn, LightGBM, XGBoost, and Apache Spark ML and compares their capabilities for predictive modeling tasks. It highlights differences in how each framework handles data formats, parameter tuning, model serialization, and execution. It also presents a case study predicting car prices using gradient boosted trees in various frameworks and discusses lessons learned, emphasizing that ease-of-use and integration often outweigh raw performance.
iOS Development using Swift: Enums, ARC, Delegation, Closures, Table View and...Ahmed Ali
Learn iOS development using Swift (Arabic tutorials) - Fourth session slides, which covers the following topics:
- Enumerations
- Auto References Count (ARC)
- Delegation Pattern
- Closures
.
The video end up demonstrating: UITableView, performing segues programmatically, passing data between screens, and access information on iOS Documentation.
The document compares different approaches to implementing feature model composition through merge operators, including:
1. Separate feature models with intersection - Provides basic merging but lacks optimality in some cases.
2. AGG - Limited to union mode and struggles with non-trivial examples in intersection mode due to expressiveness limitations.
3. Kompose - Too restrictive due to two-stage local reasoning approach, making constraints and post-conditions difficult.
4. Kermeta - Provides better semantics than Kompose but still has issues with different hierarchies and constraints.
5. Boolean logic - Provides full expressiveness but lacks hierarchy and variability information on its own. An algorithm is needed to reconstruct feature models from
This document discusses software variability management. It begins by defining software variability as the ability of a software system or artifact to be efficiently extended, changed, customized or configured for a particular context. It then provides examples of variability in iOS and GCC versions. Next, it discusses challenges in managing copies of software with variability and advantages of software product lines. Key aspects of software product line engineering covered include commonalities and variabilities, product derivation, and an example of enterprise resource planning systems. The document concludes by summarizing feature modeling and variability realization techniques including feature models, binding times, and design patterns.
An overview of techniques for detecting software variability concepts in sour...Angela Lozano
The document discusses techniques for detecting software variability in source code. It describes key concepts related to variability including features, feature diagrams, mandatory vs optional features, and feature dependencies. It also discusses how mining source code can help identify variable features, variants selected by triggers, and feature dependencies. The document provides examples of how pre-processor directives in code specify selection of variants and notes triggers do not necessarily store the selection of a variant.
SiriusCon 2015 - Breathe Life into Your Designer!melbats
You have your shiny new DSL up and running thanks to the Eclipse Modeling Technologies and you built a powerful tooling with graphical modelers, textual syntaxes or dedicated editors to support it. But how can you see what is going on when a model is executed ? Don't you need to simulate your design in some way ? Wouldn't you want to see your editors being animated directly within your modeling environment based on execution traces or simulator results?
The GEMOC Research Project designed a methodology to bring animation and execution analysis to DSLs. The companion technologies required to put this in action are small dedicated components (all open-source) at a "proof of concept" maturity level extending proven components : Sirius, Eclipse Debug, Xtend making such features within the reach of Eclipse based tooling. The general intent regarding those OSS technologies is to leverage them within different contexts and contribute them to Eclipse once proven strong enough. The method covers a large spectrum of use cases from DSLs with a straightforward execution semantic to a combination of different DSLs with concurrent execution semantic. Any tool provider can leverage both the technologies and the method to provide an executable DSL and animated graphical modelers to its users enabling simulation and debugging at an early phase of the design.
This talk presents the approach, the technologies and demonstrate it through an example: providing Eclipse Debug integration and diagram animation capabilities for Arduino Designer (EPL) : setting breakpoints, stepping forward or backward in the execution, inspecting the variables states... We will walk you through the steps required to develop such features, the choices to make and the trade-offs involved. Expects live demos with simulated blinking leds and a virtual cat robot ! This talks presents also xCapella an industrial use case onwhich the Gemoc methodology was applied.
This talks was presented at SiriusCon 2015 in collaboration with Jérôme Le Noir from Thales.
The Arduino Designer documentation is available on : https://github.com/mbats/arduino/wiki/Documentation
This document summarizes a presentation on analyzing airport terminal effectiveness using multiple criteria and simulation optimization. It discusses modeling the terminal facilities planning problem (TFPP) as a discrete event simulation and multi-objective optimization problem. Specifically, it formulates the TFPP as a bi-criteria problem (2TFPP) to optimize configuration cost and average waiting time. It then describes solving the 2TFPP using a pre-computing phase to derive Pareto optimal solutions, followed by a decision-making phase where the decision maker selects the preferred solution based on their preferences.
R, Scikit-Learn and Apache Spark ML - What difference does it make?Villu Ruusmann
This document discusses different machine learning frameworks like R, Scikit-Learn, LightGBM, XGBoost, and Apache Spark ML and compares their capabilities for predictive modeling tasks. It highlights differences in how each framework handles data formats, parameter tuning, model serialization, and execution. It also presents a case study predicting car prices using gradient boosted trees in various frameworks and discusses lessons learned, emphasizing that ease-of-use and integration often outweigh raw performance.
iOS Development using Swift: Enums, ARC, Delegation, Closures, Table View and...Ahmed Ali
Learn iOS development using Swift (Arabic tutorials) - Fourth session slides, which covers the following topics:
- Enumerations
- Auto References Count (ARC)
- Delegation Pattern
- Closures
.
The video end up demonstrating: UITableView, performing segues programmatically, passing data between screens, and access information on iOS Documentation.
The document compares different approaches to implementing feature model composition through merge operators, including:
1. Separate feature models with intersection - Provides basic merging but lacks optimality in some cases.
2. AGG - Limited to union mode and struggles with non-trivial examples in intersection mode due to expressiveness limitations.
3. Kompose - Too restrictive due to two-stage local reasoning approach, making constraints and post-conditions difficult.
4. Kermeta - Provides better semantics than Kompose but still has issues with different hierarchies and constraints.
5. Boolean logic - Provides full expressiveness but lacks hierarchy and variability information on its own. An algorithm is needed to reconstruct feature models from
This document discusses software variability management. It begins by defining software variability as the ability of a software system or artifact to be efficiently extended, changed, customized or configured for a particular context. It then provides examples of variability in iOS and GCC versions. Next, it discusses challenges in managing copies of software with variability and advantages of software product lines. Key aspects of software product line engineering covered include commonalities and variabilities, product derivation, and an example of enterprise resource planning systems. The document concludes by summarizing feature modeling and variability realization techniques including feature models, binding times, and design patterns.
An overview of techniques for detecting software variability concepts in sour...Angela Lozano
The document discusses techniques for detecting software variability in source code. It describes key concepts related to variability including features, feature diagrams, mandatory vs optional features, and feature dependencies. It also discusses how mining source code can help identify variable features, variants selected by triggers, and feature dependencies. The document provides examples of how pre-processor directives in code specify selection of variants and notes triggers do not necessarily store the selection of a variant.
SiriusCon 2015 - Breathe Life into Your Designer!melbats
You have your shiny new DSL up and running thanks to the Eclipse Modeling Technologies and you built a powerful tooling with graphical modelers, textual syntaxes or dedicated editors to support it. But how can you see what is going on when a model is executed ? Don't you need to simulate your design in some way ? Wouldn't you want to see your editors being animated directly within your modeling environment based on execution traces or simulator results?
The GEMOC Research Project designed a methodology to bring animation and execution analysis to DSLs. The companion technologies required to put this in action are small dedicated components (all open-source) at a "proof of concept" maturity level extending proven components : Sirius, Eclipse Debug, Xtend making such features within the reach of Eclipse based tooling. The general intent regarding those OSS technologies is to leverage them within different contexts and contribute them to Eclipse once proven strong enough. The method covers a large spectrum of use cases from DSLs with a straightforward execution semantic to a combination of different DSLs with concurrent execution semantic. Any tool provider can leverage both the technologies and the method to provide an executable DSL and animated graphical modelers to its users enabling simulation and debugging at an early phase of the design.
This talk presents the approach, the technologies and demonstrate it through an example: providing Eclipse Debug integration and diagram animation capabilities for Arduino Designer (EPL) : setting breakpoints, stepping forward or backward in the execution, inspecting the variables states... We will walk you through the steps required to develop such features, the choices to make and the trade-offs involved. Expects live demos with simulated blinking leds and a virtual cat robot ! This talks presents also xCapella an industrial use case onwhich the Gemoc methodology was applied.
This talks was presented at SiriusCon 2015 in collaboration with Jérôme Le Noir from Thales.
The Arduino Designer documentation is available on : https://github.com/mbats/arduino/wiki/Documentation
This document summarizes a presentation on analyzing airport terminal effectiveness using multiple criteria and simulation optimization. It discusses modeling the terminal facilities planning problem (TFPP) as a discrete event simulation and multi-objective optimization problem. Specifically, it formulates the TFPP as a bi-criteria problem (2TFPP) to optimize configuration cost and average waiting time. It then describes solving the 2TFPP using a pre-computing phase to derive Pareto optimal solutions, followed by a decision-making phase where the decision maker selects the preferred solution based on their preferences.
The main body of work related to supporting dynamic languages on the JVM at Oracle today is done within the Nashorn project. While on the surface it looks like we're busy creating a JavaScript runtime, in reality JavaScript is only the beginning, and not the ultimate goal. Nashorn has served as the proving ground for new approaches for implementing a dynamic language on top of the JVM, and we're eager to – once solidified – crystallize these into a reusable dynamic language implementer's toolkit. We have faced challenges of optimally mapping JavaScript local variables to JVM types (or: "hey, there's a static type inference algorithm in your dynamic language compiler"), doing liveness analysis, cutting up methods too large to fit into a single JVM method, efficiently representing large array and object literals in compiled code, creating a system for on-demand compilation of several type-specialized variants of the same function, and more. Along the way, we have reached the limits of our initial internal representation (fun fact: you can't do liveness analysis on an AST. We learned it the hard way.) and started sketching up an intermediate representation that would be easy to emit from a dynamic language compiler, and that could be taken over by a toolchain to perform the operations described above then on it and finally output standard Java bytecode for JIT to take over. Elevator pitch: like LLVM, but for dynamic languages on the JVM.
Data Driven-Toyota Customer 360 Insights on Apache Spark and MLlib-(Brian Kur...Spark Summit
This document summarizes Toyota's use of Apache Spark for customer analytics. It discusses how Spark has helped Toyota improve the performance of customer experience analytics jobs from 160 hours to 4 hours. It also outlines Toyota's efforts to develop machine learning models in Spark for categorizing social media conversations. Specifically, it details the development of an SVM model for classifying conversations about brake noise, achieving over 80% accuracy. The document advocates for continuous improvement and shares lessons learned in working with Spark.
Fractional factorial designs (FFDs) are used to efficiently study many factors using fewer experimental runs than a full factorial design. FFDs exploit redundancy in estimating interactions to select a subset of runs. Regular FFDs have desirable properties like balance and orthogonality. Resolution indicates how interactions are aliased, with higher resolutions preferred. FFDs are useful in screening experiments to identify important factors efficiently before further optimization. Software helps select appropriate FFDs based on desired resolution and aliasing.
From System Modeling to Automated System TestingFlorian Lier
Often, high-level (functional) tests are carried out manually, implementing a tailored solution, e.g, via shell scripts
or launch files, for a specific system setup. Besides the effort of manual execution and supervision, current tests mostly do not take timing and orchestration, i.e., required process start-up sequence, into account. Furthermore, successful execution of components is not verified, which might lead to subsequent errors during the execution chain. Most importantly, all this knowledge about the test and its environment is implicit, often hidden in the actual implementation of the tailored test suite. To overcome these issues, this contribution introduces a generic and configurable state-machine based process.
Fortran & Link with Library & Brief Explanation of MKL BLASJongsu "Liam" Kim
This document discusses Fortran programming best practices and features. It recommends avoiding labeled DO loops, EQUIVALENCE, and COMMON blocks due to errors and complexity. Instead, it suggests using CYCLE and EXIT statements, WHERE constructs, and DO CONCURRENT for vectorization. The document also covers sparse matrix storage formats and using Intel MKL and BLAS routines for linear algebra operations.
This document discusses machine learning concepts and techniques for categorization, popularity, and sequence labeling. It introduces linear models, decision trees, ensemble methods, and evaluation metrics. The document aims to provide a self-contained tutorial and explain the notation used. It outlines examples of machine learning applications and discusses encoding objects with features, the machine learning framework, and specific techniques like perceptrons, logistic regression, decision trees, boosting, and hidden Markov models.
Inheritance - the myth of code reuse | Andrei Raifura | CodeWay 2015YOPESO
Watch this presentation if you want to know why inheritance is not always the most appropriate method for code reuse - and what to do instead.
Watch the video here:
https://www.youtube.com/watch?v=H6m0W-eDyAk
The code used for the demo:
https://github.com/yopeso/Inheritance
Knowledge Engineering rediscovered, Towards Reasoning Patterns for the Semant...Frank van Harmelen
We show how it is possible to apply the problem solving patterns from knowledge engineering to systems developed on the semantic web. This give us re-usable problem solving patterns for the semantic web, and would greatly help us to build and understand such systems.
Yandex School of Data Analysis conference, Machine Learning and Very Large Da...Илья Трофимов
This document discusses machine learning techniques for click-through rate prediction in online advertising. It describes using a composition of boosted decision trees and logistic regression with L1-regularization to model clicks based on 54 real-valued and 3.4 million binary features extracted from user search sessions. The model was trained on 67 million examples and tested on 5 million examples, achieving improved accuracy over alternative methods. Keywords that increased or decreased the probability of a click were also presented.
The document provides security tips and best practices for building web applications in Go. It discusses Go's type system, concurrency model, and standard library features. It also summarizes common vulnerabilities like SQL injection and XSS, and recommends using parameterized queries and HTML escaping to prevent them. Finally, it highlights tools like Gorilla and Gin web frameworks, and techniques like rate limiting and secure cookies to build secure Go applications.
Towards Domain Refinement for UML/OCL Bounded Verificationrclariso
Correctness of UML class diagrams annotated with OCL constraints can be checked using bounded verication, e.g. SAT solvers. Bounded verication detects faults efficiently but, on the other hand, the absence of faults does not guarantee a correct behavior outside the bounded domain. Hence, choosing suitable bounds is a non-trivial process as there is a trade-o between the verication time (faster for smaller domains) and the condence in the result (better for larger domains).
Unfortunately, existing tools provide little support in this choice.This paper presents a technique that can be used to (i) automatically infer verication bounds whenever possible, (ii) tighten a set of bounds proposed by the user and (iii) guide the user in the bound selection process. This approach may increase the usability of UML/OCL bounded verification tools and improve the efficiency of the verification process.
Presented in SEFM 2015 (13h International Conference on Software Engineering and Formal Methods, 8-11 Sept 2015, York, UK). Work co-authored with Carlos A. González and Jordi Cabot.
Generators take a high-level software specification and produce an implementation. GenVoca is an approach to building generators that composes reusable component layers. It models software as realms of components with vertical and horizontal parameters. Components are implemented as C++ templates containing member classes. Composition validation ensures semantics are correct. Aspect-oriented programming (AOP) and GenVoca both aim to improve code reuse but differ in focus, concepts, and implementation mechanisms like aspect languages versus type expressions. Generators automate implementation through transformations while GenVoca provides a systematic approach through composable and customizable components.
Generators take a high-level software specification and produce an implementation. GenVoca is an approach to building generators that composes reusable component layers. It models software as realms of components with vertical and horizontal parameters. Components are implemented as C++ templates containing member classes. Composition validation ensures semantics are correct. Aspect-oriented programming (AOP) and GenVoca both promote code reuse but differ in focus, concepts, and implementation mechanisms like aspect languages versus type expressions. Generators automate implementation through transformations while GenVoca provides a systematic approach through composable, standardized components.
The first lecture of the ACM Aleppo CPC training. The local contest of ICPC. This lecture will help you get started in programming contests word with the lower bound techniques. The lectures focus on the C++ programming language and the STL library to solve programming problems.
Feature Models (FMs) are the de-facto standard for documenting, model checking, and reasoning about the configurations of a software system. This paper introduces WebFML a comprehensive environment for synthesizing FMs from various kinds of artefacts (e.g. propositional formula, dependency graph, FMs or product comparison matrices). A key feature of WebFML is an interactive support (through ranking lists, clusters, and logical heuristics) for choosing a sound and meaningful hierarchy. WebFML opens avenues for numerous practical applications (e.g., merging multiple product lines, slicing a configuration process, reverse engineering configurable systems).
tinyurl.com/WebFMLDemo
TMPA-2017: Tools and Methods of Program Analysis
3-4 March, 2017, Hotel Holiday Inn Moscow Vinogradovo, Moscow
Vellvm - Verifying the LLVM
Steve Zdancewic (Professor, USA University of Pennsylvania)
For video follow the link: https://youtu.be/jDPAtUfnoBU
Would like to know more?
Visit our website:
www.tmpaconf.org
www.exactprosystems.com/events/tmpa
Follow us:
https://www.linkedin.com/company/exactpro-systems-llc?trk=biz-companies-cym
https://twitter.com/exactpro
Artificial Intelligence and Optimization with ParallelismOlivier Teytaud
This document discusses parallelism in artificial intelligence and evolutionary computation. It explains that comparison-based optimization algorithms, which include many evolutionary algorithms, can be naturally parallelized by speculatively running multiple branches in parallel with a branching factor of 3 or more. This allows theoretical logarithmic speedups to be achieved in practice through simple parallelization tricks.
This document outlines the basics of C++ programming, including:
- The history and evolution of C++ and other programming languages.
- How a C++ source code is compiled into an executable program by the compiler in multiple steps like preprocessing, compiling, linking etc.
- The structure of a basic C++ program and key elements like main function, headers, comments.
- How to use input/output streams, variables, arithmetic operations, and conditional statements like if-else in a C++ program.
This document discusses machine learning projects in Go. It begins by explaining what machine learning is and provides an example of linear regression. It then outlines the typical steps for a machine learning project, including gathering data, defining models, training and testing models, and deploying models. The document discusses options for developing machine learning models in Go, including using TensorFlow bindings, Gorgonia for building graphs, and Gonum libraries. It provides examples of implementing convolutional neural networks and recurrent neural networks in these Go frameworks. While developing neural networks from scratch in Go is challenging, the document concludes that Go is suitable for machine learning if using existing TensorFlow models or libraries like Gorgonia and Gonum for other model types.
The ability to recreate computational results with minimal effort and actionable metrics provides a solid foundation for scientific research and software development. When people can replicate an analysis at the touch of a button using open-source software, open data, and methods to assess and compare proposals, it significantly eases verification of results, engagement with a diverse range of contributors, and progress. However, we have yet to fully achieve this; there are still many sociotechnical frictions.
Inspired by David Donoho's vision, this talk aims to revisit the three crucial pillars of frictionless reproducibility (data sharing, code sharing, and competitive challenges) with the perspective of deep software variability.
Our observation is that multiple layers — hardware, operating systems, third-party libraries, software versions, input data, compile-time options, and parameters — are subject to variability that exacerbates frictions but is also essential for achieving robust, generalizable results and fostering innovation. I will first review the literature, providing evidence of how the complex variability interactions across these layers affect qualitative and quantitative software properties, thereby complicating the reproduction and replication of scientific studies in various fields.
I will then present some software engineering and AI techniques that can support the strategic exploration of variability spaces. These include the use of abstractions and models (e.g., feature models), sampling strategies (e.g., uniform, random), cost-effective measurements (e.g., incremental build of software configurations), and dimensionality reduction methods (e.g., transfer learning, feature selection, software debloating).
I will finally argue that deep variability is both the problem and solution of frictionless reproducibility, calling the software science community to develop new methods and tools to manage variability and foster reproducibility in software systems.
Exposé invité Journées Nationales du GDR GPL 2024
Producing a variant of code is highly challenging, particularly for individuals unfamiliar with programming. This demonstration introduces a novel use of generative AI to aid end-users in customizing code. We first describe how generative AI can be used to customize code through prompts and instructions, and further demonstrate its potential in building end-user tools for configuring code. We showcase how to transform an undocumented, technical, low-level TikZ into a user-friendly, configurable, Web-based customization tool written in Python, HTML, CSS, and JavaScript and itself configurable. We discuss how generative AI can support this transformation process and traditional variability engineering tasks, such as identification and implementation of features, synthesis of a template code generator, and development of end-user configurators. We believe it is a first step towards democratizing variability programming, opening a path for end-users to adapt code to their needs.
More Related Content
Similar to From Basic Variability Models to OpenCompare.org
The main body of work related to supporting dynamic languages on the JVM at Oracle today is done within the Nashorn project. While on the surface it looks like we're busy creating a JavaScript runtime, in reality JavaScript is only the beginning, and not the ultimate goal. Nashorn has served as the proving ground for new approaches for implementing a dynamic language on top of the JVM, and we're eager to – once solidified – crystallize these into a reusable dynamic language implementer's toolkit. We have faced challenges of optimally mapping JavaScript local variables to JVM types (or: "hey, there's a static type inference algorithm in your dynamic language compiler"), doing liveness analysis, cutting up methods too large to fit into a single JVM method, efficiently representing large array and object literals in compiled code, creating a system for on-demand compilation of several type-specialized variants of the same function, and more. Along the way, we have reached the limits of our initial internal representation (fun fact: you can't do liveness analysis on an AST. We learned it the hard way.) and started sketching up an intermediate representation that would be easy to emit from a dynamic language compiler, and that could be taken over by a toolchain to perform the operations described above then on it and finally output standard Java bytecode for JIT to take over. Elevator pitch: like LLVM, but for dynamic languages on the JVM.
Data Driven-Toyota Customer 360 Insights on Apache Spark and MLlib-(Brian Kur...Spark Summit
This document summarizes Toyota's use of Apache Spark for customer analytics. It discusses how Spark has helped Toyota improve the performance of customer experience analytics jobs from 160 hours to 4 hours. It also outlines Toyota's efforts to develop machine learning models in Spark for categorizing social media conversations. Specifically, it details the development of an SVM model for classifying conversations about brake noise, achieving over 80% accuracy. The document advocates for continuous improvement and shares lessons learned in working with Spark.
Fractional factorial designs (FFDs) are used to efficiently study many factors using fewer experimental runs than a full factorial design. FFDs exploit redundancy in estimating interactions to select a subset of runs. Regular FFDs have desirable properties like balance and orthogonality. Resolution indicates how interactions are aliased, with higher resolutions preferred. FFDs are useful in screening experiments to identify important factors efficiently before further optimization. Software helps select appropriate FFDs based on desired resolution and aliasing.
From System Modeling to Automated System TestingFlorian Lier
Often, high-level (functional) tests are carried out manually, implementing a tailored solution, e.g, via shell scripts
or launch files, for a specific system setup. Besides the effort of manual execution and supervision, current tests mostly do not take timing and orchestration, i.e., required process start-up sequence, into account. Furthermore, successful execution of components is not verified, which might lead to subsequent errors during the execution chain. Most importantly, all this knowledge about the test and its environment is implicit, often hidden in the actual implementation of the tailored test suite. To overcome these issues, this contribution introduces a generic and configurable state-machine based process.
Fortran & Link with Library & Brief Explanation of MKL BLASJongsu "Liam" Kim
This document discusses Fortran programming best practices and features. It recommends avoiding labeled DO loops, EQUIVALENCE, and COMMON blocks due to errors and complexity. Instead, it suggests using CYCLE and EXIT statements, WHERE constructs, and DO CONCURRENT for vectorization. The document also covers sparse matrix storage formats and using Intel MKL and BLAS routines for linear algebra operations.
This document discusses machine learning concepts and techniques for categorization, popularity, and sequence labeling. It introduces linear models, decision trees, ensemble methods, and evaluation metrics. The document aims to provide a self-contained tutorial and explain the notation used. It outlines examples of machine learning applications and discusses encoding objects with features, the machine learning framework, and specific techniques like perceptrons, logistic regression, decision trees, boosting, and hidden Markov models.
Inheritance - the myth of code reuse | Andrei Raifura | CodeWay 2015YOPESO
Watch this presentation if you want to know why inheritance is not always the most appropriate method for code reuse - and what to do instead.
Watch the video here:
https://www.youtube.com/watch?v=H6m0W-eDyAk
The code used for the demo:
https://github.com/yopeso/Inheritance
Knowledge Engineering rediscovered, Towards Reasoning Patterns for the Semant...Frank van Harmelen
We show how it is possible to apply the problem solving patterns from knowledge engineering to systems developed on the semantic web. This give us re-usable problem solving patterns for the semantic web, and would greatly help us to build and understand such systems.
Yandex School of Data Analysis conference, Machine Learning and Very Large Da...Илья Трофимов
This document discusses machine learning techniques for click-through rate prediction in online advertising. It describes using a composition of boosted decision trees and logistic regression with L1-regularization to model clicks based on 54 real-valued and 3.4 million binary features extracted from user search sessions. The model was trained on 67 million examples and tested on 5 million examples, achieving improved accuracy over alternative methods. Keywords that increased or decreased the probability of a click were also presented.
The document provides security tips and best practices for building web applications in Go. It discusses Go's type system, concurrency model, and standard library features. It also summarizes common vulnerabilities like SQL injection and XSS, and recommends using parameterized queries and HTML escaping to prevent them. Finally, it highlights tools like Gorilla and Gin web frameworks, and techniques like rate limiting and secure cookies to build secure Go applications.
Towards Domain Refinement for UML/OCL Bounded Verificationrclariso
Correctness of UML class diagrams annotated with OCL constraints can be checked using bounded verication, e.g. SAT solvers. Bounded verication detects faults efficiently but, on the other hand, the absence of faults does not guarantee a correct behavior outside the bounded domain. Hence, choosing suitable bounds is a non-trivial process as there is a trade-o between the verication time (faster for smaller domains) and the condence in the result (better for larger domains).
Unfortunately, existing tools provide little support in this choice.This paper presents a technique that can be used to (i) automatically infer verication bounds whenever possible, (ii) tighten a set of bounds proposed by the user and (iii) guide the user in the bound selection process. This approach may increase the usability of UML/OCL bounded verification tools and improve the efficiency of the verification process.
Presented in SEFM 2015 (13h International Conference on Software Engineering and Formal Methods, 8-11 Sept 2015, York, UK). Work co-authored with Carlos A. González and Jordi Cabot.
Generators take a high-level software specification and produce an implementation. GenVoca is an approach to building generators that composes reusable component layers. It models software as realms of components with vertical and horizontal parameters. Components are implemented as C++ templates containing member classes. Composition validation ensures semantics are correct. Aspect-oriented programming (AOP) and GenVoca both aim to improve code reuse but differ in focus, concepts, and implementation mechanisms like aspect languages versus type expressions. Generators automate implementation through transformations while GenVoca provides a systematic approach through composable and customizable components.
Generators take a high-level software specification and produce an implementation. GenVoca is an approach to building generators that composes reusable component layers. It models software as realms of components with vertical and horizontal parameters. Components are implemented as C++ templates containing member classes. Composition validation ensures semantics are correct. Aspect-oriented programming (AOP) and GenVoca both promote code reuse but differ in focus, concepts, and implementation mechanisms like aspect languages versus type expressions. Generators automate implementation through transformations while GenVoca provides a systematic approach through composable, standardized components.
The first lecture of the ACM Aleppo CPC training. The local contest of ICPC. This lecture will help you get started in programming contests word with the lower bound techniques. The lectures focus on the C++ programming language and the STL library to solve programming problems.
Feature Models (FMs) are the de-facto standard for documenting, model checking, and reasoning about the configurations of a software system. This paper introduces WebFML a comprehensive environment for synthesizing FMs from various kinds of artefacts (e.g. propositional formula, dependency graph, FMs or product comparison matrices). A key feature of WebFML is an interactive support (through ranking lists, clusters, and logical heuristics) for choosing a sound and meaningful hierarchy. WebFML opens avenues for numerous practical applications (e.g., merging multiple product lines, slicing a configuration process, reverse engineering configurable systems).
tinyurl.com/WebFMLDemo
TMPA-2017: Tools and Methods of Program Analysis
3-4 March, 2017, Hotel Holiday Inn Moscow Vinogradovo, Moscow
Vellvm - Verifying the LLVM
Steve Zdancewic (Professor, USA University of Pennsylvania)
For video follow the link: https://youtu.be/jDPAtUfnoBU
Would like to know more?
Visit our website:
www.tmpaconf.org
www.exactprosystems.com/events/tmpa
Follow us:
https://www.linkedin.com/company/exactpro-systems-llc?trk=biz-companies-cym
https://twitter.com/exactpro
Artificial Intelligence and Optimization with ParallelismOlivier Teytaud
This document discusses parallelism in artificial intelligence and evolutionary computation. It explains that comparison-based optimization algorithms, which include many evolutionary algorithms, can be naturally parallelized by speculatively running multiple branches in parallel with a branching factor of 3 or more. This allows theoretical logarithmic speedups to be achieved in practice through simple parallelization tricks.
This document outlines the basics of C++ programming, including:
- The history and evolution of C++ and other programming languages.
- How a C++ source code is compiled into an executable program by the compiler in multiple steps like preprocessing, compiling, linking etc.
- The structure of a basic C++ program and key elements like main function, headers, comments.
- How to use input/output streams, variables, arithmetic operations, and conditional statements like if-else in a C++ program.
This document discusses machine learning projects in Go. It begins by explaining what machine learning is and provides an example of linear regression. It then outlines the typical steps for a machine learning project, including gathering data, defining models, training and testing models, and deploying models. The document discusses options for developing machine learning models in Go, including using TensorFlow bindings, Gorgonia for building graphs, and Gonum libraries. It provides examples of implementing convolutional neural networks and recurrent neural networks in these Go frameworks. While developing neural networks from scratch in Go is challenging, the document concludes that Go is suitable for machine learning if using existing TensorFlow models or libraries like Gorgonia and Gonum for other model types.
Similar to From Basic Variability Models to OpenCompare.org (20)
The ability to recreate computational results with minimal effort and actionable metrics provides a solid foundation for scientific research and software development. When people can replicate an analysis at the touch of a button using open-source software, open data, and methods to assess and compare proposals, it significantly eases verification of results, engagement with a diverse range of contributors, and progress. However, we have yet to fully achieve this; there are still many sociotechnical frictions.
Inspired by David Donoho's vision, this talk aims to revisit the three crucial pillars of frictionless reproducibility (data sharing, code sharing, and competitive challenges) with the perspective of deep software variability.
Our observation is that multiple layers — hardware, operating systems, third-party libraries, software versions, input data, compile-time options, and parameters — are subject to variability that exacerbates frictions but is also essential for achieving robust, generalizable results and fostering innovation. I will first review the literature, providing evidence of how the complex variability interactions across these layers affect qualitative and quantitative software properties, thereby complicating the reproduction and replication of scientific studies in various fields.
I will then present some software engineering and AI techniques that can support the strategic exploration of variability spaces. These include the use of abstractions and models (e.g., feature models), sampling strategies (e.g., uniform, random), cost-effective measurements (e.g., incremental build of software configurations), and dimensionality reduction methods (e.g., transfer learning, feature selection, software debloating).
I will finally argue that deep variability is both the problem and solution of frictionless reproducibility, calling the software science community to develop new methods and tools to manage variability and foster reproducibility in software systems.
Exposé invité Journées Nationales du GDR GPL 2024
Producing a variant of code is highly challenging, particularly for individuals unfamiliar with programming. This demonstration introduces a novel use of generative AI to aid end-users in customizing code. We first describe how generative AI can be used to customize code through prompts and instructions, and further demonstrate its potential in building end-user tools for configuring code. We showcase how to transform an undocumented, technical, low-level TikZ into a user-friendly, configurable, Web-based customization tool written in Python, HTML, CSS, and JavaScript and itself configurable. We discuss how generative AI can support this transformation process and traditional variability engineering tasks, such as identification and implementation of features, synthesis of a template code generator, and development of end-user configurators. We believe it is a first step towards democratizing variability programming, opening a path for end-users to adapt code to their needs.
Slides presented at MODEVAR 2024 co-located with VaMoS 2024: https://modevar.github.io/program/ Thanks to Jessie Galasso and Chico Sundermann for the invitation Abstract: "Variability models (e.g., feature models) are widely considered in software engineering research and practice, in order to develop software product lines, configurable systems, generators, or adaptive systems. Numerous success stories of variability models have been reported in different domains (e.g., automotive, aerospace, avionics) and the applicability broadens. However, the use of variability models is not yet universally adopted… Why? Some examples: variability models are not continuously extracted from projects and artefacts; each time a variability model is used, its expressiveness and language should be specialized; learning-based models are decoupled from variability models; modeling software variability should cover different layers and their interactions, etc. The list is arguably opinionated, incomplete, and based on my own practical experience, but also on observations of existing works. I will give 24 reasons to occupy your day as a researcher or practitioner in the field of variability modeling."
Slides: https://github.com/acherm/24RWVMANYU-VaMoS-MODEVAR/blob/main/vamos2024.md (Markdown content) PDF: https://github.com/acherm/24RWVMANYU-VaMoS-MODEVAR/blob/main/VaMoS2024-MODEVAR.pdf (slides in PDF format)
Programming variability is central to the design and implementation of software systems that can adapt to a variety of contexts and requirements, providing increased flexibility and customization. Managing the complexity that arises from having multiple features, variations, and possible configurations is known to be highly challenging for software developers. In this paper, we explore how large language model (LLM)-based assistants can support the programming of variability. We report on new approaches made possible with LLM-based assistants, like: features and variations can be implemented as prompts; augmentation of variability out of LLM-based domain knowledge; seamless implementation of variability in different kinds of artefacts, programming languages, and frameworks, at different binding times (compile-time or run-time). We are sharing our data (prompts, sessions, generated code, etc.) to support the assessment of the effectiveness and robustness of LLMs for variability-related tasks.
https://inria.hal.science/hal-04153310/
The migration and reengineering of existing variants into a software product line (SPL) is an error-prone and time-consuming activity. Many extractive approaches have been proposed, spanning different activities from feature identification and naming to the synthesis of reusable artefacts. In this paper, we explore how large language model (LLM)-based assistants can support domain analysts and developers. We revisit four illustrative cases of the literature where the challenge is to migrate variants written in different formalism (UML class diagrams, Java, GraphML, statecharts). We systematically report on our experience with ChatGPT-4, describing our strategy to prompt LLMs and documenting positive aspects but also failures. We compare the use of LLMs with state-of-the-art approach, BUT4Reuse. While LLMs offer potential in assisting domain analysts and developers in transitioning software variants into SPLs, their intrinsic stochastic nature and restricted ability to manage large variants or complex structures necessitate a semiautomatic approach, complete with careful review, to counteract inaccuracies.
The document discusses deep software variability and the challenges of predicting software performance across different configuration layers. It provides an example of measuring the video encoder x264 across different hardware platforms, operating systems, compiler options, and input video files. The key points are that software performance prediction models may not generalize if they do not account for variability across these different layers. The document calls for more empirical studies of deep software variability in real-world systems to better understand how it manifests and which layers have the most influence. This knowledge could help reduce costs when exploring configuration spaces and transferring performance models between environments.
talk @ DiverSE coffee (informal, work in progress)
abstract: Cheating in chess is a serious issue, mainly due to the use of chess engines during play.
Chess engines like Stockfish or AlphaZero-like variant can give to the cheater a decisive advantage, since almost perfect moves can be played.
Already in 2006, Topalov accused Kramnik as part of the world championship.
Sébastien Feller https://en.wikipedia.org/wiki/S%C3%A9bastien_Feller case in Chess Olympiad in 2010 was a shock.
With the rise of online games and $$$, cheating is even more problematic.
A few weeks ago, Magnus Carlsen https://en.wikipedia.org/wiki/Magnus_Carlsen accused Hans Niemann (HN) of cheating over the board and refused to ever play him again.
You may have heard headlines with "anal bead" supposed to help HN.
In fact, I'm not specifically aiming to talk about chess (and cheating).
I rather want to discuss how science has been (and will be) at the heart of the anti-cheating chess problem.
I will first argue that many people (chess hobbyists/experts, data nerds, etc.), most being non-scientists, have actually done science for trying to demonstrate or refute the cheating case.
The basic idea is to confront moves played by humans (players) with those of computer engines.
With the sharing of data (analysis of chess games like those played by HN), scripts, and methods, numerous results and conclusions have emerged, getting popularized with social media (twitch, Youtube, twitter, etc.)
On the one hand, I've been quite excited to see all this energy for trying to advance our understanding and propose interesting ideas/analysis.
On the other hand, there have been some failures in the quality of some analysis or the choice of closed systems to compute unclear metrics.
In-between, there have been a report by chess.com and the analysis of the computer scientist Ken Regan https://cse.buffalo.edu/~regan/ the world renewed specialist.
I still think the problem is open (eg Regan's method is too conservative and missing many cases; chess.com methodology, though unclear and opaque at some points, is certainly effective for online cheating, but not over the board detection).
I will present a variability model of the space of experiments/methods that can be considered to address the problem.
This model can be used to pilot the collaborative effort, to reproduce, replicate or reject some experiments, and to gain confidence or robustness in some conclusions.
Another last point I want to discuss is that most probably the anti-cheating chess problem cannot be resolved solely with retrospective computational analysis.
It's just too uncertain, especially if cheaters are "smart".
(Cyber-)security experts, psychologists, chess players, and of course computer science nerds/professionals can contribute to address this multidisciplinary problem.
preprint: https://hal.inria.fr/hal-03720273
presented at SPLC 2022 research track
Linux kernels are used in a wide variety of appliances, many of them having strong requirements on the kernel size due to constraints such as limited memory or instant boot. With more than nine thousands of configuration options to choose from, developers and users of Linux actually spend significant effort to document, understand, and eventually tune (combinations of) options for meeting a kernel size. In this paper, we describe a large-scale endeavour automating this task and predicting a given Linux kernel binary size out of unmeasured configurations. We first experiment that state-of-theart solutions specifically made for configurable systems such as performance-influence models cannot cope with that number of options, suggesting that software product line techniques may need to be adapted to such huge configuration spaces. We then show that tree-based feature selection can learn a model achieving low prediction errors over a reduced set of options. The resulting model, trained on 95 854 kernel configurations, is fast to compute, simple to interpret and even outperforms the accuracy of learning without feature selection.
Keynote VariVolution/VM4ModernTech@SPLC 2022
At compile-time or at runtime, varying software is a powerful means to achieve optimal functional and performance goals. An observation is that only considering the software layer might be naive to tune the performance of the system or test that the functionality behaves correctly. In fact, many layers (hardware, operating system, input data, build process etc.), themselves subject to variability, can alter performances of software configurations. For instance, configurations' options may have very different effects on execution time or energy consumption when used with different input data, depending on the way it has been compiled and the hardware on which it is executed.
In this talk, I will introduce the concept of “deep software variability” which refers to the interactions of all external layers modifying the behavior or non-functional properties of a software system. I will show how compile-time options, inputs, and software evolution (versions), some dimensions of deep variability, can question the generalization of the variability knowledge of popular configurable systems like Linux, gcc, xz, or x264.
I will then argue that machine learning (ML) is particularly suited to manage very large variants space. The key idea of ML is to build a model based on sample data -- here observations about software variants in variable settings -- in order to make predictions or decisions. I will review state-of-the-art solutions developed in software engineering and software product line engineering while connecting with works in ML (e.g., transfer learning, dimensionality reduction, adversarial learning). Overall, the key challenge is to leverage the right ML pipeline in order to harness all variability layers (and not only the software layer), leading to more efficient systems and variability knowledge that truly generalizes to any usage and context.
From this perspective, we are starting an initiative to collect data, software, reusable artefacts, and body of knowledge related to (deep) software variability: https://deep.variability.io
Finally, I will open a broader discussion on how machine learning and deep software variability relate to the reproducibility, replicability, and robustness of scientific, software-based studies (e.g., in neuroimaging and climate modelling).
Software has eaten the world and will continue to impact society, spanning numerous application domains, including the way we're doing science and acquiring knowledge.
Software variability is key since developers, engineers, entrepreneurs, scientists can explore different hypothesis, methods, and custom products to hopefully fit a diversity of needs and usage.
In this talk, I will first illustrate the importance of software variability using different concrete examples.
I will then show that, though highly desirable, software variability also introduces an enormous complexity due to the combinatorial explosion of possible variants.
For example, 10^6000 variants of the Linux kernel may be build, much more than the estimated number of atoms in the universe (10^80).
Hence, the big picture and challenge for the audience: any organization capable of mastering software variability will have a competitive advantage.
Summer School EIT Digital.
5th July Rennes 2022
With large scale and complex configurable systems, it is hard for users to choose the right combination of options (i.e., configurations) in order to obtain the wanted trade-off between functionality and performance goals such as speed or size. Machine learning can help in relating these goals to the configurable system options, and thus, predict the effect of options on the outcome, typically after a costly training step. However, many configurable systems evolve at such a rapid pace that it is impractical to retrain a new model from scratch for each new version. In this paper, we propose a new method to enable transfer learning of binary size predictions among versions of the same configurable system. Taking the extreme case of the Linux kernel with its ≈ 14, 500 configuration options, we first investigate how binary size predictions of kernel size degrade over successive versions. We show that the direct reuse of an accurate prediction model from 2017 quickly becomes inaccurate when Linux evolves, up to a 32% mean error by August 2020. We thus propose a new approach for transfer evolution-aware model shifting (TEAMS). It leverages the structure of a configurable system to transfer an initial predictive model towards its future versions with a minimal amount of extra processing for each version. We show that TEAMS vastly outperforms state of the art approaches over the 3 years history of Linux kernels, from 4.13 to 5.8.
Biology, medicine, physics, astrophysics, chemistry: all these scientific domains need to process large amount of data with more and more complex software systems. For achieving reproducible science, there are several challenges ahead involving multidisciplinary collaboration and socio-technical innovation with software at the center of the problem. Despite the availability of data and code, several studies report that the same data analyzed with different software can lead to different results. I am seeing this problem as a manifestation of deep software variability: many factors (operating system, third-party libraries, versions, workloads, compile-time options and flags, etc.) themselves subject to variability can alter the results, up to the point it can dramatically change the conclusions of some scientific studies. In this keynote, I argue that deep software variability is a threat and also an opportunity for reproducible science. I first outline some works about (deep) software variability, reporting on preliminary evidence of complex interactions between variability layers. I then link the ongoing works on variability modelling and deep software variability in the quest for reproducible science.
Most modern software systems are subject to variation or come in many variants. Web browsers like Firefox or Chrome are available on different operating systems, in different languages, while users can configure 2000+ preferences or install numerous 3rd parties extensions (or plugins). Web servers like Apache, operating systems like the Linux kernel, or a video encoder like x264 are other examples of software systems that are highly configurable at compile-time or at run-time for delivering the expected functionality andmeeting the various desires of users. Variability ("the ability of a software system or artifact to be efficiently extended, changed,customized or configured for use in a particular context") is therefore a crucial property of software systems. Organizations capable of mastering variability can deliver high-quality variants (or products) in a short amount of time and thus attract numerous customers, new use-cases or usage contexts. A hard problem for end-users or software developers is to master the combinatorial explosion induced by variability: Hundreds of configuration options can be combined, each potentially with distinct functionality and effects on execution time, memory footprint, quality of the result, etc. The first part of this course will introduce variability-intensive systems, their applications and challenges, in various software contexts. We will use intuitive examples (like a generator of LaTeX paper variants) and real-world systems (like the Linux kernel). A second objective of this course is to show the relevance of ArtificialIntelligence (AI) techniques for exploring and taming such enormous variability spaces. In particular, we will introduce how (1) satisfiability and constraint programming solvers can be used to properly model and reason about variability; (2) how machine learning can be used to discover constraints and predict the variability behavior of configurable systems or software product lines.
http://ejcp2019.icube.unistra.fr/
Presented at SIGCSE 2018: https://sigcse2018.sigcse.org/
Software Product Line (SPL) engineering has emerged to provide the means to efficiently model, produce, and maintain multiple similar software variants, exploiting their common properties, and managing their variabilities (differences). With over two decades of existence, the community of SPL researchers and practitioners is thriving as can be attested by the extensive research output and the numerous successful industrial projects. Education has a key role to support the next generation of practitioners to build highly complex, variability-intensive systems. Yet, it is unclear how the concepts of variability and SPLs are taught, what are the possible missing gaps and difficulties faced, what are the benefits, or what is the material available. Also, it remains unclear whether scholars teach what is actually needed by industry. In this article we report on three initiatives we have conducted with scholars, educators, industry practitioners, and students to further understand the connection between SPLs and education, i.e., an online survey on teaching SPLs we performed with 35 scholars, another survey on learning SPLs we conducted with 25 students, as well as two workshops held at the International Software Product Line Conference in 2014 and 2015 with both researchers and industry practitioners participating. We build upon the two surveys and the workshops to derive recommendations for educators to continue improving the state of practice of teaching SPLs, aimed at both individual educators as well as the wider community.
This document proposes exploiting the enumeration of all configurations of a feature model as a new perspective for automated reasoning with distributed computing. It discusses (1) enumerating configurations in parallel to improve scalability, (2) pre-compiling configurations offline to speed up costly operations like counting, core, and dead features, and (3) how the approach is not always best and depends on the feature model, operation, and time requirements. Preliminary evaluations show the approach is more efficient for large models but not always, and future work is needed to determine when enumeration is best versus traditional solvers.
Product Derivation is a key activity in Software Product Line Engineering. During this process, derivation operators modify or create core assets (e.g., model elements, source code instructions, components) by adding, removing or substituting them according to a given configuration. The result is a derived product that generally needs to conform to a programming or modeling language. Some operators lead to invalid products when applied to certain assets, some others do not; knowing this in advance can help to better use them, however this is challenging, specially if we consider assets expressed in extensive and complex languages such as Java. In this paper, we empirically answer the following question: which product line operators, applied to which program elements, can synthesize variants of programs that are incorrect, correct or perhaps even conforming to test suites? We implement source code transformations, based on the derivation operators of the Common Variability Language. We automatically synthesize more than 370,000 program variants from a set of 8 real large Java projects (up to 85,000 lines of code), obtaining an extensive panorama of the sanity of the operations.
Paper was presented at SPLC'15
Many real-world product lines are only represented as non-hierarchical collections of distinct products, described by their configuration values. As the manual preparation of feature models is a tedious and labour-intensive activity, some techniques have been proposed to automatically generate boolean feature models from product descriptions. However , none of these techniques is capable of synthesizing feature attributes and relations among attributes, despite the huge relevance of attributes for documenting software product lines. In this paper, we introduce for the first time an algorithmic and parametrizable approach for computing a legal and appropriate hierarchy of features, including feature groups, typed feature attributes, domain values and relations among these attributes. We have performed an empirical evaluation by using both randomized configuration matrices and real-world examples. The initial results of our evaluation show that our approach can scale up to matrices containing 2,000 attributed features, and 200,000 distinct configurations in a couple of minutes.
Paper has been presented at SPLC'15 (Nashville, USA)
Pandoc (http://pandoc.org/) is a universal document converter. Taking as input Markdown/Wiki-like syntax, you can obtain an .odt, .docx, .tex, or even Beamer slides (like here)!
In this presentation we introduce Pandoc.
We then zoom on some interesting technical details (parameters, template language, ability to embed LaTeX into Markdown, ways to rewrite your AST with external bindings, etc.)
We believe Pandoc is a very useful piece of software that is worth studying (including for education/research purposes).
The slides have been written by Erwan Bousse (http://people.irisa.fr/Erwan.Bousse/) in Pandoc (of course!) and presented in the context of the DiverSE coffee (a weekly meeting of the DiverSE team: http://diverse.irisa.fr).
#1 The diversity of terminology shows the large spectrum of shapes DSLs can take.
#2 As syntax and development environment matter, DSLs should allow the user to choose the right shape according to their usage or task.
#3 A metamorphic DSL vision is proposed where DSLs can adapt to the most appropriate shape, including transitioning between shapes based on usage or task.
The document discusses customization and 3D printing from a software product line perspective. The researchers observed the Thingiverse community to see how they interact and collaborate to customize and produce 3D models. They found that while variability concepts are present, there is no constraints modeling and configuration leads to many issues due to huge complexity with 38 parameters across 8 tabs and 10^28 possible configurations. Software product line engineering techniques like variability modeling and implementation could help address challenges of complexity and cognitive effort for non-software developers customizing 3D models, but may not provide clear benefits for small communities in garages. Future work includes automated techniques to better analyze large datasets and help communities manage complexity.
More from University of Rennes, INSA Rennes, Inria/IRISA, CNRS (20)
The debris of the ‘last major merger’ is dynamically youngSérgio Sacani
The Milky Way’s (MW) inner stellar halo contains an [Fe/H]-rich component with highly eccentric orbits, often referred to as the
‘last major merger.’ Hypotheses for the origin of this component include Gaia-Sausage/Enceladus (GSE), where the progenitor
collided with the MW proto-disc 8–11 Gyr ago, and the Virgo Radial Merger (VRM), where the progenitor collided with the
MW disc within the last 3 Gyr. These two scenarios make different predictions about observable structure in local phase space,
because the morphology of debris depends on how long it has had to phase mix. The recently identified phase-space folds in Gaia
DR3 have positive caustic velocities, making them fundamentally different than the phase-mixed chevrons found in simulations
at late times. Roughly 20 per cent of the stars in the prograde local stellar halo are associated with the observed caustics. Based
on a simple phase-mixing model, the observed number of caustics are consistent with a merger that occurred 1–2 Gyr ago.
We also compare the observed phase-space distribution to FIRE-2 Latte simulations of GSE-like mergers, using a quantitative
measurement of phase mixing (2D causticality). The observed local phase-space distribution best matches the simulated data
1–2 Gyr after collision, and certainly not later than 3 Gyr. This is further evidence that the progenitor of the ‘last major merger’
did not collide with the MW proto-disc at early times, as is thought for the GSE, but instead collided with the MW disc within
the last few Gyr, consistent with the body of work surrounding the VRM.
The binding of cosmological structures by massless topological defectsSérgio Sacani
Assuming spherical symmetry and weak field, it is shown that if one solves the Poisson equation or the Einstein field
equations sourced by a topological defect, i.e. a singularity of a very specific form, the result is a localized gravitational
field capable of driving flat rotation (i.e. Keplerian circular orbits at a constant speed for all radii) of test masses on a thin
spherical shell without any underlying mass. Moreover, a large-scale structure which exploits this solution by assembling
concentrically a number of such topological defects can establish a flat stellar or galactic rotation curve, and can also deflect
light in the same manner as an equipotential (isothermal) sphere. Thus, the need for dark matter or modified gravity theory is
mitigated, at least in part.
ANAMOLOUS SECONDARY GROWTH IN DICOT ROOTS.pptxRASHMI M G
Abnormal or anomalous secondary growth in plants. It defines secondary growth as an increase in plant girth due to vascular cambium or cork cambium. Anomalous secondary growth does not follow the normal pattern of a single vascular cambium producing xylem internally and phloem externally.
ESPP presentation to EU Waste Water Network, 4th June 2024 “EU policies driving nutrient removal and recycling
and the revised UWWTD (Urban Waste Water Treatment Directive)”
Deep Behavioral Phenotyping in Systems Neuroscience for Functional Atlasing a...Ana Luísa Pinho
Functional Magnetic Resonance Imaging (fMRI) provides means to characterize brain activations in response to behavior. However, cognitive neuroscience has been limited to group-level effects referring to the performance of specific tasks. To obtain the functional profile of elementary cognitive mechanisms, the combination of brain responses to many tasks is required. Yet, to date, both structural atlases and parcellation-based activations do not fully account for cognitive function and still present several limitations. Further, they do not adapt overall to individual characteristics. In this talk, I will give an account of deep-behavioral phenotyping strategies, namely data-driven methods in large task-fMRI datasets, to optimize functional brain-data collection and improve inference of effects-of-interest related to mental processes. Key to this approach is the employment of fast multi-functional paradigms rich on features that can be well parametrized and, consequently, facilitate the creation of psycho-physiological constructs to be modelled with imaging data. Particular emphasis will be given to music stimuli when studying high-order cognitive mechanisms, due to their ecological nature and quality to enable complex behavior compounded by discrete entities. I will also discuss how deep-behavioral phenotyping and individualized models applied to neuroimaging data can better account for the subject-specific organization of domain-general cognitive systems in the human brain. Finally, the accumulation of functional brain signatures brings the possibility to clarify relationships among tasks and create a univocal link between brain systems and mental functions through: (1) the development of ontologies proposing an organization of cognitive processes; and (2) brain-network taxonomies describing functional specialization. To this end, tools to improve commensurability in cognitive science are necessary, such as public repositories, ontology-based platforms and automated meta-analysis tools. I will thus discuss some brain-atlasing resources currently under development, and their applicability in cognitive as well as clinical neuroscience.
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.
Unlocking the mysteries of reproduction: Exploring fecundity and gonadosomati...AbdullaAlAsif1
The pygmy halfbeak Dermogenys colletei, is known for its viviparous nature, this presents an intriguing case of relatively low fecundity, raising questions about potential compensatory reproductive strategies employed by this species. Our study delves into the examination of fecundity and the Gonadosomatic Index (GSI) in the Pygmy Halfbeak, D. colletei (Meisner, 2001), an intriguing viviparous fish indigenous to Sarawak, Borneo. We hypothesize that the Pygmy halfbeak, D. colletei, may exhibit unique reproductive adaptations to offset its low fecundity, thus enhancing its survival and fitness. To address this, we conducted a comprehensive study utilizing 28 mature female specimens of D. colletei, carefully measuring fecundity and GSI to shed light on the reproductive adaptations of this species. Our findings reveal that D. colletei indeed exhibits low fecundity, with a mean of 16.76 ± 2.01, and a mean GSI of 12.83 ± 1.27, providing crucial insights into the reproductive mechanisms at play in this species. These results underscore the existence of unique reproductive strategies in D. colletei, enabling its adaptation and persistence in Borneo's diverse aquatic ecosystems, and call for further ecological research to elucidate these mechanisms. This study lends to a better understanding of viviparous fish in Borneo and contributes to the broader field of aquatic ecology, enhancing our knowledge of species adaptations to unique ecological challenges.
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
This presentation explores a brief idea about the structural and functional attributes of nucleotides, the structure and function of genetic materials along with the impact of UV rays and pH upon them.
3. Architectural/
Component
Models
Dependencies
Files
Web
Configurators
Source
Code
Regulatory
Requirements
Video
Variants
Language
Units
Informal
Product
DescripHons
(e.g.,
product
overviews)
EMF/UML
Models
4. Or
Xor
Mandatory
Optional
not, and, or, implies
Variability Models (feature models)
Variants of code (e.g., Java or C)
Variants of user interfaces
Variants of video sequences
Variants of models (e.g., UML or
SysML)
Variants of « things » (3D models)
…
Mining/Extracting
Encoding/Formalizing
Synthesising
11. 11
«
Extrac+on
and
Evolu+on
of
Architectural
Variability
Models
in
Plugin-‐based
Systems
»
Mathieu
Acher,
Anthony
Cleve,
Philippe
Collet,
Philippe
Merle,
Laurence
Duchien,
Philippe
Lahire
ECSA/SoSyM’14
FraSCAti
SCAParser
Java Compiler
JDK6 JDT
Optional
Mandatory
Alternative-
Group
Or-Group
Assembly Factory
resthttp
Binding
MMFrascati
Component Factory
Metamodel
MMTuscany
constraints
rest requires MMFrascati
http requires MMTuscany
FM1
Variability
Model
12. 12
«
Feature
Model
Extrac+on
from
Large
Collec+ons
of
Informal
Product
Descrip+ons
»
Jean-‐Marc
Davril,
Edouard
Delfosse,
Negar
Hariri,
Mathieu
Acher,
Jane
Cleland-‐Huang,
Patrick
Heymans
(ESEC/FSE’13)
13. 13
“Reverse
Engineering
Web
Configurators”
Ebrahim
Khalil
Abbasi,
Mathieu
Acher,
Patrick
Heymans,
and
Anthony
Cleve.
In
17th
European
Conference
on
Soware
Maintenance
and
Reengineering
(CSMR'14)
14. Guillaume
Bécan,
Mathieu
Acher,
Jean-‐Marc
Jézéquel,
and
Thomas
Menguy.
On
the
Variability
Secrets
of
an
Online
Video
Generator
(2015).
In
VaMoS'15
"sq":
["dwlcjv",
"1y60t3z",
"1lymk",
"wqzv0y",
"1xxivi2",
"1oxnvtu",
"lolbe9",
"wvo06o",
"1u6y5t2",
"1eqb8bw",
"1j9aij7",
"nr7jom",
"1jmv11y",
"1qgn9dh",
"1bv7rka",
"19ykyyw",
"5znrg7",
"116hv1k"]
15.
16. Feature
Models
(defacto
standard
for
modeling
variability)
16
Hierarchy:
rooted
tree
Variability:
• mandatory,
• op+onal,
• Groups:
exclusive
or
inclusive
features
• Cross-‐tree
constraints
Optional
Mandatory
Xor-Group
Or-Group
17. 17
Hierarchy
+
Variability
=
set
of
valid
configuraHons
{CarEquipment,
Comfort,
DrivingAndSafety,
Healthing,
AirCondi+oning,
FrontFogLights}
configuraHon
=
set
of
features
selected
Optional
Mandatory
Xor-Group
Or-Group
18. 18
Hierarchy
+
Variability
=
set
of
valid
configuraHons
{CarEquipment,
Comfort,
DrivingAndSafety,
Healthing,
AirCondi+oning}
configuraHon
=
set
of
features
selected
Optional
Mandatory
Xor-Group
Or-Group
19. 19
Hierarchy
+
Variability
=
set
of
valid
configuraHons
Optional
Mandatory
Xor-Group
Or-Group
{CarEquipment,
Comfort,
DrivingAndSafety,
Healthing,
AirCondi+oning,
Automa+cHeadLights}
configuraHon
=
set
of
features
selected
ü
ü
ü
ü
ü
ü
24. 24
Hierarchy
+
Variability
=
set
of
valid
configuraHons
{CarEquipment,
Comfort,
DrivingAndSafety,
Healthing,
AirCondi+oning}
configuraHon
=
set
of
features
selected
Optional
Mandatory
Xor-Group
Or-Group
25. (FeAture
Model
scrIpt
Language
for
manIpula+on
and
Automa+c
Reasoning)
imporHng,
exporHng,
composing,
decomposing,
ediHng,
configuring,
reverse
engineering,
compuHng
"diffs",
refactoring,
tesHng,
and
reasoning
about
(mulHple)
variability
models
not, and, or, implies
φTVL
DIMACS
hVp://familiar-‐project.github.com/
Mathieu
Acher,
Philippe
Collet,
Philippe
Lahire,
Robert
B.
France
«
A
Domain-‐Specific
Language
for
Large-‐
Scale
Management
of
Feature
Models
»
Science
of
Computer
Programming
(SCP),
2013
30. For
a
given
configuraHon
set,
many
(maximal)
feature
diagrams
with
different
ontological
semanHcs
[She
et
al.
ICSE’11,
Andersen
et
al.
SPLC’12,
Acher
et
al.
VaMoS’13]
30
31. For
a
given
configuraHon
set,
many
(maximal)
feature
diagrams
with
different
ontological
semanHcs
[She
et
al.
ICSE’11,
Andersen
et
al.
SPLC’12,
Acher
et
al.
VaMoS’13]
31
35. 35
Two
product
configurators
generated
from
two
FMs
with
the
same
configuraHon
semanHcs
but
different
ontological
semanHcs.
Good
FM
Good
configuraHon
interface
Bad
FM
Bad
configuraHon
interface
Importance
of
ontological
semanHcs
(4)
36. Most
of
the
exisHng
approaches
neglect
either
configuraHon
or
ontological
semanHcs.
We
want
both!
36
φ
37. Fundamental
Problem
SelecHng
a
Spanning
Tree
of
the
Binary
ImplicaHon
Graph
(BIG)
37
38. 38
#0
OpHmum
branching
(Tarjan)
weighHng
edges
Fundamental
Problem
SelecHng
a
Spanning
Tree
of
the
Binary
ImplicaHon
Graph
(BIG)
39. 39
#1
Ranking
lists
best
parent
candidates
for
each
feature
Fundamental
Problem
SelecHng
a
Spanning
Tree
of
the
Binary
ImplicaHon
Graph
(BIG)
40. 40
#2
Clusters
~possible
siblings
Fundamental
Problem
SelecHng
a
Spanning
Tree
of
the
Binary
ImplicaHon
Graph
(BIG)
41. 41
#3
Cliques
~bi-‐implicaHons
Fundamental
Problem
SelecHng
a
Spanning
Tree
of
the
Binary
ImplicaHon
Graph
(BIG)
42. 42
#4
small
BIG
Fundamental
Problem
SelecHng
a
Spanning
Tree
of
the
Binary
ImplicaHon
Graph
(BIG)
43. 43
#4
reduced
BIG
incomplete
but
dramaHcally
reduce
the
problem
Fundamental
Problem
SelecHng
a
Spanning
Tree
of
the
Binary
ImplicaHon
Graph
(BIG)
44. Ontological
HeurisHcs
• For
op+mum
branching,
compu+ng
ranking
lists
and
clusters
– ~
«
closedness
»
of
features
based
on
their
names
• Syntac+cal
heuris+cs
– Smith-‐Waterman
(SW)
and
Levenshtein
(L)
• Wordnet
– PathLength
(PL)
and
Wu&Palmer
(WP)
• Wikipedia
Miner
offers
an
API
to
browse
Wikipedia's
ar+cles
and
compute
their
relatedness
– Wik+onary
(Wikt)
44
Milne,
D.N.,
WiVen,
I.H.:
An
open-‐source
toolkit
for
mining
wikipedia.
ArHf.
Intell.
194,
222{239
(2013)
40
GB!
46. • Dataset
– 120+
feature
models
of
SPLOT
– 30+
product
comparison
matrices
from
Wikipedia
(see
Becan
et
al.
ASE’14
and
ASE’13)
– Ground
truths
are
known
• Effec+veness
of
techniques
(reduced
BIG
+
ontological
heuris+cs)
– One
shot
synthesis
– Quality
of
the
ranking
lists
(top
2),
clusters
– Comparison
with
randomized
and
exis+ng
techniques
46
Support
and
Empirical
Study
(1)
Goal:
evidence
and
empirical
insights
of
what
heurisHcs
are
effecHve
and
what
support
is
needed
in
WebFML
47. • Dataset
– 120+
feature
models
of
SPLOT
– 30+
product
comparison
matrices
from
Wikipedia
(see
Becan
et
al.
ASE’14
and
ASE’13)
– Ground
truths
are
known
• Effec+veness
of
techniques
(reduced
BIG
+
ontological
heuris+cs)
– One
shot
synthesis
– Quality
of
the
ranking
lists
(top
2),
clusters
– Comparison
with
randomized
and
exis+ng
techniques
47
Support
and
Empirical
Study
(2)
Default
heurisHcs/support
has
been
determined
through
an
empirical
study
48. • One-‐step
synthesis
is
far
from
the
ground
truth
– despite
state-‐of-‐the-‐art
techniques
we
have
developed
– interac+ve
support
is
thus
crucial
• State-‐of-‐the-‐art
heuris+cs
for
ranking
lists
and
clusters
• Empirical
insights
on
«
cliques
»
and
BIG
reduc+on
– e.g.,
support
for
unfolding
of
cliques
48
Support
and
Empirical
Study
(3)
Default
heurisHcs/support
has
been
determined
through
an
empirical
study
50. 50
Guillaume
Bécan,
Mathieu
Acher,
Benoit
Baudry,
and
Sana
Ben
Nasr.
Breathing
Ontological
Knowledge
Into
Feature
Model
Synthesis:
An
Empirical
Study
(2015).
In
Empirical
Soware
Engineering
(ESE)
WebFML:
Synthesizing
Feature
Models
Everywhere
(SPLC’14)
51.
52.
53. Guillaume
Bécan,
Razieh
Behja+,
Arnaud
Gotlieb,
and
Mathieu
Acher.
Synthesis
of
Axributed
Feature
Models
From
Product
Descrip+ons
(2015).
In
19th
Interna+onal
Soware
Product
Line
Conference
(SPLC'15)
(research
track,
long
paper)
54. Guillaume
Bécan,
Razieh
Behja+,
Arnaud
Gotlieb,
and
Mathieu
Acher.
Synthesis
of
Axributed
Feature
Models
From
Product
Descrip+ons
(2015).
In
19th
Interna+onal
Soware
Product
Line
Conference
(SPLC'15)
(research
track,
long
paper)
55.
56.
57.
58. Jean-‐Marc
Davril,
Mathieu
Acher,
Guillaume
Bécan,
and
Patrick
Heymans.
Towards
Breaking
The
Curse
of
Dimensionality
in
Reverse
Engineering
Feature
Models
(2015).
In
Configura+on
Workshop
Data
Mining
Fuzzy
Logic
…
65. MatrixMiner:
A
Red
Pill
to
Architect
Informal
Product
DescripHons
in
the
Matrix
(Ben
Nasr
et
al.,
ESEC/FSE’15
tool)
hVp://matrix-‐miner.variability.io/
66. Guillaume
Bécan,
Nicolas
Sannier,
Mathieu
Acher,
Olivier
Barais,
Arnaud
Blouin,
and
Benoit
Baudry.
Automa+ng
the
Formaliza+on
of
Product
Comparison
Matrices
(2014).
In
29th
IEEE/ACM
Interna+onal
Conference
on
Automated
Soware
Engineering
(ASE'14)
67. Product Comparison Matrix (PCM)
• Initial points: VaMoS’12 (VariCell), ASE’13 (we coined
the term), VaMoS’14 (comparators)
• Metamodel for encoding PCMs and developing
services (eg editors), cross-validated by users
Guillaume Bécan, Nicolas Sannier, Mathieu Acher, Olivier Barais, Arnaud Blouin, and Benoit
Baudry. Automating the Formalization of Product Comparison Matrices (2014). In 29th IEEE/ACM
International Conference on Automated Software Engineering (ASE'14)
68. Evaluation
Automating the Formalization of Product Comparison Matrices - 68
Experimental settings:
• 75 Wikipedia pages
• Headers specified manually
• Automated extraction of information
PCM PCM
model
parsing preprocessing extracting
information
PCM
model
PCM
model
PCM metamodel
exploiting
S
E
R
V
I
C
E
S
RQ1
RQ2
RQ3
69. Evaluation
Automating the Formalization of
Product Comparison Matrices
- 69
Experimental settings:
• Evaluated by 20 persons (researchers and engineers)
• Online editor
70. Evaluation
Automating the Formalization of
Product Comparison Matrices
- 70
RQ1: How to formalize data contained in PCMs?
95.72% cells are valid or corrected with concepts from the metamodel
4.28% are invalid and the evaluators proposed a new concept
• Dates
• Dimensions and units
• Versions
Solution:
• Add corresponding data types to the metamodel
• Create new rules for interpreting cells
71. Evaluation
Automating the Formalization of
Product Comparison Matrices
- 71
RQ2: How to automate the formalization of PCMs?
93,11% of the cells are correctly formalized
The rest can be manually formalized with an editor
Formalization errors arise from 4 main areas:
• Overlapping concepts (e.g. what does an empty cell mean?)
• Missing concepts (e.g. dates, versions…)
• Missing interpretation rules
• Bad rules
72. Evaluation
Automating the Formalization of
Product Comparison Matrices
- 72
RQ3: What kind of tools and services can be built on top of
formalized PCMs?
Editing and formalizing PCMs
73. Evaluation
Automating the Formalization of
Product Comparison Matrices
- 73
Providing guidance during edition or refactoring
Detect inconsistent cells to provide warnings
RQ3: What kind of tools and services can be built on top of
formalized PCMs?
74. Evaluation
Automating the Formalization of
Product Comparison Matrices
- 74
Metamodel
• Feature/product oriented
• Clear semantics
RQ3: What kind of tools and services can be built on top of
formalized PCMs?
Comparing products
Translate PCMs to variability models
77. OpenCompare.org
standard format
collaborative edition
import/export of numerous formats
embeddable editor
open source
open data
innovative services (e.g., for visualizing, configuring, filtering and
« playing » with comparisons; ways to share, collaborate, and easily create comparisons)
(https://github.com/gbecan/OpenCompare)
(opencompare.org/api/get/ID)
78. Current case study: Wikipedia
Import
Export
Edit
|-
! {{rh}} | [[KickassTorrents]]
| {{yes|None}}
| {{no}}
| {{yes}}
| {{no}}<ref>{{cite web|url=http://kickass.so/
dmca/|title=KAT DMCA|work=kickasstorrents}}</
ref>
| {{sort|0000076|76}}<ref>[http://www.alexa.com/
siteinfo/kickass.so KickassTorrents] at Alexa</
ref>
|-
81. Key Contributions
• Mining Variability (see ESEC/FSE’13, SPLC’14, SoSyM’14,
VaMoS’12/13/14/15)
• From Feature Models to Product Comparison Matrices
– Syntax and semantics
• Synthesis of Feature Models
– Becan et al. (ESE journal, 2015)
• Synthesis of Attributed Feature Models
– Becan et al. (SPLC’15)
• Mining Product Comparison Matrices
– Ben Nasr et al. (ESEC/FSE’15, MatrixMiner)
– Becan et al. (ASE’14)
• OpenCompare.org
82. Future Work
• Synthesis of Feature Models
– scalability, expressiveness, readability,
usefullness
• Comparison Matrices
– Mining everything
– Synthesis
– Reasoning
• The link between the two
• OpenCompare.org