61 research outputs found
The Art of Creating Code-Based Artworks
Full text linkProgramming has become an artistic medium for artists; it provides expression possibilities built on top of the computer's interactivity and multimedia features. However, implementing code-based artworks encloses defining characteristics that differ from traditional programming. This paper reports on an in-depth interview with 5 code artists with diverse backgrounds, levels of experience, and working on different code-based artistic expressions. Through their experience, we identified characteristics and commonalities in their development process, the tools they use, their sources of inspiration, and their expectations. Accordingly, we reflect on the particularities of Creative Coding, indicate commonalities with other domains, and suggest opportunities and challenges for HCI researchers and practitioners in proposing tools to support it better
Block-based platform for defining adaptation rules for automotive systems
Full text linkAdaptive human-machine interfaces (HMIs) enhance driver safety and comfort by tailoring information presentation. While existing research identifies key adaptation parameters, their practical application remains challenging due to the complexity of rule-based decision making and the limitations of current authoring tools. To address these issues, this paper introduces AHSL, a domain-specific language for efficiently specifying message adaptation logic. By unifying established adaptation parameters within a hierarchical structure, AHSL simplifies rule creation and improves readability. Usability testing demonstrates AHSL's effectiveness in supporting intuitive and efficient decision logic development
Suppose you had blocks within a notebook
Full text linkComputational notebooks have been gaining prominence as a development environment suitable for non-experienced developers. However, it requires proficiency in writing syntactically and semantically correct code. In this article, we propose integrating a block-based approach into computational notebooks to prevent syntactical errors and ease the non-expert developers’ adoption. Furthermore, we rely on two tools previously implemented (Bacatá and Kogi) to (i) create a computational notebook for Domain-Specific Languages and (ii) generate a block-based representation upon the language definition. Consequently, our approach does not exclusively focus on integrating a block-based environment into computational notebooks but on enabling the creation and integration of domain-specific block-based environments into notebooks. Future work concerns the evaluation of our proposal through a user study
Engineering Language-Parametric End-User Programming Environments for DSLs
Full text linkHuman-computer communication can be achieved through different interfaces such as Graphical User Interfaces (GUIs), Tangible User Interfaces (TUIs), command-line interfaces, and programming languages. In this thesis, we used some of these inter- faces; however, we focused on programming languages which are artificial languages consisting of instructions written by humans and executed by computers. In order to create these programs, humans use specialized tools called programming environments that offer a set of utilities that ease human-computer communication. When creating programs, users must learn the language’s syntax and get acquainted with the pro- gramming environment. Unfortunately, programming languages usually offer a single user interface or syntax, which is not ideal considering different types of users with varied backgrounds and expertise will use it. Given the increasing number of people performing any kind of programming activity, it is important to offer different inter- faces depending on the programming task and the background of the users. However, from the language engineering point of view, offering multiple user interfaces for the same language is expensive, and if we specifically consider Domain-Specific Languages (DSLs), it is even more expensive given their audience and development teams’ size. Therefore, we study how to engineer different user interfaces for DSLs in a practical way.This thesis presents different mechanisms to engineer different language-parametric programming environments for end-users. These mechanisms rely heavily on reusing existing language components for existing languages or helping language engineers define these interfaces for new languages. We mainly studied four technological spaces, namely, Grammarware, Computational Notebooks, Block-based environments, and Projec- tional editors. We present three different language-parametric interfaces for interacting with DSLs, namely computational notebooks, projectional editors, and block-based editors. These interfaces offer different user experiences and rely upon different technological spaces. Different notations are associated with different technological spaces; for in- stance, grammarware is associated with text files, while block-based environments are associated with Blockly and JavaScript files. Therefore, to provide different notations for their languages, we have to "space travel" so that language engineers can select the most appropriate technological space and interface for their target audience. To support this, we defined grammarware as a common starting point to allow traveling to different technological spaces (e.g., computational notebooks space, projectional editors space, or block-based space). Based on this idea, we developed three tools that allowed language engineers to generate different interfaces for their DSLs based on a grammar definition of the language. Our results show that it is possible to generate these different user interfaces and decrease the effort required to create these. However, additional research is required to improve the usability of the generated interfaces and make the generation of these interfaces more flexible so that users’ data can be used as part of the generated interfaces
Migrating jee applications to a microservice-based architecture deployed in the cloud
No full textMagíster en Ingeniería de SoftwareMaestrí
maveme/bacata-demos: First release
No full textSet of Rascal DSLs that can be used in Jupyter notebooks using Bacat
Engineering Language-Parametric End-User Programming Environments for DSLs
No full textHuman-computer communication can be achieved through different interfaces such as Graphical User Interfaces (GUIs), Tangible User Interfaces (TUIs), command-line interfaces, and programming languages. In this thesis, we used some of these inter- faces; however, we focused on programming languages which are artificial languages consisting of instructions written by humans and executed by computers. In order to create these programs, humans use specialized tools called programming environments that offer a set of utilities that ease human-computer communication. When creating programs, users must learn the language’s syntax and get acquainted with the pro- gramming environment. Unfortunately, programming languages usually offer a single user interface or syntax, which is not ideal considering different types of users with varied backgrounds and expertise will use it. Given the increasing number of people performing any kind of programming activity, it is important to offer different inter- faces depending on the programming task and the background of the users. However, from the language engineering point of view, offering multiple user interfaces for the same language is expensive, and if we specifically consider Domain-Specific Languages (DSLs), it is even more expensive given their audience and development teams’ size. Therefore, we study how to engineer different user interfaces for DSLs in a practical way.This thesis presents different mechanisms to engineer different language-parametric programming environments for end-users. These mechanisms rely heavily on reusing existing language components for existing languages or helping language engineers define these interfaces for new languages. We mainly studied four technological spaces, namely, Grammarware, Computational Notebooks, Block-based environments, and Projec- tional editors. We present three different language-parametric interfaces for interacting with DSLs, namely computational notebooks, projectional editors, and block-based editors. These interfaces offer different user experiences and rely upon different technological spaces. Different notations are associated with different technological spaces; for in- stance, grammarware is associated with text files, while block-based environments are associated with Blockly and JavaScript files. Therefore, to provide different notations for their languages, we have to "space travel" so that language engineers can select the most appropriate technological space and interface for their target audience. To support this, we defined grammarware as a common starting point to allow traveling to different technological spaces (e.g., computational notebooks space, projectional editors space, or block-based space). Based on this idea, we developed three tools that allowed language engineers to generate different interfaces for their DSLs based on a grammar definition of the language. Our results show that it is possible to generate these different user interfaces and decrease the effort required to create these. However, additional research is required to improve the usability of the generated interfaces and make the generation of these interfaces more flexible so that users’ data can be used as part of the generated interfaces
Una plataforma web para la ejecución en paralelo de algoritmos de optimización
No full textIngeniero de Sistemas y ComputaciónPregrad
Migrating jee applications to a microservice-based architecture deployed in the cloud
No full textMagíster en Ingeniería de SoftwareMaestrí
PescaJ: A projectional editor for Java featuring scattered code aggregation
Full text linkConventionally, source code (and its documentation) is simultaneously a storage and editing representation, through files and editors to manipulate them as text. Over the years, IDEs have become increasingly sophisticated, providing features to augment the visible text content with helpful information (e.g., overlay documentation popups, inlay type hints), or on the opposite, to decrease it to reduce clutter (e.g., code folds on imports, documentation, methods, etc). This is a sign that the developers seek more convenient code editing forms than the direct manipulation of text files.
We present PescaJ, a prototype projectional editor for Java projects that breaks away from file-oriented source code editing, providing the possibility of forming views that aggregate methods that belong to different classes, where single methods may be simultaneously present and edited in multiple views. Furthermore, we provide documentation editors, also aggregating scattered Javadoc comments, that can be used in parallel with source code editing.info:eu-repo/semantics/acceptedVersio
- …
