The paper presents a survey of methods solving the actual task of aspect-based sentiment analysis. Solutions for this task were proposed at multiple natural language processing conferences. Organizers of these conferences proposed evaluation platforms for methods for aspect-based sentiment analysis. This paper describes methods proposed by participants of two international evaluation platforms: SemEval-2015 focusing on English texts and SentiRuEval-2015 focusing on Russian texts.

In ISP RAS cloud computing system SaaS Unihub was developed. It provides the possibility for users to work by Web-browser with interactive graphic Linux-applications, working in isolated Docker containers. Containers have dynamical demands to computational resources. Usual way of placement when containers are distributed uniformly among all servers can lead to bad result: some servers have too many applications but other are almost empty. In this paper we propose to collect information about users behavior and investigate how different applications work in order to predict containers load-balancing. Our observations show that such information can provide more uniform load-balancing and improve the whole system performance.

In this paper the problem of creating virtual clusters in clouds for big data analysis with Apache Hadoop and Apache Spark is discussed. Existing methods for Apache Spark clusters creation are described in this work. Also the implemented solution for building Apache Spark clusters and Apache Spark jobs execution in Openstack environment is described. The implemented solution is a modification for OpenStack Sahara project and it was featured in Openstack Liberty release.

Nowadays OpenStack platform is a leading solution in cloud computing field. Keystone, the OpenStack Identity Service is one of its major components. In this paper we demonstrate the problem of Keystone performance degradation during constant load. In order to find source of the problem we have tested Keystone with different backends (PostgreSQL, MariaDB), frontends (Apache2, ngnix) and keeping the database on different hardware (HDD, SSD and tmpfs on RAM). Tests were conducted with Rally. As a result, in all test cases we have seen inadequate quick degradation under relatively light load. We have also implemented a mock service which represents the simplest Keystone tasks. Our service turned out to be much faster than Keystone. The problem with Keystone might be related to either its internal logic implementation or incorrect interaction with other components; it is the subject of further research.

This paper proposes an approach for detecting bugs in C# programs and uses null pointer deference as the main example. The approach is based on a scalable path-sensitive analysis, which involves symbolic execution with state merging and function summary methods. Functions are analyzed in backward topological order with account for previously calculated summaries. For summary construction, we use the same analysis engine as for bug detection. The problem of bug detection is reduced to satisfiability of a first-order logical formula defined on atoms, which are arithmetic expressions on function input values. We have implemented the approach in our Roslyn-based analyzer, called CSCC. Evaluation of CSCC on open-source commodity applications has shown acceptable scalability and reasonable true positive/false positive ratio.

The paper presents an approach to lightweight static data race detection, called CPALockator. It takes into account the specifics of operating system kernels, such as complex parallelism and kernel specifics synchronization mechanisms. The method is based on the Lockset one, but it implements two heuristics that are aimed to reduce amount of false alarms: a memory model and a model of parallelism. The main target of our research and evaluation is operating system kernels but the approach can be applied to the other programs as well.

One of the key problems in modern static verification methods is a precise model for semantics of expressions containing pointers. The trustworthiness of the verification verdict highly depends on the analysis of these expressions. In the paper we describe the verification methods with memory models based on uninterpreted functions, allowing analyzing programs containing expressions with pointers, including pointers to structures, arrays and pointer arithmetic. The approach is limited finite array size and finite recursion depth for dynamic data structures. The method is scalable, as far as it demonstrates reasonable verification times on the industrial size benchmarks containing device drivers of Linux operating system.

The paper presents an approach to specify constraints on AADL models in Python-based language and a toolset allowing to verify that constraints. The goal of the approach is to enable reusing of existing rich facilities of Python language, tools, and libraries as well as to reduce learning curve of engineers. Constraints must be placed into component annexes. These constraints must be written in Python programming language as functions with one argument (an object to be checked), Boolean result, and special decorator. A plugin for a modeling environment generates a program in Python from the model components declarations. While it is executing this program creates an object with the model instance and checks the object by functions from annexes. This approach is implemented in MASIW Framework that allows checking constraints on model instance. The implementation is made upon PyDev, a well-known Eclipse-plugin for Python developing in Eclipse and reuses integration of Eclipse with Python from PyDev.

The paper presents methods aimed to extend coverage of existing tests by systematic and targeted fault injection in Linux kernel. The main goal is to test if kernel components correctly handle abnormal situations. As long as such situations happen seldom and unpredictably, it is difficult to debug bugs in the code handling them. Currently the only approach used in practice is random fault injection. The paper presents new methods that inject faults systematically. It allows to achieve better coverage and to make test results more predictable. The paper describes results of evaluation of the methods proposed and random fault injection.

In this work the problem of high quality verification techniques applicable for operating systems is formulated. A perspective approach to solve this problem is integration of various verification methods. The solution technique can be considered successful if it allows to check the whole operating system and to verify in more accurate way the most important functions and components of the system, using more strict and formal methods for it. Based on the ISP RAS experience in operating system verification projects conducted using various verification techniques we determine development artefacts, that can be suitable integration point candidates for integration of formal specification based static and dynamic verification techniques for operating systems.

It is known that if P≠NP the sum coloring problem cannot be approximated within for some constant . We propose for arbitrary small an approximation scheme for this problem that works in expected polynomial time.