Finish requirements analysis, add abstract

content/abstract_en.typ

@@ -1,4 +1,3 @@
-Note:
-  1. *paragraph:* What is the motivation of your thesis? Why is it interesting from a scientific point of view? Which main problem do you like to solve?
-  2. *paragraph:* What is the purpose of the document? What is the main content, the main contribution?
-  3. *paragraph:* What is your methodology? How do you proceed?
+In modern development workflows, the seamless integration of UML diagrams into documentation, issues, and pull requests on Git hosting services is crucial for clarity and collaboration. Apollon is a web-based UML modeling editor used to create such diagrams. It lacks version management and doesn't provide the possibility to export live embeddings of diagrams. Apollon also doesn't provide an IDE integration.
+
+This project aims to significantly enhance Apollon by implementing efficient embedding capabilities, allowing developers to embed their UML diagrams with live updates in issues and pull requests. When a user publishes a new version of a diagram in Apollon, the system will automatically reflect these changes in their embedded diagram, eliminating the need for manual updates. We will introduce version management, which will enable users to capture new versions, preview changes, and revert to previous versions. An IDE extension, integrated with VSCode, will facilitate developers in versioning their UML diagrams with Git for seamless documentation integration. These enhancements will improve Apollon's usability, encouraging its adoption in development workflows.

content/requirements_analysis.typ

@@ -10,7 +10,7 @@ This chapter presents a detailed Requirements Analysis for the development of th
 == Overview
 The purpose of our proposed embedding feature for the standalone Apollon editor is to provide users with a seamless Git integration, in order to motivate the usage of UML diagrams in issues and pull requests. This results in a collaborative setting, where diagrams may need to be iteratively updated, which is facilitated by version management. The Apollon VSCode extension enables an IDE integration of Apollon, to assist developers with creating and maintaining UML diagrams for documentation purposes.
 
-The overarching objective is to take steps forward in the direction of making Apollon a viable tool for students and the industry as a solution for their UML modeling needs. A successful outcome for this project is positive feedback for new features and an increase in usage of Apollon.
+The goal is to take steps forward in the direction of making Apollon a viable tool for students and the industry as a solution for their UML modeling needs. A successful outcome for this project is positive feedback for new features and an increase in usage of Apollon.
 
 == Requirements
 
@@ -89,25 +89,71 @@ Use case modeling helps capture the functional requirements of a system. Use cas
 
 The intended users of the standalone Apollon editor and the Apollon VSCode extension are students and developers from the industry. Both types of users use our proposed work in the same way, so we will call them *Developer*. @use-case-model shows the use case diagram of proposed features in the standalone Apollon editor and the Apollon VSCode extension.
 
+One approach to using version management in the standalone Apollon editor is to _Address Diagram Feedback_. The source of the feedback is irrelevant for the use case, but this is useful in a Git setting, after the developer performed the _Embed Diagram_ use case (FR1.7). The developer can then _Iterate with Version Management_(FR1.1 - 1.6), in order to end the feedback loop by publishing a new version.
 
+Another use case is _Maintain Diagram for Docs_. This use case implies that the _Export Diagram_ use case (FR2.4) will be undertaken, so that the developer can embed the diagram in documentation. In order to achieve this, the developer has the _Model Diagram_, _Save Diagram_ and _Draft Diagram_ use cases (FR 2.1 - 2.3, FR 2.5) at their disposal.
+
+This use case model showcases the actions a developer can perform in the standalone Apollon editor using the version management and embedding features, as well as with the Apollon VSCode extension.
 
 #figure(
   image("/figures/use-case-model/use-case-model.svg"),
   caption: [Use case diagram of proposed features in the standalone Apollon editor and the Apollon VSCode extension],
 ) <use-case-model>
 
 === Analysis Object Model
-#TODO[
-  This subsection should contain a UML Class Diagram showing the most important objects, attributes, methods and relations of your application domain including taxonomies using specification inheritance (see @bruegge2004object). Do not insert objects, attributes or methods of the solution domain. *Important:* Make sure to describe the analysis object model thoroughly in the text so that readers are able to understand the diagram. Also write about the rationale how and why you modeled the concepts like this.
+The analysis object model describes the application domain concepts that the system manipulates and the user-visible interfaces of the system. It is depicted with UML class diagrams, includes classes, attributes, and operations @bruegge2004object. @analysis-object-model shows the Analysis Object Model of our proposed features of the standalone Apollon editor and the Apollon VSCode extension. The analysis object model is split into two tightly coupled parts.
+
+#figure(
+  image("/figures/analysis-object-model/analysis-object-model.svg"),
+  caption: [Analysis object model of proposed features in the standalone Apollon editor and the Apollon VSCode extension],
+) <analysis-object-model>
+
+In the bottom right portion of the analysis object model, the _Developer_ can create a diagram with the _IDE_. This is made possible by the _openUMLEditor()_, _modelDiagram()_ and _draftDiagram()_ operations. Using the _exportDiagram()_ operation, the developer is then able to embed a diagram into _Documentation_. This class is extended by the _Thesis_, _Technical Documentaion_ and _Knowledge Base_ subclasses.
+
+In the top left part of the analysis object model, the _Developer_ is able to create a diagram with the _UML Diagram Editor_. In order to facilitate version management, this class provides the _createDiagramVersion()_, _deleteDiagramVersion()_, _editDiagramVersion()_, _previewDiagramVersion()_ and _restoreDiagramVersion()_ operations. Using the _exportEmbedding()_ operation, the _Developer_ can export their diagram for embedding.
+
+The _Issue_ class has the attribute _isPullRequest_, and the operation _embedDiagram()_, so that the exported diagram can be embedded. An _Issue_ can have multiple instances of _Feedback_, with its _content_ attribute. _Feedback_ is linked to a _UML Diagram Version_, that has its own _title_, _description_ and _createdAt_ attributes. A _UML Diagram Version_ is part of a _Version History_, which belongs to a single _UML Diagram Editor_.
 
-]
+In conclusion, this analysis object model captures the relationships and processes that take place with version management and embedding features in the standalone Apollon editor, and in the Apollon IDE extension.
 
 === Dynamic Model
-#TODO[
-  This subsection should contain dynamic UML diagrams. These can be a UML state diagrams, UML communication diagrams or UML activity diagrams.*Important:* Make sure to describe the diagram and its rationale in the text. *Do not use UML sequence diagrams.*
-]
+In this section we will use the activity diagram to describe the utilization of version management and embedding features in a Git setting for the standalone Apollon editor, and the application of the Apollon IDE extension for documentation maintenance. Activity diagrams describe behavior in terms control and data flows @bruegge2004object.
+
+See @git-integration for an activity diagram of the utilization of version management and embedding features in a Git setting for the standalone Apollon editor.
+
+#figure(
+  image("/figures/dynamic-model/git-integration/git-integration.svg"),
+  caption: [Activity diagram of the utilization of version management and embedding features in a Git setting for the standalone Apollon editor],
+) <git-integration>
+
+The diagram starts with the activity _User creates a diagram_, after which the _First draft of diagram_ is obtained. This allows the user to embed their diagram in a Git pull request. When the diagram is embedded, the user can engage in a feedback loop with their collaborators. According to the feedback, the user can update the diagram and publish a new version, which will result in a _Diagram embedding updated_ object. With the end of the feedback loop comes the end of this activity diagram.
+
+See @docs-integration for an activity diagram of the application of the Apollon IDE extension for documentation maintenance.
+
+#figure(
+  image("/figures/dynamic-model/docs-integration/docs-integration.svg"),
+  caption: [Activity diagram of the application of the Apollon IDE extension for documentation maintenance],
+) <docs-integration>
+
+The first activity is _Open Diagram in IDE_, after which the user has a _Diagram preview opened in IDE_. Then, the user decides if they want to modify the diagram. If not, the user generates SVG of the diagram with the extension. Otherwise, the user first makes changes to the diagram in the editor in order to acquire the _New diagram_. Finally, the user has an SVG of the diagram for embedding, allowing him to embed the diagram in documentation.
 
 === User Interface
-#TODO[
-  Show mockups of the user interface of the software you develop and their connections / transitions. You can also create a storyboard. *Important:* Describe the mockups and their rationale in the text.
-]
+In this section we will discuss the key UI components of the standalone Apollon editor that constitute version management and embedding feautures.
+
+The component for version management in the standalone Apollon editor lies in the version management sidebar, displayed in @version-management-sidebar.
+
+#figure(
+  image("/figures/user-interface/version-management-sidebar.png", height: 60%),
+  caption: [Version management sidebar in standalone Apollon editor (in dark mode)],
+) <version-management-sidebar>
+
+In the top right corner of the sidebar is a "+" button, used for creating new versions. Below is the list of versions, ordered chronologically. For example, this diagram has three versions. At the top is the unpublished version, which presents the latest state of the diagram. Then follow the published versions, each with a title, an optional description and time stamp of publishing. Under this version information are buttons for editing the version's information, deleting it and previewing it. In case a diagram version is being previewed, this will be indicated by a filled circle to the left of the version, and the buttons "Exit preview" and "Restore version" will appear.
+
+In order to embed a diagram in a Git issue/pull request, the user clicks on the _Share_ navigation bar item, which triggers the Share modal, displayed in @share-modal-embed. In order to embed the diagram, the user clicks on the _Embed_ option, after which the embedding link is copied to their clipboard. In case the _Embed_ option was previously selected, a textarea with the embedding link is displayed in the Share modal, as shown in @share-modal-embed.
+
+#figure(
+  image("/figures/user-interface/share-modal-embed.png"),
+  caption: [Share modal in standalone Apollon editor (in dark mode)],
+) <share-modal-embed>
+
+The user interface components responsible for version management and embedding features in the standalone Apollon editor were designed with the goal in mind to provide the most intuitive and seamless user experience as possible.