Publications

When solving two-player multi-objective normal-form games (MONFGs) under worst-case considerations, each strategy is naturally represented by multiple payoff vectors, one for each possible interaction with an opponent’s strategy. While it may be simpler to compress these into a single “representative” vector (e.g., a Nadir point), such scalarization may obscure important trade-offs and potentially misidentify solutions when worst-case performance is critical. To address this, recent approaches compare full sets of payoff vectors to accurately capture adversarial behaviors. However, this approach is computationally expensive. We propose a novel two-stage acceleration method that retains the exactness of full set-based worst-case comparisons, yet substantially reduces runtime. First, a computationally inexpensive tuple-based dominance check identifies obviously dominated (and hence irrational) strategies, discarding them without affecting the final worst-case non-dominated set. Second, the remaining pool of strategies is subjected to the more complex set-based dominance check. We prove theoretically that this two-stage procedure yields the same final solutions as a direct set-based approach, but at a fraction of the computational cost—especially in large strategy spaces. We demonstrate the effectiveness of our method in both a full-search scenario (small problem) and a co-evolutionary setting (larger problem), using a two-player competitive Traveling Salesperson Problem framed as a MONFG. Empirical results show consistent alignment with our complexity analysis and reveal considerable speedups, highlighting the approach’s promise for scaling set-based worst-case methods to more complex multi-player decision domains.

Traditional genetic algorithm mutation strategies typically apply stochastic gene modifications without considering broader genomic context or learning from historical evolutionary data. To address this, we introduce BERT Mutation for Genetic Algorithms (GAs), a novel, domain-independent contextual mutation operator that adapts the Transformer architecture to fixed-length genetic representations. While deep learning-based operators have shown success in Genetic Programming, extending them to GAs is challenged by “semantic opacity”—the lack of explicit structural definitions in linear integer or binary vectors. To overcome this, we propose a novel data augmentation strategy that generates pseudo-training examples derived from the population’s elite. This strategy enriches the training signal by constructing augmented trajectories toward high-fitness solutions, stabilizing the reinforcement learning process. We evaluate the operator across four diverse domains: Frozen Lake, Artificial Ant, Graph Coloring, and Unweighted Set Cover. Our results demonstrate that BERT Mutation consistently outperforms traditional stochastic operators (One-Point, Uniform, and Zigzag) and an adaptive operator (AOS) in both convergence speed and final solution quality. Notably, BERT Mutation achieves superior average fitness in approximately half the wall-clock time and fewer than half the generations required by competing baselines. Furthermore, diversity analysis confirms that BERT Mutation preserves structured, meaningful population diversity, avoiding the premature convergence seen in simpler operators.

In Genetic Algorithms (GAs), the selection operator plays a critical role in balancing exploration and exploitation. However, classical and adaptive selection mechanisms largely rely on static rules or handcrafted heuristics that fail to adapt to the real-time dynamics of the evolving population. In this work, we introduce Deep Tournament Selection (DTS), a novel domain-independent selection operator that reformulates tournament selection as a Markov Decision Process optimized via reinforcement learning. DTS evaluates candidate solutions in a tournament using a Transformer encoder augmented with global and local rank-based positional encodings, along with a self-attention pointer mechanism. This architecture allows the selection policy to jointly capture global fitness relationships and local competitive context. The policy is trained fully online using policy-gradient reinforcement learning without requiring additional fitness evaluations, enabling the operator to dynamically adjust its selection pressure. We evaluate DTS on three canonical combinatorial optimization domains: Graph Coloring, Set Cover, and the Traveling Salesman Problem. Empirical results demonstrate that DTS achieves faster convergence, improved solution quality, and robust performance across problem instances compared to classical and dynamic selection baselines, while introducing negligible computational overhead and preserving population diversity.

Deep-learning-based genetic operators can substantially improve evolutionary search quality, but they also introduce significant computational and energy overhead, bringing the Red AI vs. Green AI tension into evolutionary computation. In this work, we study the energy footprint of Deep Neural Crossover, a reinforcement-learning-based multi-parent crossover operator, and evaluate parameter-level strategies to reduce its power consumption without sacrificing solution quality. We profile experiments with process-level energy measurements and analyze two optimization levers: training batch size and a new fitness-based scheduling threshold that triggers backpropagation only after meaningful fitness improvement. Experiments on benchmark Bin-Packing and Graph Coloring instances show that changing batch size alone has little effect on total energy, whereas the proposed scheduling strategy yields substantial savings. In particular, using larger scheduling thresholds considerably reduces energy consumption while keeping fitness close to the best-performing configurations and, in several cases, matching or improving it. These results provide a practical pathway for greener neuro-evolutionary algorithms through adaptive training schedules.

We present two novel domain-independent genetic operators that harness the capabilities of deep learning: a crossover operator for genetic algorithms and a mutation operator for genetic programming. Deep Neural Crossover leverages the capabilities of deep reinforcement learning and an encoder-decoder architecture to select offspring genes. BERT mutation masks multiple gp-tree nodes and then tries to replace these masks with nodes that will most likely improve the individual’s fitness. We show the efficacy of both operators through experimentation.

This repository contains supplementary materials for the paper ’A Study on the Comprehensibility of Behavioral Programming Variants’ presented at ENASE 2025. It includes: Supplementary Appendix: Detailed results and analysis of the controlled experiment comparing BP and COBP, including per-question statistics and extended discussion of findings. Experimental Data: Raw questionnaire results from the controlled experiment involving 109 participants (37 COBP and 24 BP participants from ISE, 29 COBP and 19 BP participants from SE). This data supports the study’s investigation of comprehensibility differences between classic Behavioral Programming (BP) and Context-Oriented Behavioral Programming (COBP) in reactive systems development. Authors: Adiel Ashrov, Arnon Sturm, Achiya Elyasaf, Guy Katz Conference: 20th International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE 2025) For questions about the data, please contact: adiel.ashrov@mail.huji.ac.il Keywords: Behavioral Programming, Context-Oriented Programming, Empirical Software Engineering, Software Comprehension, Controlled Experiment, Reactive Systems

Autonomous business process systems (ABPS) operate with minimal human intervention while modifying themselves over time. Being ‘self-modifying’thereby becomes an intrinsic characteristic that enables a process to become autonomous. In this paper, we define what it means to be self-modifying in autonomous business process systems (ABPS) and outline key characteristics of such capability, including (1) the differentiation between two types of modifications, namely adaptation and evolution,(2) the levels of granularity in which a modification can be carried out, and (3) the reasons why a possible modification may be triggered. After presenting a motivating example, we characterize the goals for advancing self-modifying capabilities in ABPSs, and identify open research challenges, particularly around governance, uncertainty, and continuous learning. This work aims to structure the problem space of self-modification in ABPSs and provide a conceptual foundation for future research and development.

We introduce BERT mutation, a novel, domain-independent mutation operator for Genetic Programming (GP) that leverages advanced Natural Language Processing (NLP) techniques to improve convergence, particularly using the Masked Language Modeling approach. By combining the capabilities of deep reinforcement learning and the BERT transformer architecture, BERT mutation intelligently suggests node replacements within GP trees to enhance their fitness. Unlike traditional stochastic mutation methods, BERT mutation adapts dynamically by using historical fitness data to optimize mutation decisions, resulting in more effective evolutionary improvements. Through comprehensive evaluations across three benchmark domains, we demonstrate that BERT mutation significantly outperforms conventional and state-of-the-art mutation operators in terms of convergence speed and solution quality. This work represents a pivotal step toward integrating state-of-the-art deep learning into evolutionary algorithms, pushing the boundaries of adaptive optimization in GP.

This paper investigates how Behavioral Programming (BP), and executable specifications in general, can more effectively align models with requirements, addressing a key motivation behind BP’s development. While BP has traditionally supported safety requirements—defining what a system may, must, and must not do—it lacks direct mechanisms for expressing liveness requirements, which ensure that certain tasks are eventually completed. We introduce a “must-finish” idiom for BP, allowing explicit specification of liveness requirements. We demonstrate how this approach allows for the direct representation of common requirements patterns, supported by a user study that highlights positive outcomes, particularly in improving the alignment between software components and their corresponding requirements. While formal modeling languages that allow specification of liveness requirements are mostly used in the context of model-checking and synthesis, the focus of BP is on the executability of the model. To this end, we propose two execution mechanisms: one based on translation to Büchi automata and another using Markov decision processes (MDP), with the latter offering scalability through deep reinforcement learning. A formal analysis of the MDP-based mechanism is provided, together with qualitative and quantitative evaluations of a proof-of-concept tool.

Predicting player behavior in strategic games, especially complex ones like chess, presents a significant challenge. The difficulty arises from several factors. First, the sheer number of potential outcomes stemming from even a single position, starting from the initial setup, makes forecasting a player’s next move incredibly complex. Second, and perhaps even more challenging, is the inherent unpredictability of human behavior. Unlike the optimized play of engines, humans introduce a layer of variability due to differing playing styles and decision-making processes. Each player approaches the game with a unique blend of strategic thinking, tactical awareness, and psychological tendencies, leading to diverse and often unexpected actions. This stylistic variation, combined with the capacity for creativity and even irrational moves, makes predicting human play difficult. Chess, a longstanding benchmark of artificial intelligence research, has seen significant advancements in tools and automation. Engines like Deep Blue, AlphaZero, and Stockfish can defeat even the most skilled human players. However, despite their exceptional ability to outplay top-level grandmasters, predicting the moves of non-grandmaster players, who comprise most of the global chess community – remains complicated for these engines. This paper proposes a novel approach combining expert knowledge with machine learning techniques to predict human players’ next moves. By applying feature engineering grounded in domain expertise, we seek to uncover the patterns in the moves of intermediate-level chess players, particularly during the opening phase of the game. Our methodology offers a promising framework for anticipating human behavior, advancing both the fields of AI and human-computer interaction.

Bugs, especially those in concurrent systems, are often hard to reproduce because they manifest only under rare conditions. Testers frequently encounter failures that occur only under specific inputs, often at low probability. We propose an approach to systematically amplify the occurrence of such elusive bugs. We treat the system under test as a black-box system and use repeated trial executions to train a predictive model that estimates the probability of a given input configuration triggering a bug. We evaluate this approach on a dataset of 17 representative concurrency bugs spanning diverse categories. Several model-based search techniques are compared against a brute-force random sampling baseline. Our results show that an ensemble stacking classifier can significantly increase bug occurrence rates across nearly all scenarios, often achieving an order-of-magnitude improvement over random sampling. The contributions of this work include the following: (i) a novel formulation of bug amplification as a rare-event classification problem; (ii) an empirical evaluation of multiple techniques for amplifying bug occurrence, demonstrating the effectiveness of model-guided search; and (iii) a practical, non-invasive testing framework that helps practitioners to expose hidden concurrency faults without altering the internal system architecture.

Deep learning (DL), which includes deep reinforcement learning (DRL), holds great promise for carrying out real-world tasks that human minds seem to cope with quite readily. That promise is already delivering extremely impressive results in a variety of areas. However, while DL-enabled systems achieve excellent performance, they are far from perfect. It has been demonstrated, in several domains, that DL systems can err when they encounter cases they had not hitherto encountered. Furthermore, the opacity of the produced agents makes it difficult to explain their behavior and ensure that they adhere to various requirements posed by human engineers. At the other end of the software development spectrum of methods, behavioral programming (BP) facilitates orderly system development using self-standing executable modules aligned with how humans intuitively describe desired system behavior. In this paper, we elaborate on different approaches for combining DRL with BP and, more generally, machine learning (ML) with executable specifications (ES). We begin by defining a framework for studying the various approaches, which can also be used to study new emerging approaches not covered here. We then briefly review state-of-the-art approaches to integrating ML with ES, continue with a focus on DRL, and then present the merits of integrating ML with BP. We conclude with guidelines on how this categorization can be used in decision making in system development, and outline future research challenges.

One of the benefits of using executable specifications such as Behavioral Programming (BP) is the ability to align the system implementation with its requirements. This is facilitated in BP by a protocol that allows independent implementation modules that specify what the system may, must, and must not do. By that, each module can enforce a single system requirement, including negative specifications such as “don't do X after Y.” The existing BP protocol, however, allows only the enforcement of safety requirements and does not support the execution of liveness properties such as “do X at least three times.” To model liveness requirements in BP directly and independently, we propose idioms for tagging states with “must-finish;’ indicating that tasks are yet to be completed. We show that this idiom allows a direct specification of known requirements patterns from the literature. We also offer semantics and two execution mechanisms, one based on a translation to Büchi automata and the other based on a Markov decision process (MDP). The latter approach offers the possibility of utilizing deep reinforcement learning (DRL) algorithms, which bear the potential to handle large software systems effectively. This paper presents a qualitative and quantitative assessment of the proposed approach using a proof-of-concept tool. A formal analysis of the MDP-based execution mechanism is given in an appendix.

Emerging LLM-based code generation tools enable programmers to specify desired functionality and automatically generate code. However, these tools fall short in comparison to human ability when it comes to creating complete system models from requirements. This is because humans typically formulate a software design before implementing a system. In this paper, we propose to use the behavioral programming (BP) model-based paradigm as a general design approach that allows for the direct translation of requirements of any reactive systems into code. We demonstrate that each requirement can be automatically transformed into a dedicated code module without the need for a global view of the system. The key lies in BP’s capability to enable modules to implement both scenarios and anti-scenarios separately. This means that each module can independently define behaviors that may happen, must happen, and must not happen. Subsequently, an application-agnostic execution engine interprets and interweaves these modules at runtime to generate cohesive system behavior consistent with system requirements. The fact that each requirement is translated into a small module also facilitates the verification of its implementation, thereby helping to reduce errors in LLM code generation. We present an initial evaluation of our approach and demonstrate how the characteristics of BP aid in generating aligned and correct implementations.

We survey eight recent works by our group, involving the successful blending of evolutionary algorithms with machine learning and deep learning: (1) Binary and Multinomial Classification through Evolutionary Symbolic Regression; (2) Classy Ensemble: A Novel Ensemble Algorithm for Classification; (3) EC-KitY: Evolutionary Computation Tool Kit in Python; (4) Evolution of Activation Functions for Deep Learning-Based Image Classification; (5) Adaptive Combination of a Genetic Algorithm and Novelty Search for Deep Neuroevolution; (6) An Evolutionary, Gradient-Free, Query-Efficient, Black-Box Algorithm for Generating Adversarial Instances in Deep Networks; (7) Foiling Explanations in Deep Neural Networks; (8) Patch of Invisibility: Naturalistic Black-Box Adversarial Attacks on Object Detectors.

We present a novel approach to performing fitness approximation in genetic algorithms (GAs) using machine learning (ML) models, focusing on dynamic adaptation to the evolutionary state. We compare different methods for (1) switching between actual and approximate fitness, (2) sampling the population, and (3) weighting the samples. Experimental findings demonstrate significant improvement in evolutionary runtimes, with fitness scores that are either identical or slightly lower than those of the fully run GA—depending on the ratio of approximate-to-actual-fitness computation. Although we focus on evolutionary agents in Gymnasium (game) simulators—where fitness computation is costly—our approach is generic and can be easily applied to many different domains.

We evolve survivors for the CodeGuru competition — assembly programs that run the longest in shared memory, by resisting attacks from adversary survivors and finding their weaknesses. For evolving top-notch solvers, we specify a Backus Normal Form (BNF) for the assembly language and synthesize the code from scratch using Genetic Programming (GP). We evaluate the survivors by running CodeGuru games against human-written winning survivors. Our evolved programs found weaknesses in the programs they were trained against and utilized them. This work has important applications for cyber-security, as we utilize evolution to detect weaknesses in survivors. The assembly BNF is domain-independent; thus, by modifying the fitness function, it can detect code weaknesses and help fix them. Finally, the CodeGuru competition offers a novel platform for analyzing GP and code evolution in adversarial environments. To support further research in this direction, we provide a thorough qualitative analysis of the evolved survivors and the weaknesses found.

We present a novel multi-parent crossover operator in genetic algorithms (GAs) called "Deep Neural Crossover" (DNC). Unlike conventional GA crossover operators that rely on a random selection of parental genes, DNC leverages the capabilities of deep reinforcement learning (DRL) and an encoder-decoder architecture to select the genes. Specifically, we use DRL to learn a policy for selecting promising genes. The policy is stochastic, to maintain the stochastic nature of GAs, representing a distribution for selecting genes with a higher probability of improving fitness. Our architecture features a recurrent neural network (RNN) to encode the parental genomes into latent memory states, and a decoder RNN that utilizes an attention-based pointing mechanism to generate a distribution over the next selected gene in the offspring. The operator’s architecture is designed to find linear and nonlinear correlations between genes and translate them to gene selection. To reduce computational cost, we present a transfer-learning approach, wherein the architecture is initially trained on a single problem within a specific domain and then applied to solving other problems of the same domain. We compare DNC to known operators from the literature over two benchmark domains, outperforming all baselines.

Context-aware systems keep on emerging in all of our daily activities. Context, which can be a location, a user, an actual activity, or physical conditions, plays a major role in such systems. Actually, everything we refer to in our systems can be considered as context. Mechanisms for managing context were devised to cope with this new situation, including frameworks and programming languages. However, modeling languages that address the notion of context are rare. In this paper, we aim to frame and further define the requirements for context modeling languages. Such a conceptualized framework sets the ground for designing and evaluating modeling languages for context-aware systems. We demonstrate a possible use of the proposed framework through the evaluation of context-oriented modeling languages: UML-based Context Modeling and Context-Oriented Live Sequence Chart (CO-LSC).

Deep reinforcement learning agents have achieved unprecedented results when learning to generalize from unstructured data. However, the “black-box” nature of the trained DRL agents makes it difficult to ensure that they adhere to various requirements posed by engineers. In this work, we put forth a novel technique for enhancing the reinforcement learning training loop, and specifically—its reward function, in a way that allows engineers to directly inject their expert knowledge into the training process. This allows us to make the trained agent adhere to multiple constraints of interest. Moreover, using scenario-based modeling techniques, our method allows users to formulate the defined constraints using advanced, well-established, behavioral modeling methods. This combination of such modeling methods together with ML learning tools produces agents that are both high performing and more likely to adhere to prescribed constraints. Furthermore, the resulting agents are more transparent and hence more maintainable. We demonstrate our technique by evaluating it on a case study from the domain of internet congestion control, and present promising results.

We present a new model-based approach for testing systems that use sequences of actions and assertions as test vectors. Our solution includes a method for quantifying testing quality, a tool for generating high-quality test suites based on the coverage criteria we propose, and a framework for assessing risks. For testing quality, we propose a method that specifies generalized coverage criteria over sequences of actions, which extends previous approaches. Our publicly available tool demonstrates how to extract effective test suites from test plans based on these criteria. We also present a Bayesian approach for measuring the probabilities of bugs or risks, and show how this quantification can help achieve an informed balance between exploitation and exploration in testing. Finally, we provide an empirical evaluation demonstrating the effectiveness of our tool in finding bugs, assessing risks, and achieving coverage.

Context-aware systems keep on emerging as an intrinsic part of everyday activities. To cope with such situations, programming languages are extended to support the notion of context. Although context-oriented programming languages exist for over 15 years, they were tested for their suitability for developing context-aware systems only to a limited extent. In this paper, we propose a framework for analyzing the suitability of context-oriented languages from a wider viewpoint. Using this framework, we are able to examine context definition and activation, reasoning capabilities, process aspects of how to work with the language, and other pragmatic considerations. To demonstrate the use of the framework, we apply it to analyze three context-oriented programming languages: ServalCJ, Subjective-C, and COBPjs which represent the major Context-Oriented Programming themes. We evaluate the capabilities of each language using the purposed framework. Developers of context-oriented programming languages can use the framework to improve their languages and the associated development and supporting tools. Furthermore, such analysis can support users of context-oriented programming languages in deciding the language that best suits their needs.

EC-KitY is a comprehensive Python library for doing evolutionary computation (EC), licensed under the BSD 3-Clause License, and compatible with scikit-learn. Designed with modern software engineering and machine learning integration in mind, EC-KitY can support all popular EC paradigms, including genetic algorithms, genetic programming, coevolution, evolutionary multi-objective optimization, and more. This paper provides an overview of the package, including the ease of setting up an EC experiment, the architecture, the main features, and a comparison with other libraries.

We identify and demonstrate a weakness of Petri Nets (PN) in specifying composite behavior of reactive systems. Specifically, we show how, when specifying multiple requirements in one PN model, modelers are obliged to specify mechanisms for combining these requirements. This yields, in many cases, over-specification and incorrect models. We demonstrate how some execution paths are missed, and some are generated unintentionally. To support this claim, we analyze PN models from the literature, identify the combination mechanisms, and demonstrate their effect on the correctness of the model. To address this problem, we propose to model the system behavior using behavioral programming (BP), a software development and modeling paradigm designed for seamless integration of independent requirements. Specifically, we demonstrate how the semantics of BP, which define how to interweave scenarios into a single model, allow for avoiding the over-specification. Additionally, while BP maintains the same mathematical properties as PN, it provides means for changing the model dynamically, thus increasing the agility of the specification. We compare BP and PN in quantitative and qualitative measures by analyzing the models, their generated execution paths, and the specification process. Finally, while BP is supported by tools that allow for applying formal methods and reasoning techniques to the model, it lacks the legacy of PN tools and algorithms. To address this issue, we propose semantics and a tool for translating BP models to PN and vice versa.

We present Provengo, a comprehensive suite of tools designed to facilitate the implementation of Scenario-Driven Model-Based Testing (SDMBT), an innovative approach that utilizes scenarios to construct a model encompassing the user’s perspective and the system’s business value while also defining the desired outcomes. With the assistance of Provengo, testers gain the ability to effortlessly create natural user stories and seamlessly integrate them into a model capable of generating effective tests. The demonstration illustrates how SDMBT effectively addresses the bootstrapping challenge commonly encountered in model-based testing (MBT) by enabling incremental development, starting from simple models and gradually augmenting them with additional stories.

A context-aware recommender system (CARS) applies sensing and analysis of user context to provide personalized services. The contextual information can be driven from sensors in order to improve the accuracy of the recommendations. Yet, generating accurate recommendations is not enough to constitute a useful system from the users’ perspective, since certain contextual information may cause different issues, such as draining the user’s battery, privacy issues, and more. Adding high-dimensional contextual information may increase both the dimensionality and sparsity of the model. Previous studies suggest reducing the amount of contextual information by selecting the most suitable contextual information using a domain knowledge. Another solution is compressing it into a denser latent space, thus disrupting the ability to explain the recommendation item to the user, and damaging users’ trust. In this paper we present an approach for selecting low-dimensional subsets of the contextual information and incorporating them explicitly within CARS. Specifically, we present a novel feature-selection algorithm, based on genetic algorithms (GA), that outperforms SOTA dimensional-reduction CARS algorithms, improves the accuracy and the explainability of the recommendations, and allows for controlling user aspects, such as privacy and battery consumption. Furthermore, we exploit the top subsets that are generated along the evolutionary process, by learning multiple deep context-aware models and applying a stacking technique on them, thus improving the accuracy while remaining at the explicit space. We evaluated our approach on two high-dimensional context-aware datasets driven from smartphones. An empirical analysis of our results validates that our proposed approach outperforms SOTA CARS models while improving transparency and explainability to the user.

Automatically generating executable code has a long history of arguably modest success, mostly limited to the generation of small programs of up to 200 lines of code, and genetic improvement of existing code. We present the use of genetic programming (GP) in conjunction with context-oriented behavioral programming (COBP), the latter being a programming paradigm with unique characteristics that facilitate automatic coding. COBP models a program as a set of behavioral threads (b-threads), each aligned to a single behavior or requirement of the system. To evolve behavioral programs we design viable and effective genetic operators, a genetic representation, and evaluation methods. The simplicity of the COBP paradigm, its straightforward syntax, the ability to use verification and formal-method techniques to validate program correctness, and a program comprising small independent chunks all allow us to effectively generate behavioral programs using GP. To demonstrate our approach we evolve complete programs from scratch of a highly competent O player for the game of tic-tac-toe. The evolved programs are well structured, consisting of multiple, explainable modules that specify the different behavioral aspects of the program and are similar to our handcrafted program. To validate the correctness of our individuals, we utilize the mathematical characteristics of COBP to analyze program behavior under all possible execution paths. Our analysis of an evolved program proved that it plays as expected more than 99% of the times.

Deep reinforcement learning has proven remarkably useful in training agents from unstructured data. However, the opacity of the produced agents makes it difficult to ensure that they adhere to various requirements posed by human engineers. In this work-in-progress report, we propose a technique for enhancing the reinforcement learning training process (specifically, its reward calculation), in a way that allows human engineers to directly contribute their expert knowledge, making the agent under training more likely to comply with various relevant constraints. Moreover, our proposed approach allows formulating these constraints using advanced model engineering techniques, such as scenario-based modeling. This mix of black-box learning-based tools with classical modeling approaches could produce systems that are effective and efficient, but are also more transparent and maintainable. We evaluated our technique using a case-study from the domain of internet congestion control, obtaining promising results.

Context-aware systems keep on emerging in all of our daily activities. Context, which can be a location, a user, an actual activity, or physical conditions, plays a major role in such systems. Actually, everything we refer to in our systems can be considered as context. To cope with this new situation, mechanisms for managing context were devised, including frameworks and programming languages. However, modeling languages that address the notion of context are rare. In this paper, we aim at framing and further defining the requirements for context modeling languages. Such a conceptualized framework sets the ground for designing and evaluatingmodeling languages for context-aware systems. We demonstrate a possible use of the proposed framework through the evaluation of CO-LSC, a context-oriented modeling language

A method for testing operating software of a system consisting of a plurality of internal subsystems operating in an environment and controlled by a hardware board using electronic signals and an operating software. The signals are translated into a computer readable format by an interfacing card for each internal subsystem and simulating the internal subsystems by data acquisition modules by a simulating computer, which simulates the environmental conditions to which each module is currently exposed. A scenario based test software module generates a plurality of possible independent test scenarios using Behavioral Programming (BP) and the independent scenarios are interleaved at run time by an execution engine, to thereby automatically create a larger number of dependent and derived scenarios representing only possible combinations which are relevant to the operating conditions and states of the system.

Context: Modern systems require programmers to develop code that dynamically adapts to different contexts, leading to the evolution of new context-oriented programming languages. These languages introduce new software-engineering challenges, such as: how to maintain the separation of concerns of the codebase? how to model the changing behaviors? how to verify the system behavior? and more. Objective: This paper introduces Context-Oriented Behavioral Programming (COBP) — a novel paradigm for developing context-aware systems, centered on natural and incremental specification of context-dependent behaviors. As the name suggests, we combine behavioral-programming (BP) — a scenario-based modeling paradigm — with context idioms that explicitly specify when scenarios are relevant and what information they need. The core idea is to connect the behavioral model with a data model that represents the context, allowing an intuitive connection between the models via update and select queries. Combining behavioral-programming with context-oriented programming brings the best of the two worlds, solving issues that arise when using each of the approaches in separation. Methods: We begin with providing abstract semantics for COBP and two implementations for the semantics, laying the foundations for applying reasoning algorithms to context-aware behavioral programs. Next, we exemplify the semantics with formal specifications of systems, including a variant of Conway’s Game of Life. Then, we provide two case studies of real-life context-aware systems (one in robotics and another in IoT) that were developed using this tool. Throughout the examples and case studies, we provide design patterns and a methodology for coping with the above challenges. Results: The case studies show that the proposed approach is applicable for developing real-life systems, and presents measurable advantages over the alternatives — behavioral programming alone and context-oriented programming alone. Conclusion: We present a paradigm allowing programmers and system engineers to capture complex context-dependent requirements and align their code with such requirements.

Context-aware systems keep on emerging in all of our daily activities. To cope with this new situation, programming languages were extended to support the notion of context. Although context-oriented programming languages exist for over 15 years, they were tested for their suitability in developing context-aware systems only to a limited extent. In this paper, we propose a framework for analyzing context-oriented languages from that viewpoint. In this framework, we refer to context definition and activation, reasoning capabilities, process aspects of how to work with the suggested extension, and pragmatic considerations. To demonstrate the use of the framework, we applied it to a relatively new context-oriented programming paradigm, namely context-oriented behavioral programming. The proposed framework can support users of context-oriented programming languages in deciding on the most fitted language for their purpose. Developers of context-oriented programming languages can also use the framework to improve such languages and their supporting tools.

We describe four scenario-based implementations of controllers for a player in a simplified RoboCup-type game. All four implementations are based on the behavioural programming (BP) approach. We first describe a simple controller for the player using the state-of-the-art BPjs tool and then show how it can be extended in various ways. The first extension is based on a version of BP where the Z3 SMT solver is used to provide mechanisms for richer composition of modules within the BP model. This allows for modules with higher cohesion and lower coupling. It also allows incrementality: we could use the scenarios we developed for the challenge of MDETOOLS’18 and extend the model to handle the new system. The second extension of BP demonstrated in this paper is a set of idioms for subjecting model components to context. One of the differences between this year’s challenge and the challenge we dealt with last year is that following the ball is not the only task that a player needs to handle, there is much more to care for. We demonstrate how we used the idioms for handling context to parametrize scenarios like "go to a target" in a dynamic and natural fashion such that modelers can efficiently specify reusable components similar to the way modern user manuals for advanced products are written. Lastly, in an attempt to make the instructions to the robot even more natural, we demonstrate a third extension based on deep reinforcement learning. Towards substantiating the observation that it is easier to explain things to an intelligent agent than to dumb compiler, we demonstrate how the combination of BP and deep reinforcement learning (DRL) allows for giving abstract instructions to the robot and for teaching it to follow them after a short training session.

In this paper we propose a novel approach to satellites-software development, that allows for modularity and formal verification, resulting with safe and robust satellite software. Specifically, we propose to use scenario-based programming where software components (modules) represent different aspects of mission scenarios and anti-scenarios (sequences of events that must not happen). We present examples of how specifications can be translated into code artifacts that represent them in a direct and intuitive way. We support this approach with a development environment that we are designing for creating an on-board mission software. Our environment includes an automatic model-checking tool for verifying the produced software and for bug detection. we show that verification can be done on specific parts of the model, on specific logical layers of the applications, and on the entire model at a specific abstraction level. This allows for modular design process, where modules are tested and verified as soon as their code is ready. Additionally, we describe a “hybrid laboratory” for advanced testing of the mission software. This laboratory uses a novel approach that allows for automatic generation of test scenarios, using scenario-based programming. We believe that... the development environment along with the hybrid laboratory, provide a viable solution for developing reliable satellite software.

The General Video Game Playing Competition (GVGAI) defines a challenge of creating controllers for general video game playing, a testbed—as it were—for examining the issue of artificial general intelligence . We develop herein a game controller that mimics human learning behavior, focusing on the ability to generalize from experience and diminish learning time as new games present themselves. We use genetic programming to evolve hyper-heuristic-based general players. Our results show the effectiveness of evolution in meeting the generality challenge.

In scenario-based models of reactive systems complex specifications are divided into artifacts corresponding to separate aspects of overall system behavior, as they may appear, e.g., in a robot’s requirements document or user specifications. The advantages of scenario-based development include intuitiveness and clarity, the ability to execute or simulate specifications of early prototypes and of final systems, and the ability to verify the specification for early detection of conflicts, omissions, and errors. In this position paper we discuss two issues that emerge when applying scenario-based development in complex cases: (a) simple scenarios become unwieldy when subjected to a growing number of conditions, exceptions and refinements, and (b) it is hard to understand and maintain a large ‘flat’ specification, consisting of an unorganized list of independently-specified scenarios, simple as they may individually be. We address these issues by basing certain facets of scenario design on context, an increasingly popular foundational consideration in software engineering. We first show how one can incorporate context into the graphical language of live sequence charts (LSC) using existing LSC idioms. We then outline two other possibilities: (i) enriching the LSC language, or (ii) embedding LSCs within hierarchical state machines, namely, statecharts. We believe that this research can contribute to the broader goals of developing complex and powerful reactive systems in intuitive and robust ways.

As devices, platforms, and technologies for IoT (Internet-of-Things) and robots, develop, the question of how to best specify the behavior of such systems so that it is both robust and manageable becomes central. Current practices may suffice when working with simple requirements. However, behavior specification given in current languages often become unwieldy as they grow to accommodate complex conditions, exceptions, and priorities. To address this, we propose to use the scenariobased programming approach, and specifically, the graphical language of live sequence charts (LSC). This addresses one aspect of the specification growth issue by allowing a natural break-down of the specification in alignment with the requirements. The other aspect of our solution, aiming at further simplifying and shortening the specification, is based on subjecting these scenarios to context—a key concept in IoT and autonomous robot modeling. Specifically, we propose additions to LSC for subjecting behavioral scenario charts to contexts and a methodology to work with these idioms.

The computational identification of conserved motifs in RNA molecules is a major—yet largely unsolved—problem. Structural conservation serves as strong evidence for important RNA functionality. Thus, comparative structure analysis is the gold standard for the discovery and interpretation of functional RNAs. In this paper we focus on one of the functional RNA motif types, sequence-structure motifs in RNA molecules, which marks the molecule as targets to be recognized by other molecules. We present a new approach for the detection of RNA structure (including pseudoknots), which is conserved among a set of unaligned RNA sequences. Our method extends previous approaches for this problem, which were based on first identifying conserved stems and then assembling them into complex structural motifs. The novelty of our approach is in simultaneously preforming both the identification and the assembly of these stems. We believe this novel unified approach offers a more informative model for deciphering the evolution of functional RNAs, where the sets of stems comprising a conserved motif co-evolve as a correlated functional unit. Since the task of mining RNA sequence-structure motifs can be addressed by solving the maximum weighted clique problem in an n-partite graph, we translate the maximum weighted clique problem into a state graph. Then, we gather and define domain knowledge and low-level heuristics for this domain. Finally, we learn hyper-heuristics for this domain, which can be used with heuristic search algorithms (e.g., A*, IDA*) for the mining task. The hyper-heuristics are evolved using HH-Evolver, a tool for domain-specific, hyper-heuristic evolution. Our approach is designed to overcome the computational limitations of current algorithms, and to remove the necessity of previous assumptions that were used for sparsifying the graph. This is still work in progress and as yet we have no results to report. However, given the interest in the methodology and its previous success in other domains we are hopeful that these shall be forthcoming soon.

Despite many advances in automating system and software engineering, the knowledge, skills and experience of human engineers and domain experts are, and will continue to be, critical factors in the success of complex system development projects. In a new research direction we term towards wise computing we aim to make some of these abilities available to all project-team members, at any time, by adding several radically-new capabilities to the development environment. For example, the development environment will be able to, on its own, notice and suggest a required action for, an unexpected, unspecified, emergent system property. A report on the ultimate wise-computing vision and an initial demonstration of the desired functions have been published separately. Clearly, advanced tools, such as formal verification and synthesis, machine learning and automatic reasoning, which were not previously available, are now maturing and will be essential to wise computing. Yet, a comprehensive feasibility plan was not shown until now, and despite the above arsenal of tools, a challenge is often presented: is it indeed possible to automate some critically relevant abilities of humans, like free association, applying general knowledge to a wide variety of specific cases, or “thinking outside the box” to find a solution to a problem. In this report we outline research directions for several software capabilities and design principles that we have begun to work on, and which we believe can remove key remaining obstacles to feasibility of wise computing.

The application of computational intelligence techniques within the vast domain of games has been increasing at a breathtaking speed. Over the past few years my research has produced a plethora of results in games of different natures, evidencing the success and efficiency of evolutionary algorithms in general—and genetic programming in particular—at producing top-notch, human-competitive game strategies.

The application of computational intelligence techniques within the vast domain of games has been increasing at a breath-taking speed. Over the past several years our research group has produced a plethora of results in numerous games of different natures, evidencing the success and efficiency of evolutionary algorithms in general — and genetic programming in particular — at producing top-notch, human-competitive game strategies. Herein, we describe our study of the game of FreeCell, which produced two Gold Humie Awards. Our top evolved FreeCell player is the best published player to date, able to convincingly beat high-ranking human players.

We present two opposing approaches to the evolution of game strategies, one wherein a minimal amount of domain expertise is injected into the process, the other infusing the evolutionary setup with expertise in the form of domain heuristics. We show that the first approach works well for several popular board games, while the second produces top-notch solvers for the hard game of FreeCell.

We present a HeuristicLab plugin for FINCH. FINCH (Fertile Darwinian Bytecode Harvester) is a system designed to evolutionarily improve actual, extant software, which was not intentionally written for the purpose of serving as a GP representation in particular, nor for evolution in general. This is in contrast to existing work that uses restricted subsets of the Java bytecode instruction set as a representation language for individuals in genetic programming. The ability to evolve Java programs will hopefully lead to a valuable new tool in the software engineer’s toolkit.

We present HH-Evolver, a tool for domain-specific, hyper-heuristic evolution. HH-Evolver automates the design of domain-specific heuristics for planning domains. Hyper-heuristics generated by our tool can be used with combinatorial search algorithms such as A* and IDA* for solving problems of a given domain. HH-Evolver has a rich GUI that enables easy operation, including: running experiments in parallel, pausing and resuming experiments, and saving them and analyzing the results. Implementing new domains and heuristics with HH-Evolver is easily accomplished.

In this paper, we evolve heuristics to guide staged deepening search for the hard game of FreeCell, obtaining top-notch solvers for this human-challenging puzzle. We first devise several novel heuristic measures using minimal domain knowledge and then use them as building blocks in two evolutionary setups involving a standard genetic algorithm and policy-based, genetic programming. Our evolved solvers outperform the best FreeCell solver to date by three distinct measures: 1) number of search nodes is reduced by over 78%; 2) time to solution is reduced by over 94%; and 3) average solution length is reduced by over 30%. Our top solver is the best published FreeCell player to date, solving 99.65% of the standard Microsoft 32 K problem set. Moreover, it is able to convincingly beat high-ranking human players.

We use genetic algorithms to evolve highly successful solvers for two puzzles: FreeCell and the Sliding-Tile Puzzle.

We evolve heuristics to guide staged deepening search for the hard game of FreeCell, obtaining top-notch solvers for this NP-Complete, human-challenging puzzle. We first devise several novel heuristic measures and then employ a Hillis-style coevolutionary genetic algorithm to find efficient combinations of these heuristics. Our results significantly surpass the best published solver to date by three distinct measures: 1) Number of search nodes is reduced by 87%; 2) time to solution is reduced by 93%; and 3) average solution length is reduced by 41%. Our top solver is the best published FreeCell player to date, solving 98% of the standard Microsoft 32K problem set, and also able to beat high-ranking human players.

We use genetic programming to evolve highly successful solvers for two puzzles: Rush Hour and FreeCell.

We evolve heuristics to guide IDA* search for the 6x6 and 8x8 versions of the Rush Hour puzzle, a PSPACE-Complete problem, for which no efficient solver has yet been reported. No effective heuristic functions are known for this domain, and–before applying any evolutionary thinking–we first devise several novel heuristic measures, which improve (non-evolutionary) search for some instances, but hinder search substantially for many other instances. We then turn to genetic programming (GP) and find that evolution proves immensely efficacious, managing to combine heuristics of such highly variable utility into composites that are nearly always beneficial, and far better than each separate component. GP is thus able to beat both the human player of the game and also the human designers of heuristics.