|
|
|
|
| LEADER |
04369nam a2200289 c 4500 |
| 001 |
22-l189-qucosa2-721469 |
| 007 |
cr |
| 008 |
2020 ger |
| 037 |
|
|
|a urn:nbn:de:bsz:l189-qucosa2-721469
|
| 041 |
|
|
|a ger
|
| 082 |
|
|
|a 006.3\0285436
|
| 100 |
|
|
|a Götz, Julian
|
| 245 |
|
|
|a Distributed Systems Extensions for the Dunai FRP Library
|
| 264 |
|
|
|c 2020
|
| 336 |
|
|
|b txt
|
| 338 |
|
|
|b nc
|
| 533 |
|
|
|a Online-Ausg.
|d 2020
|e Online-Ressource (Text)
|f Hochschule für Technik, Wirtschaft und Kultur
|
| 502 |
|
|
|b Masterarbeit
|c Hochschule für Technik, Wirtschaft und Kultur
|d 2020
|
| 505 |
|
|
|a 1 Introduction ... 1 2 Functional Reactive Programming ... 4 2.1 The Arrow Type Class ... 5 2.2 The Dunai FRP Library ... 7 2.2.1 Monadic Stream Functions ... 7 2.2.2 Combining Monads ... 8 2.2.3 Monads in Monadic Stream Functions ... 9 2.3 The BearRiver FRP Library ... 10 2.4 Executing FRP ... 11 3 Synchronization of Distributed Systems ... 13 3.1 Distributed Systems ... 13 3.2 Consistency of Distributed Systems ... 14 3.3 Client/Server Architecture ... 15 3.4 Time Warp Synchronization ... 16 3.5 Dead Reckoning ... 17 3.6 Client Side Prediction ... 19 4 Cloud Haskell ... 21 4.1 Exchanging Messages ... 22 4.2 Fault Tolerance ... 23 4.3 The Cloud Haskell Platform ... 23 5 Concept ... 25 5.1 Concept of the Implemented Library ... 25 5.2 Concept of the Sample Application ... 27 5.3 Functional Requirements ... 28 5.4 Non-Functional Requirements ... 30 6 Implementation ... 32 6.1 Client/Server Architecture ... 33 6.1.1 Establishing Connections between Clients and Servers ... 33 6.1.2 Distributed Execution of FRP ... 35 6.1.3 Implementation of Servers ... 36 6.1.4 Implementation of Clients ... 38 6.2 Time Warp Synchronization ... 39 6.2.1 Rollbacks of Monadic Stream Functions ... 39 6.2.2 Executing FRP using Time Warp Synchronization ... 41 6.3 Dead Reckoning ... 45 6.4 Client Side Prediction ... 46 7 Evaluation ... 48 7.1 Evaluation of Functional Requirements ... 48 7.2 Concept of the Performance Test ... 52 7.3 Concept of the User Test ... 53 7.4 Results of the Performance Test ... 54 7.5 Results of the User Test ... 56 8 Summary ... 60 Bibliography ... A Listings ... M List of Figures ... O List of Tables ... P Glossary .. Q Abbreviations ... U
|
| 520 |
|
|
|a Functional Reactive Programming (FRP) offers a declarative way to express reactive systems such as animations, user interfaces and games. Various topics related to FRP like optimization, generalization and debugging were studied. However, the use of FRP in distributed systems has not been investigated extensively. Focused on the use of the Dunai FRP library implemented in the Haskell programming language, the aim of this thesis is to develop and evaluate a way to apply FRP to distributed systems. A library is implemented to extend Dunai with means to create distributed systems. There is support for the Client/Server network architectural model and algorithms to synchronize applications across a network. As the synchronization of distributed systems has been a topic of research for decades, this thesis explores whether developed ideas, such as Time Warp (Jefferson, 1985), can be expressed in FRP. Additionally, Client Side Prediction (Bernier, 2001) and Dead Reckoning (DIS Steering Committee, 1994) are used to predict server reactions on client-side. An exemplary application demonstrates the implementation. The application is then evaluated in a performance test and a user test. TimeWarp synchronization has a significant impact on performance. Despite this, the application is playable up to a latency of 100 ms. The result of Dead Reckoning is acceptable, whereas Client Side Prediction is not usable. The thesis shows that the developed way can be used to run FRP on distributed systems. Further work should focus the performance to enable more complex applications. Moreover, Dead Reckoning can be improved to a smoother result. Non-trivial changes are necessary to make Client Side Prediction usable.
|
| 650 |
|
|
|a Functional Reactive Programming
|
| 650 |
|
|
|a Synchronization Distributed Systems
|
| 650 |
|
|
|a Cloud Haskell
|
| 655 |
|
|
|a Hochschulschrift
|2 gnd-content
|
| 856 |
4 |
0 |
|q text/html
|u https://nbn-resolving.org/urn:nbn:de:bsz:l189-qucosa2-721469
|z Online-Zugriff
|
| 935 |
|
|
|c hs
|
| 980 |
|
|
|a l189-qucosa2-721469
|b 22
|c sid-22-col-qucosa
|
SOLR
| _version_ |
1797999339018125313 |
| author |
Götz, Julian |
| author_facet |
Götz, Julian |
| author_role |
|
| author_sort |
Götz, Julian |
| author_variant |
j g jg |
| building |
Library A |
| collection |
sid-22-col-qucosa |
| contents |
1 Introduction ... 1 2 Functional Reactive Programming ... 4 2.1 The Arrow Type Class ... 5 2.2 The Dunai FRP Library ... 7 2.2.1 Monadic Stream Functions ... 7 2.2.2 Combining Monads ... 8 2.2.3 Monads in Monadic Stream Functions ... 9 2.3 The BearRiver FRP Library ... 10 2.4 Executing FRP ... 11 3 Synchronization of Distributed Systems ... 13 3.1 Distributed Systems ... 13 3.2 Consistency of Distributed Systems ... 14 3.3 Client/Server Architecture ... 15 3.4 Time Warp Synchronization ... 16 3.5 Dead Reckoning ... 17 3.6 Client Side Prediction ... 19 4 Cloud Haskell ... 21 4.1 Exchanging Messages ... 22 4.2 Fault Tolerance ... 23 4.3 The Cloud Haskell Platform ... 23 5 Concept ... 25 5.1 Concept of the Implemented Library ... 25 5.2 Concept of the Sample Application ... 27 5.3 Functional Requirements ... 28 5.4 Non-Functional Requirements ... 30 6 Implementation ... 32 6.1 Client/Server Architecture ... 33 6.1.1 Establishing Connections between Clients and Servers ... 33 6.1.2 Distributed Execution of FRP ... 35 6.1.3 Implementation of Servers ... 36 6.1.4 Implementation of Clients ... 38 6.2 Time Warp Synchronization ... 39 6.2.1 Rollbacks of Monadic Stream Functions ... 39 6.2.2 Executing FRP using Time Warp Synchronization ... 41 6.3 Dead Reckoning ... 45 6.4 Client Side Prediction ... 46 7 Evaluation ... 48 7.1 Evaluation of Functional Requirements ... 48 7.2 Concept of the Performance Test ... 52 7.3 Concept of the User Test ... 53 7.4 Results of the Performance Test ... 54 7.5 Results of the User Test ... 56 8 Summary ... 60 Bibliography ... A Listings ... M List of Figures ... O List of Tables ... P Glossary .. Q Abbreviations ... U, Functional Reactive Programming (FRP) offers a declarative way to express reactive systems such as animations, user interfaces and games. Various topics related to FRP like optimization, generalization and debugging were studied. However, the use of FRP in distributed systems has not been investigated extensively. Focused on the use of the Dunai FRP library implemented in the Haskell programming language, the aim of this thesis is to develop and evaluate a way to apply FRP to distributed systems. A library is implemented to extend Dunai with means to create distributed systems. There is support for the Client/Server network architectural model and algorithms to synchronize applications across a network. As the synchronization of distributed systems has been a topic of research for decades, this thesis explores whether developed ideas, such as Time Warp (Jefferson, 1985), can be expressed in FRP. Additionally, Client Side Prediction (Bernier, 2001) and Dead Reckoning (DIS Steering Committee, 1994) are used to predict server reactions on client-side. An exemplary application demonstrates the implementation. The application is then evaluated in a performance test and a user test. TimeWarp synchronization has a significant impact on performance. Despite this, the application is playable up to a latency of 100 ms. The result of Dead Reckoning is acceptable, whereas Client Side Prediction is not usable. The thesis shows that the developed way can be used to run FRP on distributed systems. Further work should focus the performance to enable more complex applications. Moreover, Dead Reckoning can be improved to a smoother result. Non-trivial changes are necessary to make Client Side Prediction usable. |
| dewey-full |
006.3\0285436 |
| dewey-hundreds |
000 - Computer science, information, general works |
| dewey-ones |
006 - Special computer methods |
| dewey-raw |
006.3\0285436 |
| dewey-search |
006.3\0285436 |
| dewey-sort |
16.3 6285436 |
| dewey-tens |
000 - Computer science, information, general works |
| facet_avail |
Online, Free |
| finc_class_facet |
Informatik |
| fincclass_txtF_mv |
science-computerscience |
| format |
eBook, Thesis |
| format_access_txtF_mv |
Thesis |
| format_de14 |
Thesis, Book, E-Book |
| format_de15 |
Thesis, Book, E-Book |
| format_del152 |
Buch, Buch |
| format_detail_txtF_mv |
text-online-monograph-independent-thesis |
| format_dezi4 |
e-Book |
| format_finc |
Book, E-Book, Thesis |
| format_legacy |
Thesis, Book |
| format_legacy_nrw |
Thesis, Book, E-Book |
| format_nrw |
Thesis, Book, E-Book |
| format_strict_txtF_mv |
E-Thesis |
| genre |
Hochschulschrift gnd-content |
| genre_facet |
Hochschulschrift |
| geogr_code |
not assigned |
| geogr_code_person |
not assigned |
| id |
22-l189-qucosa2-721469 |
| illustrated |
Not Illustrated |
| imprint |
2020 |
| imprint_str_mv |
Online-Ausg.: 2020 |
| institution |
DE-105, DE-Gla1, DE-Brt1, DE-D161, DE-540, DE-Pl11, DE-Rs1, DE-Bn3, DE-Zi4, DE-Zwi2, DE-D117, DE-Mh31, DE-D275, DE-Ch1, DE-15, DE-D13, DE-L242, FID-BBI-DE-23, DE-L229, DE-L328 |
| is_hierarchy_id |
|
| is_hierarchy_title |
|
| language |
German |
| last_indexed |
2024-05-03T03:09:48.443Z |
| match_str |
gotz2020distributedsystemsextensionsforthedunaifrplibrary |
| mega_collection |
Qucosa |
| publishDate |
2020 |
| publishDateSort |
2020 |
| publishPlace |
|
| publisher |
|
| record_format |
marcfinc |
| record_id |
l189-qucosa2-721469 |
| recordtype |
marcfinc |
| rvk_facet |
No subject assigned |
| source_id |
22 |
| spelling |
Götz, Julian, Distributed Systems Extensions for the Dunai FRP Library, 2020, txt, nc, Online-Ausg. 2020 Online-Ressource (Text) Hochschule für Technik, Wirtschaft und Kultur, Masterarbeit Hochschule für Technik, Wirtschaft und Kultur 2020, 1 Introduction ... 1 2 Functional Reactive Programming ... 4 2.1 The Arrow Type Class ... 5 2.2 The Dunai FRP Library ... 7 2.2.1 Monadic Stream Functions ... 7 2.2.2 Combining Monads ... 8 2.2.3 Monads in Monadic Stream Functions ... 9 2.3 The BearRiver FRP Library ... 10 2.4 Executing FRP ... 11 3 Synchronization of Distributed Systems ... 13 3.1 Distributed Systems ... 13 3.2 Consistency of Distributed Systems ... 14 3.3 Client/Server Architecture ... 15 3.4 Time Warp Synchronization ... 16 3.5 Dead Reckoning ... 17 3.6 Client Side Prediction ... 19 4 Cloud Haskell ... 21 4.1 Exchanging Messages ... 22 4.2 Fault Tolerance ... 23 4.3 The Cloud Haskell Platform ... 23 5 Concept ... 25 5.1 Concept of the Implemented Library ... 25 5.2 Concept of the Sample Application ... 27 5.3 Functional Requirements ... 28 5.4 Non-Functional Requirements ... 30 6 Implementation ... 32 6.1 Client/Server Architecture ... 33 6.1.1 Establishing Connections between Clients and Servers ... 33 6.1.2 Distributed Execution of FRP ... 35 6.1.3 Implementation of Servers ... 36 6.1.4 Implementation of Clients ... 38 6.2 Time Warp Synchronization ... 39 6.2.1 Rollbacks of Monadic Stream Functions ... 39 6.2.2 Executing FRP using Time Warp Synchronization ... 41 6.3 Dead Reckoning ... 45 6.4 Client Side Prediction ... 46 7 Evaluation ... 48 7.1 Evaluation of Functional Requirements ... 48 7.2 Concept of the Performance Test ... 52 7.3 Concept of the User Test ... 53 7.4 Results of the Performance Test ... 54 7.5 Results of the User Test ... 56 8 Summary ... 60 Bibliography ... A Listings ... M List of Figures ... O List of Tables ... P Glossary .. Q Abbreviations ... U, Functional Reactive Programming (FRP) offers a declarative way to express reactive systems such as animations, user interfaces and games. Various topics related to FRP like optimization, generalization and debugging were studied. However, the use of FRP in distributed systems has not been investigated extensively. Focused on the use of the Dunai FRP library implemented in the Haskell programming language, the aim of this thesis is to develop and evaluate a way to apply FRP to distributed systems. A library is implemented to extend Dunai with means to create distributed systems. There is support for the Client/Server network architectural model and algorithms to synchronize applications across a network. As the synchronization of distributed systems has been a topic of research for decades, this thesis explores whether developed ideas, such as Time Warp (Jefferson, 1985), can be expressed in FRP. Additionally, Client Side Prediction (Bernier, 2001) and Dead Reckoning (DIS Steering Committee, 1994) are used to predict server reactions on client-side. An exemplary application demonstrates the implementation. The application is then evaluated in a performance test and a user test. TimeWarp synchronization has a significant impact on performance. Despite this, the application is playable up to a latency of 100 ms. The result of Dead Reckoning is acceptable, whereas Client Side Prediction is not usable. The thesis shows that the developed way can be used to run FRP on distributed systems. Further work should focus the performance to enable more complex applications. Moreover, Dead Reckoning can be improved to a smoother result. Non-trivial changes are necessary to make Client Side Prediction usable., Functional Reactive Programming, Synchronization Distributed Systems, Cloud Haskell, Hochschulschrift gnd-content, text/html https://nbn-resolving.org/urn:nbn:de:bsz:l189-qucosa2-721469 Online-Zugriff |
| spellingShingle |
Götz, Julian, Distributed Systems Extensions for the Dunai FRP Library, 1 Introduction ... 1 2 Functional Reactive Programming ... 4 2.1 The Arrow Type Class ... 5 2.2 The Dunai FRP Library ... 7 2.2.1 Monadic Stream Functions ... 7 2.2.2 Combining Monads ... 8 2.2.3 Monads in Monadic Stream Functions ... 9 2.3 The BearRiver FRP Library ... 10 2.4 Executing FRP ... 11 3 Synchronization of Distributed Systems ... 13 3.1 Distributed Systems ... 13 3.2 Consistency of Distributed Systems ... 14 3.3 Client/Server Architecture ... 15 3.4 Time Warp Synchronization ... 16 3.5 Dead Reckoning ... 17 3.6 Client Side Prediction ... 19 4 Cloud Haskell ... 21 4.1 Exchanging Messages ... 22 4.2 Fault Tolerance ... 23 4.3 The Cloud Haskell Platform ... 23 5 Concept ... 25 5.1 Concept of the Implemented Library ... 25 5.2 Concept of the Sample Application ... 27 5.3 Functional Requirements ... 28 5.4 Non-Functional Requirements ... 30 6 Implementation ... 32 6.1 Client/Server Architecture ... 33 6.1.1 Establishing Connections between Clients and Servers ... 33 6.1.2 Distributed Execution of FRP ... 35 6.1.3 Implementation of Servers ... 36 6.1.4 Implementation of Clients ... 38 6.2 Time Warp Synchronization ... 39 6.2.1 Rollbacks of Monadic Stream Functions ... 39 6.2.2 Executing FRP using Time Warp Synchronization ... 41 6.3 Dead Reckoning ... 45 6.4 Client Side Prediction ... 46 7 Evaluation ... 48 7.1 Evaluation of Functional Requirements ... 48 7.2 Concept of the Performance Test ... 52 7.3 Concept of the User Test ... 53 7.4 Results of the Performance Test ... 54 7.5 Results of the User Test ... 56 8 Summary ... 60 Bibliography ... A Listings ... M List of Figures ... O List of Tables ... P Glossary .. Q Abbreviations ... U, Functional Reactive Programming (FRP) offers a declarative way to express reactive systems such as animations, user interfaces and games. Various topics related to FRP like optimization, generalization and debugging were studied. However, the use of FRP in distributed systems has not been investigated extensively. Focused on the use of the Dunai FRP library implemented in the Haskell programming language, the aim of this thesis is to develop and evaluate a way to apply FRP to distributed systems. A library is implemented to extend Dunai with means to create distributed systems. There is support for the Client/Server network architectural model and algorithms to synchronize applications across a network. As the synchronization of distributed systems has been a topic of research for decades, this thesis explores whether developed ideas, such as Time Warp (Jefferson, 1985), can be expressed in FRP. Additionally, Client Side Prediction (Bernier, 2001) and Dead Reckoning (DIS Steering Committee, 1994) are used to predict server reactions on client-side. An exemplary application demonstrates the implementation. The application is then evaluated in a performance test and a user test. TimeWarp synchronization has a significant impact on performance. Despite this, the application is playable up to a latency of 100 ms. The result of Dead Reckoning is acceptable, whereas Client Side Prediction is not usable. The thesis shows that the developed way can be used to run FRP on distributed systems. Further work should focus the performance to enable more complex applications. Moreover, Dead Reckoning can be improved to a smoother result. Non-trivial changes are necessary to make Client Side Prediction usable., Functional Reactive Programming, Synchronization Distributed Systems, Cloud Haskell, Hochschulschrift |
| title |
Distributed Systems Extensions for the Dunai FRP Library |
| title_auth |
Distributed Systems Extensions for the Dunai FRP Library |
| title_full |
Distributed Systems Extensions for the Dunai FRP Library |
| title_fullStr |
Distributed Systems Extensions for the Dunai FRP Library |
| title_full_unstemmed |
Distributed Systems Extensions for the Dunai FRP Library |
| title_short |
Distributed Systems Extensions for the Dunai FRP Library |
| title_sort |
distributed systems extensions for the dunai frp library |
| title_unstemmed |
Distributed Systems Extensions for the Dunai FRP Library |
| topic |
Functional Reactive Programming, Synchronization Distributed Systems, Cloud Haskell, Hochschulschrift |
| topic_facet |
Functional Reactive Programming, Synchronization Distributed Systems, Cloud Haskell, Hochschulschrift |
| url |
https://nbn-resolving.org/urn:nbn:de:bsz:l189-qucosa2-721469 |
| urn |
urn:nbn:de:bsz:l189-qucosa2-721469 |
| work_keys_str_mv |
AT gotzjulian distributedsystemsextensionsforthedunaifrplibrary |