Follow the seminar announcements by joining our Google group.
Composing Organizational Patterns More Precisely
Waheedullah Sulaiman Khail (ÚISI FIIT STU)
July 19, 2021, 9am–10am, https://fiit-stu.webex.com/meet/vranic
Organizing people is very important and one of the great challenges, and particularly in software development. Organizational patterns document organizational knowledge, which can be used to build an organization from the start or solve existing issues within organizations. Although patterns in isolation are not uncommon, they are more effective when they are composed and applied together in sequences. In order to apply organizational patterns, one has to understand not only the patterns, but also the relationships between them. Although there has been much research done on the patterns and how patterns are applied, little work has been done in finding out the relationships between patterns. What the thesis reported in this paper states is that if organizational patterns are composed more precisely, that will improve the accessibility, comprehensibility, and applicability of the organizational knowledge. The main contributions of the thesis are all in favor of the thesis statement: identifying the relationships between patterns in a pattern format makes these relationships explicit, using text mining techniques and natural language processing techniques helps identify and extract further relationships between patterns, formalizing the relationships between patterns with a context free grammar makes the relationships exact, while applying the pattern format once again to capture whole pattern languages makes them more comprehensible. Each of the approaches was evaluated on nontrivial examples. Additionally, a comprehensive study involving thirty participants from ten organizations and five countries was conducted. It embraced sixteen organizational patterns. Furthermore, a scenario was developed where these approaches were applied in synergy. The study results confirm that applying the approaches proposed in the thesis reported here makes organizational knowledge more accessible, comprehensible, and applicable. These approaches also help practitioners navigate through patterns. which allow them to identify, learn, and apply proven techniques in their organizations.
Waheedullah Sulaiman Khail. Use Case Driven Modularization . Information Sciences and Technologies Bulletin of the ACM Slovakia, 2021.
Description and Identification of Software Project Anti-Patterns
Přemek Brada (University of West Bohemia)
November 11, 2019, 3.30–4.30pm, Meeting room 4.08
For software project managers and other practitioners, an important activity is to detect, and consequently find solutions to, insufficiencies and mistakes in process and other project management activities. Particularly interesting among these are anti-patterns: commonly occurring solutions with known negative effects. In this workshop we will first review the anti-patterns existing in known sources, their variations in terminology and description format, relation to software development methodologies. We will present and discuss the design of an online catalogue of project management and process anti-patterns, based on the knowledge obtained from the review. Then, a method of detecting process and project management anti-patterns in project data will be described, based on a model for pattern operationalization over data extracted from application lifecycle management tools used by a software project.
Software Visualization and City Metaphors
Clinton Jeffery (University of Idaho, USA)
May 31, 2019, 10.00–11.30am AdvanSD Lab (3D Lab), Room 3.38
A city metaphor has become a popular method of visualizing properties of program code. Thus far projects employing the city metaphor have primarily focused on visualizing static and dynamic properties of software repositories, also how a programs source code structure is changing over time, and who is changing what. This workshop will feature several software visualization methods of software city, also in augmented and virtual reality. We will discuss an overview of research projects that employ this metaphor for a wide range of software engineering tasks, future experiments, and the evaluation of these methods.
Modeling and Visualization in Software Engineering
Michel Chaudron (Chalmers University in Gothenburg, Sweden), Rodi Jolak (Chalmers University in Gothenburg, Sweden), http://www.rodijolak.com/ Juraj Vincúr (ÚISI FIIT STU), and Ivan Polášek (ÚISI FIIT STU)
April 17, 2019, 10.30-11.30am / 1–2pm, AdvanSD Lab (3D Lab), Room 3.38
This workshop will feature several software visualization methods, tools, and prototypes employing augmented reality, collaborative sketching, and modeling in virtual reality. We will discuss future experiments and the evaluation of these methods, tools, and prototypes using NASA-TLX, EEG, and eye tracking, in a broader context of empirical studies into the effectiveness of modeling in software design.
Initial Results and Further Experimentation
Nghia Pham van (ÚISI FIIT STU)
March 14, 2019, 3–4pm, Meeting room 4.08
For a successful support of peripheral perception in distributed teams by automatic message displaying in chat, it is crucial to filter irrelevant communication. This can be achieved by using up-to-date information about the developers’ work context. For this, the developers’ activity via created and accessed artifacts and code repository changes are continuously monitored. The correctness of comparing the context to chat messages is improved by taking into account synonyms and related words. Initial results based on a small-scale experiment are promising, The main topic of this seminar is the design and planned assessment of more extensive experiments, which are to be conducted with several teams.
Experience Drama Patterns
January 29, 2019, 6–8pm, Meeting room 4.08
The knowledge of drama building is somehow an inherent part of us. Albeit, it tends to be suppressed and forgotten. This is leveraged by a common, director or instructor supervised approach, which favors learning lines to produce them without making a mistake. But the essence of drama is in archetypal situations that tend to repeat over and over without ever being the same. These are known as patterns and are best established in software development, although their origins are in Christopher Alexander's approach to building architecture. Transposed into drama, the patterns set frames within which the actors act, but they also give them a freedom to develop their roles in a natural and unaffected way in accordance with Stanislavski's approach. In this seminar, we will experience some of the drama patterns, such as Reversed Advantage, Amazing Similarity, Disbelieved Identity, Reflection, or Thoughts Reflecting Environment, and discuss their potential.
Adapting Domain Driven Design to Game Development
Martin Fris and Jozef Hrnčár (Pixel Federation)
November 26, 2018, 3–4pm, Meeting room 4.08
Domain Driven Design (DDD)—a new approach to building complex software—has become quite popular in recent years. This is happening mainly in scenarios when complex business domains like automotive or transportation, which need to be modeled and automated. Currently, DDD is spreading even into smaller scale projects, whose lifetime is planned to span over multiple years and their domain is complex enough not to use CRUD based architecture. DDD focuses on connecting domain experts with developers in the process of domain modeling, strongly emphasising the domain language. DDD also looks at the domain from multiple contexts, which helps creating easier maintainable models, even while using ambiguity. From the implementation point of view, DDD isolates domain level code from everything technical (called the infrastructure layer), which improves control over software complexity.
Since Pixel Federation games’ lifetime spans over multiple years and the specific parts of the game domain change quite often, it is crucial to implement the projects as flexible as possible. We try to achieve this using DDD, which promises better gains in maintainability in long term. By isolating the domain complexity in the domain model and making it independent of the infrastructure layer, we achieved higher control over software complexity which grows each year by adding new use cases and changing the old ones. We also try to gain from the other strong parts of DDD and would like to talk about our journey towards releasing our first two projects using this methodology. Our use cases—games—aren’t the ideal case for an off the book implementation of DDD, so we needed to make a few alterations in the officially recommended implementation patterns, which would make a better fit for our use case.
Use Case Driven Modularization
Michal Bystrický (ÚISI FIIT STU)
July 9, 2018, 11am–12.30pm, Meeting room 3.08
How well is software comprehensible and maintainable is highly dependent on code modularity. Common object-oriented modularity, for instance, puts forward technical concerns such as reusability, but mystifies other concerns, especially usage scenarios, which greatly help with comprehending software systems, but they are completely dissolved in code. Although there are approaches able to modularize code according to use cases, they fail to gather all the code related to a use case in one module and to reflect its steps. Such modularization would improve software comprehensibility and maintainability. This talk briefly introduces use case driven modularization approaches achieving this. Multiple studies were conducted to evaluate the proposed approaches. Use case driven modularization requires less effort to follow code and to apply a change in code than common object-oriented modularization. DCI and aspect-oriented software development with use cases add more complexity to following a use case flow in code than the use case driven modularization approach.
Michal Bystrický. Use Case Driven Modularization . Information Sciences and Technologies Bulletin of the ACM Slovakia, 2018.
Complex Networks in Software Systems
Miloš Savić (University of Novi Sad, Serbia)
July 3, 2018, 2–3.30pm, Meeting room 3.08
Modern software systems are complex artifacts. The complexity of a large-scale software system stems not only from a large number of software entities (packages, modules, classes, interfaces, functions, variables, and so on) defined in its source code, but also from dependencies among those entities. More specifically, we can distinguish two layers of complexity in software systems: the internal (algorithmic) complexity of software entities (e.g. the complexity of control flow within an entity) and the structural (design) complexity of dependencies among software entities. Dependency structures present in a software system can be modeled by various types of software networks which provide different granularity views to the architecture of the system. Analysis of software networks can help software engineers and researchers to understand and quantify software design complexity and evaluate software systems according to software design quality principles. In this talk, we present a novel network-based methodology to analyze software systems. The proposed methodology utilizes the notion of enriched software networks, i.e. software networks whose nodes are augmented with metrics vectors containing both software metrics and metrics used in complex network analysis. The proposed methodology is empirically evaluated on enriched software networks that represent large-scale Java software systems at different levels of abstraction.
Miloš Savić, Mirjana Ivanović, and Lakhmi C. Jain. Complex Networks in Software, Knowledge, and Social Systems. Springer, 2018.
Peripheral Perception in Distributed Software Development: Work Context, Written Electronic Communication, and Visual Stimuli
Nghia Pham van and Gabriela Hózová (ÚISI FIIT STU)
April 19, 2018, 11am–12pm, Room 1.40
Peripheral perception, in which developers and possibly other stakeholders effortlessly get the information from their working environment without a direct participation in communication probably accounts for the most of communication effectiveness and efficiency in agile software development. Here, we look at how peripheral perception can be utilized in distributed teams via written electronic communication, such as chat or e-mail, and visual stimuli, which embraces the presence of other people nearby, but also the activity of team members. Software development is a complex process where various artifacts are created and used by developers. These artifacts, combined with the developers' intent, environment, other team members' work, and various other factors, contribute to creating and maintaining a work context. In a team, a shared work context exists between its members, but each member also has a personal work context that changes over time. This personal work context, if properly extracted, can be a rich source of information for filtering written electronic communication and visual stimuli for their relevance to peripheral perception.
Composing Organizational Patterns
Waheedullah Sulaiman Khail (ÚISI FIIT STU)
January 17, 2018, 3.30–4.30pm, Meeting room 4.08
Much of the research work on organizational patterns has been focused on discovering and documenting organizational patterns. With organizational patterns, we can build an organization, plug a gap, or correct a hole in an organization. To get the most out of organizational patterns, we need to develop techniques for composing organizational patterns. These techniques should define a composition mechanism through which organizational patterns can be integrated, which will help in the application of organizational patterns. In this presentation, we will talk about the need for organizational pattern composition. We will also look into how patterns from other domains are composed. Furthermore, we propose to formalize the pattern relationship with a pattern language grammar, which will help in creating pattern sequences.
Enhanced and Adaptable Collaboration over Multilevel Interrelated Heterogeneous Software Knowledge
Valentino Vranić (ÚISI FIIT STU)
November 6, 2017, 2–3pm, Meeting room 4.08
Software development is an extremely complex activity that involves working with large amounts of heterogeneous data. This includes source code, formal and informal specification documents, and models, but also examples of application domain documents or other artifacts. All these artifacts embody software knowledge. But what really makes knowledge out of these heterogeneous data is how they are related, which mostly remains unrecorded, consequently relying on human memory.
We envision an approach that will mitigate this by providing a way to interrelate all artifacts that embody software knowledge in a non-invasive, yet tangible way orthogonal to the use of other software development tools. Software knowledge is interrelated at multiple levels not only in terms of general software dependencies and meta to instance level relationships, but also in numerous domain specific ways. For this, a layered 3D representation comes out as a natural choice. An implied 3D visual environment would consequently act as a collaboration space for all participants in software development with a possibility to be enhanced with generic and custom analyzers and generators over the captured software knowledge. Human related part of software knowledge – both implicit (who works or has worked on what and when) and explicit (communication traces) – could be visualized, too, and used to improve shorten communication paths relying on peripheral perception, which accounts for the effectiveness of agile software development, and which is almost completely lacking in distributed teams.
All this would involve working with large amounts of most often sensitive data, so it would be necessary to incorporate security and privacy, as well as safety and overall quality aspects.
Algorithms for Decision Trees in Refactoring Systems
Lukáš Hamacek, Miroslav Haščič, and Ivan Polášek (ÚISI FIIT STU)
October 27, 2017, 1–2pm, Meeting room 3.08
This presentation analyses abilities of selected algorithms to find the minimal path in a decision tree containing refactoring combinations and sequences of removed anti-patterns or bad smells (removing bad smell can reduce or induce another bad smell). We will compare the A* algorithm, artificial bee colony (ABC) algorithm, and ant colony optimization (ACO) algorithm. Part of our work is reducing complexity of these algorithms, their parallelization, and their enhancement with fuzzy logic. In future, we will implement these algorithms in our refactoring tool using a rule based approach.
Inception Phase Software Modeling Support
Pavel Sluka and Ján Lang (ÚISI FIIT STU)
June 6, 2017, 3–4pm, Meeting room 4.08
In the introductory phase of software development it is essential to sufficiently capture customers' requirements. The challenge is not only in capturing requirements, but also in representing them in an appropriate way. Commonly, requirements are modeled by a detailed use case description and their visualization in the form of UML use case diagrams. An interesting way to capture cognitive ideas is also through mind mapping. The possibility of transformation mind maps into UML class diagrams has already been explored. Here, we will look at the possibilities to gain behavioral aspects from mind maps. Finally, our proposed transformations have succeeded in acquiring interesting behavioral model artifacts.
Configuring and Composing Existing Software Components According to Natural Language Specifications
Michal Kráľ (ÚISI FIIT STU)
May 17, 2017, 3–4pm, Meeting room 4.08
Existing approaches that target natural language programming force programmers to use specific language intended, and, moreover, they do not support defining complex specifications. In this presentation, we will demonstrate a new approach to natural language programming addressing these two problems. The approach employs keyword based and sentence similarity text processing methods to extract the information from a natural language specification. Subsequently, it configures and composes existing software components according to this information. The approach opens the possibilities for extensive natural language programming support. Combining the approach with user interface generation tools is particularly promising.
Abstract Layers as a Basis for Versatile Graphical Software Modeling
Adam Neupauer and Valentino Vranić (ÚISI FIIT STU)
March 20, 2017, 3–4pm, Meeting room 4.08
Graphical software modeling serves a broad spectrum of purposes ranging from conceptualization of ideas to executable models. Apart from UML as a general purpose modeling notation, there is a growing tendency towards domain specific modeling languages. Freedom to chose different kinds of visualization some of which are even three-dimensional, seems to be essential. What models actually represent and how this can be used further constitutes another varying perspective: interpretation. To accommodate this versatility in visualization and interpretation, a sufficiently general internal representation is necessary. Pages in a book, sheets of paper in general, blackboards in a classroom, or even diagrams in contemporary software modeling tools, they all indicate layering as a way of coping with complexity is natural to humans. Making layers and elements they consist of, along with their relationships, abstract and allowing them to be visualized and interpreted in different ways might be a key to the internal representation we look for. From this point of view, it seems that the main problem of common approaches to graphical software modeling is interweaving visualization, interpretation, and internal representation, or giving priority to the former two over the internal representation.
Collaborative Software Modelling and Extended UML Model Visualization
Matej Ferenc and Jakub Ondik (ÚISI FIIT STU)
March 6, 2017, 3–4pm, Meeting room 4.08
Standard software modelling tools support basic UML diagram visualization and isolate activities of developers via locks in a shared software model or in their own versions of a software model. Thus, developers have restricted collaboration possibilities, e.g. developers are not allowed to edit the same diagram and they must manually compare versions of UML diagrams to identify and review modifications. We will discuss possibilities of real-time collaboration in software modelling, visualization of UML diagrams in multiple dimensions, and adaptable visualization of modifications in UML diagrams with their explanations.
Bringing Virtuality to Software Development – Benefits and Practical Demonstrations
Juraj Vincúr (ÚISI FIIT STU)
December 14, 2016, 4–5pm, 3D SD Lab (3.38-2)
Software is virtual and intangible complex structure difficult to understand, which hinders its development. Graphical visualization of software has the potential to result in a better and faster comprehension of its design and functionality. 2D software visualizations have actually been the subject of many studies and began to appear in commercial products, but the recent trend is to explore 3D software visualizations. Existing 3D approaches are mainly criticized due to intrinsic 3D navigation problems that amplify possible information overload. The latest breakthroughs in virtual and augmented reality bring new devices capable of intuitive interaction with 3D objects in both virtual or augmented reality environments. We will discuss the main benefits of the third dimension in software visualizations, potential of their migration to virtual and augmented environments, related problems, and possible solutions. For these purposes, we will present an HTC Vive head-mounted display, which is available in our 3D software development lab, its features and limitations, how to develop software for it, and its applications. Selected aspects will be demonstrated on few early prototypes of both web and desktop applications.
TRACKS and DevACTs Infrastructures for Collecting, Making Accessible, and Analyzing Software Development Data
Karol Rástočný and Martin Konôpka (ÚISI FIIT STU)
December 7, 2016, 1.30–2.30pm, UISI meeting room (3.08)
Data about software development process are stored in different repositories, e.g., source code and its versions are stored in version control systems like Git or SVN, tasks and plans are stored in issue tracking systems like Jira or Bugzilla, same with code reviews, activities and CQA systems. These data sources are loosely interconnected, mostly only by textual reference in description (e.g., a task’s identifier in a commit message), and expose different APIs. This imposes challenges for mining, linking and reasoning upon such data across data sources. These problems are addressed by the TRACKS infrastructure, which uses a distributed architecture for mining, representing, storing, and reasoning upon data from various data sources about software development, with the main focus on linking these data sources together. Linked data about software development process are a good prerequisite for solving and evaluating multiple research problems, but they contain only discrete, resultant information about the process. More detailed information can be discovered from developers’ activities. These activities are collected and interpreted by the DevACTs infrastructure.
Transforming Organizational Patterns into a Comprehensible and Immersive Format
Tomáš Frťala (ÚISI FIIT STU)
December 2, 2016, 2.30–3.30pm, UISI meeting room (3.08)
Organizational patterns show us how to solve a problems caused by forces in a specific context. By utilizing organizational patterns in a right way, an organization can become agile and lean while preserving its own culture. This can be achieved fully only if all stakeholders comprehend them. Mastering organizational patterns is challenging because of several reasons. One of them is the way they are presented in a text form. Further, organizational patterns deal mainly with dynamic forces from the sociological perspective in the domain of software engineering and thus cover many interpersonal contexts, which people find difficult to associate with their own experience. We proposed a method of transforming organizational patterns into their animated version. Pattern dynamics are modeled at multiple levels using UML state machine diagrams. Interactions are ensured as in text adventure games. Mediation of experience is supplemented by the use Erickson’s conversational hypnosis language patterns. Method was used to transform six selected organizational patterns, which revealed the necessity to deal with pattern variants and to express their relationships in an object-oriented fashion. The method is intended to be usable by a broader community to easily produce animations of further organizational patterns.
Presenting Organizational Pattern Languages More Precisely
Waheedullah Sulaiman Khail (ÚISI FIIT STU)
November 23, 2016, 1.30–2.30pm, UISI meeting room (3.08)
Organizing people in an organization is very important and one of the great challenges. Organizational patterns are the key to piecemeal growth of the organization or growing the organization incrementally. They can be applied to correct a specific problem within an organization or to build a new organization from scratch. Patterns are existing from late 70’s, yet there are difficulties implementing patterns and putting the right pattern in the right context which will contribute to the wholeness of some whole. Different reasons have been identified by researchers which include the understanding of pattern itself as well. While patterns are difficult to understand their implementation is even more difficult as it is very important to identify the pattern for the specific problem. Understanding the relationship between patterns and choosing the right pattern is very important. There are different way and explanations given to follow in selecting the right pattern for your problem, however it is still confusing and most often recursion occur and one will be in the middle of injecting some patterns and losing their way and forgetting where they have started and what is the main goal. Easy ways of understanding the relation between patterns and switching between patterns should be recommended. We should put patterns together based on some rules to get an organizational pattern language which will clearly illustrate the role of every pattern in the organizational pattern language, the importance of the pattern in the organizational pattern language and its relation with other patterns in the organizational pattern language. one way of representing organizational pattern language can be a pattern itself, which will be illustrating organizational pattern language through state machine.
Overview of Research at School of Computing in Pilsen, Czech Republic
Přemek Brada (University of West Bohemia)
September 27, 2016, 5pm, Room 4.26
The talk will provide an overview of research performed at the School of Computing, Faculty of Applied Sciences in Pilsen. More focus will be provided on software analysis and verification, software visualization and process analysis.
Přemek Brada is associate professor in software engineering, leader of the Reliable Software Architectures group and currently serves as the Head of Department.
Behavioral Tests Employed in Literal Use Case Driven Modularization
Michal Bystrický (ÚISI FIIT STU)
June 23, 2016, 3–4pm, Meeting room 4.08
The intent is well readable from use cases. Literal use case driven modularization employs use cases as modules in code making the intent visible right in code. We further expose the intent by adding behavioral tests into code, which seem to be low-level use cases, in addition to use cases. In the demonstration, we will present a new tool that supports behavioral tests in literal use case driven modularization. The tool allows to gather and synchronize these artifacts (use cases, code and tests), and enforce consistency among them.
Agilné prístupy a modelovanie softvéru
Peter Šinkovič (Managing partner, ideas2markets, s.r.o)January 1, 2015, 5–7pm, UISI meeting room (3.08)
V kontexte súčasnej rýchlej doby, kedy je kladený čoraz väčší nárok na dodanie softvéru v krátkej dobe a vysokej kvalite, je potrebné, aby sa zmenili aj prístupy ku tvorbe požiadaviek na takýto softvér, jeho technické popísanie, realizáciu implementácie a testovanie. Agilné prístupy pomáhajú nastaviť prostredie tak, aby bol výsledný produkt dobre naimplementovaný a popísaný, pričom sa splnili očakávania zákazníka na jednotlivé funkcionality systému. Pri komplexných požiadavkách je veľmi ťažké myslieť na všetko dopredu a preto tak zadanie, špecifikácia, modelovanie, ako aj vývoj a testovanie prebiehajú v iteráciách. Výsledkom je maximalizovanie biznisovej hodnoty produktu.
Animating Organizational Patterns
Tomáš Frťala (ÚISI FIIT STU)May 6, 2015, 2–3pm, UISI meeting room (3.08)
Organizational patterns are the key to a stepwise adoption of agile and lean approaches and to a piecemeal growth of agile and lean organization of work. However, their text description is not easy to comprehend. In this paper, we introduce our initial efforts towards establishing an approach to animate organizational patterns as text adventure games. Players pass through a series of scenes described using Erickson's conversational hypnosis language patterns in order to better evoke their experience. The game scenario space is expressed using UML state machine diagrams. The approach is presented on adventure games we created for the Architect Also Implements organizational pattern.
Prípady použitia ako cesta k čitateľnému zdrojovému kódu
Michal Bystrický (ÚISI FIIT STU)
April 8, 2015, 2–3pm, UISI meeting room (3.08)
Zmeny vo vývoji softvéru sú časté, najmä pri agilných prístupoch, ktoré by mali byť adaptabilné a flexibilne odpovedať na zmenu. Tieto zmeny vyžadujú časté zásahy do kódu, preto by kód mal byť čitateľný a zároveň modulárny. Objektovo-orientované programovacie jazyky dosahujú modulárnosť fragmentovaním kódu do tried, avšak čítať taký kód vyžaduje veľa úsilia, pretože tento kód je zložený z veľa fragmentov a referencii. Prípady použitia vďaka ich podobnosti k zdrojovému kódu a vysokej čitateľnosti predstavujú cestu, ako dosiahnuť obe vlastnosti čitateľnosti a modulárnosti naraz. Ukážeme nový prístup k modularizácii podľa prípadov použitia taký, že textová forma prípadov použitia ako ju poznáme môže byť súčasťou kódu a nielen to, ale aj môže kód ovplyvňovať. Takto dosiahneme čitateľný zdrojový kód. Dokonca, takýto kód dokáže upravovať aj koncový používateľ.