“It was a pleasure to work with Nataliia when she was a post-doctoral researcher in my group at EPFL. She is open minded about new research directions and great at identifying collaboration opportunities. I have learned from her a lot about the role of natural language processing in requirements engineering. She was always able to quickly identify relevant literature and build prototypes making use of existing and new techniques.”
Загальна інформація
𝗪𝗛𝗢 𝗔𝗠 𝗜
I am a software engineer moving from academic research to the…
Діяльність
-
Deep-tech companies and start-ups, based on scientific advancements, attract more investment, including from foreign partners. Thanks to scientific…
Deep-tech companies and start-ups, based on scientific advancements, attract more investment, including from foreign partners. Thanks to scientific…
Вподобано Nata Stulova
-
10 years ago I came to Vienna to present my first research paper, today I am in Vienna for the first time as a researcher from industry, with our…
10 years ago I came to Vienna to present my first research paper, today I am in Vienna for the first time as a researcher from industry, with our…
Поширено Nata Stulova
-
It is always pleasant to meet again (and again) with Pooja Rani and Oscar Nierstrasz. It seems yesterday when Pooja received her award at the…
It is always pleasant to meet again (and again) with Pooja Rani and Oscar Nierstrasz. It seems yesterday when Pooja received her award at the…
Вподобано Nata Stulova
Досвід
Освіта
-
Universidad Politécnica de Madrid
-
Thesis title: "Improving Run-time Checking in Dynamic Programming Languages".
My thesis presents various techniques for performance enhancement of specification-based run-time verification frameworks, including compilation optimization, static program analysis, and more precise specification language constructs.
Technologies used: Prolog | C -
-
Thesis title: 'Dynamic Checking of Assertions for Higher-Order Predicates'.
I have developed a specification language for higher-order program routines and proposed mechanisms for run-time checking of such specifications. My thesis presented contributions to the task of run-time program verification in the context of dynamic programming languages. Though initially proposed for the (constraint) logic programming, the approach is applicable to other programming…Thesis title: 'Dynamic Checking of Assertions for Higher-Order Predicates'.
I have developed a specification language for higher-order program routines and proposed mechanisms for run-time checking of such specifications. My thesis presented contributions to the task of run-time program verification in the context of dynamic programming languages. Though initially proposed for the (constraint) logic programming, the approach is applicable to other programming paradigms.
Technologies used: Prolog -
-
Thesis title: "Software Module of Pattern Recognition Using Genetic Algorithms".
My thesis presented an experimental evaluation with a prototype tool of the applicability of AI/ML techniques to the problem of sign language recognition (working with static visual data).
Technologies used: C++ | QT
Ліцензії та сертифікати
-
Business Analysis Fundamentals
Udemy
Дата видачіІдентифікатор кваліфікаційного сертифіката UC-edf32918-443a-457e-8fdf-4e2986a2fb7e -
Волонтерський досвід
-
Website Consultant
Ksi Prostir
- зараз 4 роки 5 місяців
Мистецтво та культура
In a team of 5 helped to create a website from scratch. Participated in discussions on gathering technical and non-technical requirements, helped to choose technologies for website development, coordinated the development and maintenance efforts, and as a result a fully functioning website is now up and running: https://ksiprostir.org/
Technologies used:
- Wordpress + Brizy + Figma for design and development
- Notion + GoogleDocs for collaborative documetation
Публікації
-
First-class Artifacts as Building Blocks for Live in-IDE Documentation (to appear)
29th International Conference on Software Analysis, Evolution, and Reengineering (SANER’22)
A traditional round-trip engineering approach based on model transformations does not scale well to modern agile development environments where numerous artifacts are produced using a range of heterogeneous tools and technologies. To boost artifact connectivity and maintain their consistency,
we propose to create and manage software-related artifacts as first-class entities directly in an integrated development environment (IDE). This approach has two advantages: (i) compared to employing…A traditional round-trip engineering approach based on model transformations does not scale well to modern agile development environments where numerous artifacts are produced using a range of heterogeneous tools and technologies. To boost artifact connectivity and maintain their consistency,
we propose to create and manage software-related artifacts as first-class entities directly in an integrated development environment (IDE). This approach has two advantages: (i) compared to employing separate tools, creating various artifacts directly within a development platform eliminates the necessity to recover trace links, and (ii) first-class artifacts can be composed into stakeholder-specific live document-artifacts. We detail and exemplify our approach in the Glamorous Toolkit IDE (henceforth, Glamorous toolkit), and discuss the results of a semi-structured pilot survey we conducted with practitioners and researchers to evaluate its usefulness in practice.Інші авториПодивитися публікацію -
Interactive Behavior-driven Development: a Low-code Perspective
ACM/IEEE 24th International Conference on Model Driven Engineering Languages and Systems (MODELS), LowCode workshop
Within behavior-driven development (BDD), different types of stakeholders collaborate in creating scenarios that specify application behavior. The current workflow for BDD expects non-technical stakeholders to use an integrated development environment (IDE) to write textual scenarios in
the Gherkin language and verify application behavior using test passed/failed reports. Research to date shows that this approach leads non-technical stakeholders to perceive BDD as an overhead in addition to…Within behavior-driven development (BDD), different types of stakeholders collaborate in creating scenarios that specify application behavior. The current workflow for BDD expects non-technical stakeholders to use an integrated development environment (IDE) to write textual scenarios in
the Gherkin language and verify application behavior using test passed/failed reports. Research to date shows that this approach leads non-technical stakeholders to perceive BDD as an overhead in addition to the testing. In this vision paper, we propose an alternative approach to specify and verify application behavior visually, interactively, and collaboratively within an IDE. Instead of writing textual scenarios, non-technical stakeholders compose, edit, and save scenarios by using tailored graphical interfaces that allow them to manipulate involved domain objects. Upon executing such interactively composed scenarios, all stakeholders verify the application behavior by inspecting domain-specific representations
of run-time domain objects instead of a test run report. Such a low code approach to BDD has the potential to enable non-technical stakeholders to engage more harmoniously in behavior specification and validation together with technical stakeholders within an IDE. There are two main contributions of this work: (i) we present an analysis of the features of 13 BDD tools, (ii) we describe a prototype implementation of our approach, and (iii) we outline our plan to conduct a large-scale developer survey to
evaluate our approach to highlight the perceived benefits over the existing approach.Інші авториПодивитися публікацію -
Do Comments follow Commenting Conventions? A Case Study in Java and Python
21st IEEE International Working Conference on Source Code Analysis and Manipulation
Assessing code comment quality is known to be a difficult problem. A number of coding style guidelines have been created with the aim to encourage writing of informative, readable, and consistent comments. However, it is not clear from the research to date which specific aspects of comments the guidelines cover (e.g., syntax, content, structure). Furthermore, the extent to which developers follow these guidelines while writing code comments is unknown.
We analyze various style guidelines in…Assessing code comment quality is known to be a difficult problem. A number of coding style guidelines have been created with the aim to encourage writing of informative, readable, and consistent comments. However, it is not clear from the research to date which specific aspects of comments the guidelines cover (e.g., syntax, content, structure). Furthermore, the extent to which developers follow these guidelines while writing code comments is unknown.
We analyze various style guidelines in Java and Python and uncover that the majority of them address more the content aspect of the comments rather than syntax or formatting, but when considering the different types of information developers embed in comments and the concerns they raise on various online platforms about the commenting practices, existing comment conventions are not yet specified clearly enough, nor do they adequately cover important concerns. We also analyze commenting practices of developers in diverse projects to see the extent to which they follow the guidelines. Our results highlight the mismatch between developer commenting practices and style guidelines, and provide several focal points for the design and improvement of comment quality checking tools.Інші авториПодивитися публікацію -
RepliComment: Identifying Clones in Code Comments
Journal of Systems and Software
Code comments are the primary means to document implementation and facilitate program comprehension. Thus, their quality should be a primary concern to improve program maintenance. While much effort has been dedicated to detecting bad smells, such as clones in code, little work has focused on comments. In this paper we present our solution to detect clones in comments that developers should fix. RepliComment can automatically analyze Java projects and report instances of copy-and-paste errors…
Code comments are the primary means to document implementation and facilitate program comprehension. Thus, their quality should be a primary concern to improve program maintenance. While much effort has been dedicated to detecting bad smells, such as clones in code, little work has focused on comments. In this paper we present our solution to detect clones in comments that developers should fix. RepliComment can automatically analyze Java projects and report instances of copy-and-paste errors in comments, and can point developers to which comments should be fixed. Moreover, it can report when clones are signs of poorly written comments. Developers should fix these instances too in order to improve the quality of the code documentation. Our evaluation of 10 well-known open source Java projects identified over 11K instances of comment clones, and over 1,300 of them are potentially critical. We improve on our own previous work Blasi and Gorla (2018), which could only find 36 issues in the same dataset. Our manual inspection of 412 issues reported by RepliComment reveals that it achieves a precision of 79% in reporting critical comment clones. The manual inspection of 200 additional comment clones that RepliComment filters out as being legitimate, could not evince any false negative.
Інші авториПодивитися публікацію -
Towards Detecting Inconsistent Comments in Java Source Code Automatically
20th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2020)
We propose a technique and a tool, upDoc, to automatically detect code-comment inconsistency during code evolution. We conduct a preliminary evaluation using inconsistency examples from an existing dataset of Java open source projects, showing that upDoc can successfully detect them. We present a roadmap for the further development of the technique and its evaluation.
Інші авториПодивитися публікацію -
Static Performance Guarantees for Programs with Run-time Checks
20th International ACM SIGPLAN Symposium on Principles and Practice of Declarative Programming (PPDP 2018)
Instrumenting programs for performing runtime checking of properties, such as regular shapes, is a common and useful technique that helps programmers detect incorrect program behaviors. This is specially true in dynamic languages such as Prolog. However, such runtime checks inevitably introduce runtime overhead (in execution time, memory, energy, etc.). Several approaches have been proposed for reducing this overhead, such as eliminating the checks that can statically be proved to always…
Instrumenting programs for performing runtime checking of properties, such as regular shapes, is a common and useful technique that helps programmers detect incorrect program behaviors. This is specially true in dynamic languages such as Prolog. However, such runtime checks inevitably introduce runtime overhead (in execution time, memory, energy, etc.). Several approaches have been proposed for reducing this overhead, such as eliminating the checks that can statically be proved to always succeed, and/or optimizing the way in which the (remaining) checks are performed. However, there are cases in which it is not possible to remove all checks statically (e.g., open libraries which must check their interfaces, complex properties, unknown code, etc.) and in which, even after optimizations, these remaining checks may still introduce an unacceptable level of overhead. It is thus important for programmers to be able to determine the additional cost due to the runtime checks and compare it to some notion of admissible cost. The common practice used for estimating runtime checking overhead is profiling, which is not exhaustive by nature. Instead, we propose a method that uses static analysis to estimate such overhead, with the advantage that the estimations are functions parameterized by input data sizes. Unlike profiling, this approach can provide guarantees for all possible execution traces, and allows assessing how the overhead grows as the size of the input grows. Our method also extends an existing assertion verification framework to express "admissible" overheads, and statically and automatically checks whether the instrumented program conforms with such specifications. Finally, we present an experimental evaluation of our approach that suggests that our method is feasible and promising.
Інші авториПодивитися публікацію -
Exploiting Term Hiding to Reduce Run-time Checking Overhead
20th International Symposium on Practical Aspects of Declarative Languages (PADL 2018).
One of the most attractive features of untyped languages is the flexibility in term creation and manipulation. However, with such power comes the responsibility of ensuring the correctness of these operations. A solution is adding run-time checks to the program via assertions, but this can introduce overheads that are in many cases impractical. While static analysis can greatly reduce such overheads, the gains depend strongly on the quality of the information inferred. Reusable libraries, i.e.,…
One of the most attractive features of untyped languages is the flexibility in term creation and manipulation. However, with such power comes the responsibility of ensuring the correctness of these operations. A solution is adding run-time checks to the program via assertions, but this can introduce overheads that are in many cases impractical. While static analysis can greatly reduce such overheads, the gains depend strongly on the quality of the information inferred. Reusable libraries, i.e., library modules that are pre-compiled independently of the client, pose special challenges in this context. We propose a technique which takes advantage of module systems which can hide a selected set of functor symbols to significantly enrich the shape information that can be inferred for reusable libraries, as well as an improved run-time checking approach that leverages the proposed mechanisms to achieve large reductions in overhead, closer to those of static languages, even in the reusable-library context. While the approach is general and system-independent, we present it for concreteness in the context of the Ciao assertion language and combined static/dynamic checking framework. Our method maintains the full expressiveness of the assertion language in this context. In contrast to other approaches it does not introduce the need to switch the language to a (static) type system, which is known to change the semantics in languages like Prolog. We also study the approach experimentally and evaluate the overhead reduction achieved in the run-time checks.
Інші авториПодивитися публікацію -
Towards Static Performance Guarantees for Programs with Run-time Checks (Extended Abstract)
34th International Conference on Logic Programming, Technical Comunications
-
Some Trade-offs in Reducing the Overhead of Assertion Run-time Checks via Static Analysis
Science of Computer Programming (SCP), Vol. 155, pages 3-26. Selected and extended papers from the 2016 International Symposium on Principles and Practice of Declarative Programming (PPDP 2016).
A number of approaches for helping programmers detect incorrect program behaviors are based on combining language-level constructs (such as procedure-level assertions/contracts, program-point assertions, or gradual types) with a number of associated tools (such as code analyzers and run-time verification frameworks) that automatically check the validity of such constructs. However, these constructs and tools are often not used to their full extent in practice due to excessive run-time overhead,…
A number of approaches for helping programmers detect incorrect program behaviors are based on combining language-level constructs (such as procedure-level assertions/contracts, program-point assertions, or gradual types) with a number of associated tools (such as code analyzers and run-time verification frameworks) that automatically check the validity of such constructs. However, these constructs and tools are often not used to their full extent in practice due to excessive run-time overhead, limited expressiveness, and/or limitations in the effectiveness of the tools. Verification frameworks that combine static and dynamic verification techniques and are based on abstraction offer the potential to bridge this gap. In this paper we explore the effectiveness of abstract interpretation in detecting parts of program specifications that can be statically simplified to true or false, as well as in reducing the cost of the run-time checks required for the remaining parts of these specifications. Starting with a semantics for programs with assertion checking, and for assertion simplification based on static analysis information obtained via abstract interpretation, we propose and study a number of practical assertion checking “modes,” each of which represents a trade-off between code annotation depth, execution time slowdown, and program safety. We then explore these modes in two typical, library-oriented scenarios. We also propose program transformation-based methods for taking advantage of the run-time checking semantics to improve the precision of the analysis. Finally, we study experimentally the performance of these techniques. Our experiments illustrate the benefits and costs of each of the assertion checking modes proposed, as well as the benefits obtained from analysis and the proposed transformations in these scenarios.
Інші авториПодивитися публікацію -
On Improving Run-time Checking in Dynamic Languages
33rd International Conference on Logic Programming (ICLP 2017), Technical Communications; CP/ICLP/SAT Doctoral Program 2017 (CP-ICLP-SAT-DP-17) entry.
In order to detect incorrect program behaviors, a number of approaches have been proposed,
which include a combination of language-level constructs (procedure-level annotations such as
assertions/contracts, gradual types, etc.) and associated tools (such as static code analyzers and
run-time verification frameworks). However, it is often the case that these constructs and tools
are not used to their full extent in practice due to a number of limitations such as excessive…In order to detect incorrect program behaviors, a number of approaches have been proposed,
which include a combination of language-level constructs (procedure-level annotations such as
assertions/contracts, gradual types, etc.) and associated tools (such as static code analyzers and
run-time verification frameworks). However, it is often the case that these constructs and tools
are not used to their full extent in practice due to a number of limitations such as excessive run-
time overhead and/or limited expressiveness. This issue is especially prominent in the context
of dynamic languages without an underlying strong type system, such as Prolog. In our work
we propose several practical solutions for minimizing the run-time overhead associated with
assertion-based verification while keeping the correctness guarantees provided by run-time checks.
We present the solutions in the context of the Ciao system, where a combination of an abstract
interpretation-based static analyzer and run-time verification framework is available, although
our proposals can be straightforwardly adapted to any other similar system -
Towards Run-time Checks Simplification via Term Hiding (Extended Abstract)
33rd International Conference on Logic Programming, Technical Comunications
-
Practical Run-time Checking via Unobtrusive Property Caching
Theory and Practice of Logic Programming (TPLP), Vol. 15, Num. 04-05, pages 726-741. Special Issue of the 31st International Conference on Logic Programming (ICLP 2015).
The use of annotations, referred to as assertions or contracts, to describe program properties for which run-time tests are to be generated, has become frequent in dynamic programming languages. However, the frameworks proposed to support such run-time testing generally incur high time and/or space overheads over standard program execution. We present an approach for reducing this overhead that is based on the use of memoization to cache intermediate results of check evaluation, avoiding…
The use of annotations, referred to as assertions or contracts, to describe program properties for which run-time tests are to be generated, has become frequent in dynamic programming languages. However, the frameworks proposed to support such run-time testing generally incur high time and/or space overheads over standard program execution. We present an approach for reducing this overhead that is based on the use of memoization to cache intermediate results of check evaluation, avoiding repeated checking of previously verified properties. Compared to approaches that reduce checking frequency, our proposal has the advantage of being exhaustive (i.e., all tests are checked at all points) while still being much more efficient than standard run-time checking. Compared to the limited previous work on memoization, it performs the task without requiring modifications to data structure representation or checking code. While the approach is general and system-independent, we present it for concreteness in the context of the Ciao run-time checking framework, which allows us to provide an operational semantics with checks and caching. We also report on a prototype implementation and provide some experimental results that support that using a relatively small cache leads to significant decreases in run-time checking overhead.
Інші авториПодивитися публікацію -
Assertion-based Debugging of Higher-Order (C)LP Programs
16th International ACM SIGPLAN Symposium on Principles and Practice of Declarative Programming (PPDP 2014)
Higher-order constructs extend the expressiveness of first-order (Constraint) Logic Programming ((C)LP) both syntactically and semantically. At the same time assertions have been in use for some time in (C)LP systems helping programmers detect errors and validate programs. However, these assertion-based extensions to (C)LP have not been integrated well with higher-order to date. This paper contributes to filling this gap by extending the assertion-based approach to error detection and program…
Higher-order constructs extend the expressiveness of first-order (Constraint) Logic Programming ((C)LP) both syntactically and semantically. At the same time assertions have been in use for some time in (C)LP systems helping programmers detect errors and validate programs. However, these assertion-based extensions to (C)LP have not been integrated well with higher-order to date. This paper contributes to filling this gap by extending the assertion-based approach to error detection and program verification to the higher-order context within (C)LP. We propose an extension of properties and assertions as used in (C)LP in order to be able to fully describe arguments that are predicates. The extension makes the full power of the assertion language available when describing higher-order arguments. We provide syntax and semantics for (higher-order) properties and assertions, as well as for programs which contain such assertions, including the notions of error and partial correctness. We also discuss several alternatives for performing run-time checking of such programs.
Інші авториПодивитися публікацію -
Towards Assertion-based Debugging of Higher-Order (C)LP Programs (Extended Abstract)
30th International Conference on Logic Programming, Technical Communications
Відзнаки та нагороди
-
Cum Laude Distinction for the PhD degree
Technical University of Madrid (UPM)
Мови
-
Ukrainian
Рідна мова або володіння двома мовами
-
English
Повний професійний рівень володіння
-
Spanish
Професійний рівень володіння, достатній для роботи
-
German
Обмежений рівень володіння, достатній для роботи
Отримані рекомендації
5 людей рекомендують Nata
Приєднайтеся зараз, щоб переглянутиБільше активності від Nata
-
I wish the personal cemeteries did not grow at this scale and could all still be talking science and business here y'all
I wish the personal cemeteries did not grow at this scale and could all still be talking science and business here y'all
Поширено Nata Stulova
-
Last week, Dnipro University of Technology hosted an innovative and creative event - E-Formula. IT Dnipro Community was happy to be a partner and…
Last week, Dnipro University of Technology hosted an innovative and creative event - E-Formula. IT Dnipro Community was happy to be a partner and…
Вподобано Nata Stulova
-
#Open_data development has been uneven across the globe. Over the last decade, social scientists debated its relevance for democracy, its meaning for…
#Open_data development has been uneven across the globe. Over the last decade, social scientists debated its relevance for democracy, its meaning for…
Вподобано Nata Stulova
-
A bit over two years into this war-work-life balance thing, et voilà: I'm extra happy++ to share that our recent paper with Ivan Petrukha and Sergii…
A bit over two years into this war-work-life balance thing, et voilà: I'm extra happy++ to share that our recent paper with Ivan Petrukha and Sergii…
Поширено Nata Stulova
-
Найбільша в Європі конференція для жінок у сфері IT&TECH Perspektywy Women in Tech Summit 2024 вже 12 i 13 червня у Варшаві! Зустрінуться…
Найбільша в Європі конференція для жінок у сфері IT&TECH Perspektywy Women in Tech Summit 2024 вже 12 i 13 червня у Варшаві! Зустрінуться…
Вподобано Nata Stulova
-
Who would have thought that "publish or perish" is a terrible practice *sarcasm* https://lnkd.in/etrccaNr
Who would have thought that "publish or perish" is a terrible practice *sarcasm* https://lnkd.in/etrccaNr
Опубліковано Nata Stulova
-
Discovery of the day: PDF is not the only option for reading preprints on arXiv <3 Minor rendering bugs in floats, yes, but just clicking on a…
Discovery of the day: PDF is not the only option for reading preprints on arXiv <3 Minor rendering bugs in floats, yes, but just clicking on a…
Поширено Nata Stulova