O modelo de atores tem sido visto como uma abordagem alternativa à programação concorrente convencional, baseada em travas e variáveis de condição. Atores são agentes computacionais que se comunicam por troca de mensagens e que possuem uma caixa de correio e um comportamento. As mensagens destinadas a um ator são armazenadas na caixa de correio do ator e processadas de maneira assíncrona. Sistemas de middleware orientados a mensagens trabalham com troca assíncrona de mensagens e formam uma base que simplifica o desenvolvimento de aplicações distribuídas. Tais sistemas permitem interoperabilidade com baixo acoplamento e provêm suporte para tratamento robusto de erros em caso de falhas. Message brokers são frequentemente apresentados como uma tecnologia que pode mudar a maneira com que sistemas distribuídos são construídos. A especificação AMQP é uma proposta recente de padronização de um protocolo para message brokers. Neste trabalho exploramos a potencial sinergia entre um message broker e uma implementação do modelo de atores. Criamos uma versão modificada da implementação do modelo de atores do projeto Akka que utiliza um message broker AMQP como mecanismo de transporte de mensagens para atores remotos. / The actor model has been seen as an alternative for conventional concurrent programming based on locks and condition variables. Actors are computational agents that communicate by sending messages and have a mailbox and a behavior. The messages sent to an actor are stored in its mailbox and are asynchronously processed. Message oriented middleware systems work with asynchronous message exchange and create a base that simplifies the development of distributed applications. These systems have interoperability with low coupling and provide support for robust error handling in case of failures. Message brokers are often presented as a technology that can change the way distributed systems are built. The AMQP specification is a recent proposal of a standard protocol for message brokers. In this document we explore the potential synergy between a message broker and an implementation of the actor model. We created a modified version of the actor model implementation provided by the Akka project. Our modified implementation uses an AMQP message broker as the transport engine for messages to remote actors.

Scripting languages are extraordinarily popular due to their very flexible object model. Dynamic extensions (i.e., adding, removing and manipulating behavior and state) allow for the evolution and adaption of objects to context changes at runtime. Introducing this flexibility into a statically typed, object-oriented language would improve programmability and separation of concerns beyond the level of what one could usually gain with inheritance, mixins, traits or manually adapted designpatterns. They often lead to object-schizophrenia or the need for hand-crafted, additional management code. Although there were already attempts bringing flexible objects into statically typed languages with the benefits of an explicitly crafted core calculus or type system, they need their own compiler and tooling which limits the usability, e.g., when dealing with existing legacy code. This work presents an embedding of dynamically evolving objects via a lightweight library approach, which is pure in the sense, that there is no need for a specific compiler or tooling. It is written in Scala, which is both a modern object-oriented and functional programming language. Our approach is promising to solve practical problems arising in the area of dynamical extensibility and adaption like role-based programming.

The interrelations of a set of software objects are usually manifold and complex. Common object-oriented programming languages provide constructs for structuring objects according to shared properties and behavior, but fail to provide abstraction mechanisms for the interactions of objects. Roles seem to be a promising approach to solve this problem as they focus on the behavior of an object in a certain context. Combining multiple roles yields collaborations, an interesting abstraction and reuse unit. However, existing approaches towards roles in programming languages require vast extensions of the underlying language or even propose new languages. We propose a programming technique that enables role-based programming with commonly available language constructs. Thus, programmers can express roles and collaborations by simply using a library, and hence, without the need to change the language, its compiler, and its tools. We explain our proposal on a language-independent level. Moreover, we provide an implementation in form of a library for the Scala programming language. Finally, we apply our ideas to design patterns and analyze to which extent these can be expressed and reused with roles. / Die Zusammenhänge zwischen Softwareobjekten sind vielfältig und komplex. In den meisten objektorientierten Programmiersprachen werden Objekte an Hand von gemeinsamen Eigenschaften und Verhalten klassifiziert. Konstrukte zum Strukturieren bezüglich ihrer Interaktionen fehlen jedoch. Ein vielversprechender Lösungsansatz sind Rollen, welche das Verhalten von Objekten in einem bestimmten Kontext beschreiben. Zusammenhängende Rollen können zu Kollaborationen abstrahiert werden. Diese sind insbesondere als wiederverwendbare Bausteine interessant. Allerdings verändern bisherige Ansätze zu rollenbasiertem Programmieren die zu Grunde liegende Sprache erheblich oder schlagen gar neue Sprachen vor. Im Gegensatz dazu zeigen wir eine Programmiermethode, die rollenbasiertes Programmieren mit üblichen Sprachkonstrukten ermöglicht. Somit können Rollen und Kollaborationen als Bibliothek bereitgestellt werden, also ohne Sprache, Compiler und Werkzeuge anpassen zu müssen. Wir erläutern unseren Ansatz zunächst sprachunabhängig. Desweiteren wird eine Implementierung als Bibliothek für die Scala Programmiersprache präsentiert. Als praktische Anwendung stellen wir Entwurfsmustern dar und überprüfen, inwiefern sich diese mit Rollen ausdrücken und wiederverwenden lassen.

Continuous Deep Analytics (CDA) is a new form of analytics with performance requirements exceeding what the current generation of distributed systems can offer. This thesis is part of a five year project in collaboration between RISE SICS and KTH to develop a next generation distributed system capable of CDA. The two issues which the system aims to solve are computation sharing and hardware acceleration. The former refers to how BigData and machine learning libraries such as TensorFlow, Pandas and Numpy must collaborate in the most efficient way possible. Hardware acceleration relates to how the back-end of current generation general purpose data processing systems such as Spark and Flink are bottlenecked by the Java Virtual Machine (JVM). As the JVM abstracts over the underlying hardware, its applications become portable but also forfeit the opportunity to fully exploit the available hardware resources. This thesis aims to explore the area of Domain Specific Languages (DSLs) and code generation as a solution to hardware acceleration. The idea is to translate incoming queries to the system into low-level code, tailor suited to each worker machine’s specific hardware. To this end, two Scala DSLs for generating Rust code have been developed for the translation step. Rust is a new, low-level programming language with a unique take on memory management which makes it as safe as Java and fast as C. Scala is a language which is well suited towards development of DSLs due to its flexible syntax and semantics. The first DSL is implemented as a string interpolator. The interpolator splices strings of Rust code together, at compile time or runtime, and passes the result to an external process for static checking. The second DSL instead provides an API for constructing an abstract syntax tree, which after construction can be traversed and printed into Rust source code. The API combines three concepts: heterogeneous lists, fluent interfaces, and algebraic data types. These allow the userto express advanced Rust syntax such as polymorphic structs, functions, and traits, without sacrificing type safety. / Kontinuerlig Djup Analys (CDA) är en ny form av analys med prestandakrav som överstiger vad den nuvarande generationen av distributerade system kan erbjuda. Den här avhandlingen är del av ett project mellan RISE SICS och KTH för att utveckla ett nästa-generations distribuerat system kapabelt av CDA. Det är två problem som systemet syftar på att lösa: hårdvaruacceleration och beräkningsdelning. Det första handlar om hur BigData och maskininlärningssystem som sådan som TensorFlow, Pandas och Numpy måste kunna samarbeta så effektivt som möjligt. Hårdvaruacceleration relaterar till hur back-end delen i den dagens distribuerade beräknings system, såsom Spark och Flink, flaskhalsas av Javas Virtuella Maskin. JVM:en abstraherar över den underliggande hårvaran. Som resultat blir dess applikationer portabla, men ger också upp möjligheten att fullständigt utnyttja de tillgängliga hårdvaruresurserna. Den här avhandlingen siktar på att utforska området kring Domänspecifika Språk (DSLer) och kodgenerering som en lösning till hårdvaruacceleration. Idén är att översätta inkommande förfrågningar till låg-nivå kod, skräddarsydd till varje arbetar maskin’s specifika hårdvara. Till detta ändamål har två Scala DSLer utvecklats för generering av Rust kod. Rust är ett nytt låg-nivå språk med ett unikt vidtagande kring minneshantering som gör det både lika säkert som Java och snabbt som C. Scala är ett språk som passar bra tillutveckling av DSLer pågrund av dess flexibla syntax och semantik. Den första DSLen är implementerad som en sträng-interpolator. Interpolatorn sammanfogar strängar av Rust kod, under kompileringstid eller exekveringstid, och passerar resultatet till enextern process för statisk kontroll. Den andra DSLen består istället av ett API för att konstruera ett abstrakt syntaxträd, som efteråt kan traverseras och skrivas ut till Rust kod. API:et kombinerar tre koncept: heterogena listor, flytande gränssnitt, och algebraiska datatyper. Dessa tillåter användaren att uttrycka avancerad Rust syntax, såsom polymorfiska strukts, funktioner, och traits, utan att uppoffra typsäkerhet.

SCALA ist eine Kalibrationseinheit für den SuperNova Integral Feld Spektrographen (SNIFS) der am 2,2 m Teleskop der Universität Hawaii montiert ist. SCALA wurde gebaut um die Unsicherheiten in der Flusskalibration von Leuchtkraftentfernungen zu reduzieren. Dadurch erlaubt SCALA die mögliche zeitliche Veränderung der Dunklen Energie besser zu vermessen. SCALA ermöglicht die Kalibration von SNIFS relativ zu einem Laborstandard, der durch eine Photodiode realisiert ist, die relative zu einem Primärstandard am NIST (National Institute of Standards and Technology) kalibriert ist. Zur Übertragung der Kalibration werden SNIFS und die Photodiode gleichzeitig von einer monochromatischen, wellenlängen einstellbaren Lichtquelle beleuchtet. Dadurch wird ein Vergleich zwischen dem astronomischen CALSPEC System und dem Laborsystem möglich. Erste Ergebnisse von SCALA wurden in der Dissertation von Simona Lombardo vorgestellt. Wir haben nun mehrere Quellen von systematischen Effekten identifiziert, die unsere Messungen beeinflussen. Nach der Korrektur dieser Effekte stimmt die Wellenlängenabhängigkeit der Kalibration an Hand von SCALA und CALSPEC im Wellenlängenbereich 450 nm ,bis 900 nm,im Fehlerbereich von 1,5 % überein. In der Zukunft könnten die Quellen von systematischen Effekte durch Veränderungen am Messaufbau unterdrückt werden. Dies ermöglicht Vergleiche zwischen CALSPEC und SCALA im Fehlerbereich < 1%, außerdem könnte der Wellenlängenbereich bis zu 350 nm erweitert werden. / SCALA is a calibration system for the SuperNova Integral Field Spectrograph (SNIFS), which is mounted to the University Hawaii 2.2 m telescope. The aim of SCALA is to reduce the uncertainties on the flux calibration for luminosity distance measures. It therefore allows the reduction of the uncertainties on the time variability of the Dark Energy. SCALA enables us to calibrate SNIFS relative to a laboratory standard, which is realized by a photodiode, that is itself calibrated against a primary standard at NIST (National Institute of Standards and Technology). To transfer the calibration, we illuminate both the photodiode and SNIFS with a wavelength-tunable, monochromatic light source. This calibration allows us to compare the laboratory system to the astronomical CALSPEC system. The first results were presented in dissertation of Simona Lombardo. We have now identified several sources of systematic uncertainty that were affecting our measurements. After correcting for these effects, the wavelength-dependency of the calibration by SCALA agrees with the CALSPEC system in the wavelength range 450 nm to 900 nm (within our uncertainties of 1.5%). In the future, the identified sources of systematic uncertainty could be reduced through improvements to the setup. This would allow comparisons to the CALSPEC system with uncertainties < 1 % and a wavelength range extension down to 350nm.

Die Messung der dunklen Energie Ω(Λ) und des equation-of-state Parameters 𝑤 spielen in der Kosmologie eine entscheidende Rolle. Das Hubble-Diagramm einer Supernova vom Typ Ia (SNe-Ia) gibt Aufschluss über diese Parameter. Die Supernova-Kosmologie vergleicht die Lichtkurven von SNe-Ia bei verschiedenen Rotverschiebungen und Filterbändern. Die Genauigkeit der oben genannten Parameter hängt von der Genauigkeit der derzeit verfügbaren spektrophotometrischen Standards ab. Dies erfordert Fortschritte bei der Verbesserung der Verbindung zwischen den derzeitigen astrophysikalischen Flussstandards und den in den Labors etablierten Standards. CALSPEC ist ein stellares Standardnetzwerk mit einer internen Konsistenz von 0,5 %, das häufig mit STIS am Hubble-Weltraumteleskop validiert wird. Neue Instrumente wie das Vera C. Rubin-Observatorium erfordern Flusskalibrierungsunsicherheiten in der Größenordnung von 0,1 %. SCALA zielt darauf ab, die Kalibrierung des NIST-Laborstandards mit Unsicherheiten, die von den NIST-Kalibrierungsunsicherheiten dominiert werden, auf CALSPEC zu übertragen. SCALA verwendet zwei sequentielle Monochromatoren zur gleichzeitigen Beleuchtung des SNIFS+Teleskopsystems. Zwanzig Photosensoren wurden kalibriert für den Bereich zwischen 3000Å und 10 000 Å, und SCALA wurde im Juni 2022 mit den vorgeschlagenen Verbesserungen aufgerüstet. Nach Abschluss der Aufrüstung wurden in vier Nächten zwischen dem 19. und 22. Juni 2022 Standardsterne aus dem von der Supernova Factory verwendeten Standardsternnetz beobachtet. Tagsüber wurde SNIFS anhand der zuvor kalibrierten Fotosensoren kalibriert, so dass die Kalibrierung auf den NIST-Laborstandard zurückgeführt werden konnte. Es zeigte sich, dass der Kalibrierungstransfer von SCALA in der Größenordnung von 0,1 % zum gesamten Unsicherheitsbudget beiträgt. Eine Anpassung der SNIFS-Analysepipeline wird den Vergleich mit CALSPEC mit Unsicherheiten von weniger als 0,5 % ermöglichen. / The measurement of dark energy Ω(Λ) and its equation of state parameter 𝑤 plays a vital role in cosmology. The Hubble diagram of a Type Ia supernova (SNe-Ia) constrains these parameters. Supernova cosmology compares the light curves of SNe-Ia at different redshifts and filter bands. The accuracy of the above parameters depends on the accuracy of currently available spectrophotometric standards. This requires advances to improve the connection between current astrophysical flux standards and those established in laboratories. CALSPEC is a standard stellar network with an internal consistency of 0.5%, frequently validated with STIS at the Hubble Space Telescope. New instruments such as the Vera C. Rubin Observatory require flux calibration uncertainties of the order of 0.1%. SCALA aims to transfer the calibration of the NIST laboratory standard with uncertainties dominated by the NIST calibration uncertainties to CALSPEC. SCALA uses two sequential monochromators to simultaneously illuminate the SNIFS + telescope system and the calibrated photodiodes with traceable calibration for the range between 3000Å to 10 000 Å. Twenty photosensors were calibrated, and SCALA was upgraded with the proposed improvements in June 2022. At the end of the upgrade, standard stars from the standard star network used by the Supernova Factory were observed for four nights between June 19 and 22, 2022. During the day, SNIFS was calibrated against the previously calibrated photosensors, allowing the calibration to be traced back to the NIST laboratory standard. It was shown that the calibration transfer from SCALA contributes in the order of 0.1%to the total uncertainty budget. An adjustment of the SNIFS analysis pipeline will allow comparison with CALSPEC with uncertainties less than 0.5%.

Domänenspezifische Sprachen (DSLs) sind Software-Sprachen, die speziell für bestimmte Anwendungsdomänen entwickelt wurden. Mithilfe von DSLs können Domänenexperten ihr Domänenwissen auf einem hohen Abstraktionsniveau beschreiben. Wie andere Software-Sprachen auch, benötigen DSLs Sprachwerkzeuge, die Assistenz bei der Erstellung und Verarbeitung von domänenspezifischen Modellen bieten. Eine domänenspezifische Werkbank (DSW) ist ein Software-Werkzeug, welches mehrere solcher Sprachwerkzeuge für eine DSL miteinander integriert. Existierende Werkzeuge, die es erlauben eine DSW aufgrund der Beschreibung einer DSL automatisch generieren zu lassen, unterstützen jedoch nicht die Beschreibung und Generierung von editierbaren Sichten. Eine Sicht ist ein Teil einer DSW, der nur einen bestimmten Aspekt eines Modells darstellt. Diese Dissertation stellt spezielle Modelltransformationssprachen (MTLs) vor, mit denen die Synchronisation von Sichten in einer generierten DSW beschrieben werden kann. Dadurch können DSWs mit editierbaren Sichten mittels existierender Werkzeuge zur Generierung von Sprachwerkzeugen erstellt werden. Dafür wird eine DSW für die Nanophysik-Domäne sowie eine Taxonomie von Synchronisationstypen vorgestellt, welche es erlaubt genau zu bestimmen, welche Art von Modelltransformationen für die Synchronisation von Sichten in dieser Werkbank benötigt werden. Entsprechend dieser Anforderungen werden zwei MTLs entwickelt. Insbesondere wird eine bidirektionale MTL entwickelt. Mit solch einer Sprache kann man eine Relation, welche definiert ob zwei Modelle synchron sind, so beschreiben, dass die entsprechende Synchronisationslogik automatisch abgeleitet werden kann. Die gezeigten MTLs werden als interne DSLs - das heißt eingebettet als ausdrucksstarke Bibliotheken - in der Programmiersprache Scala implementiert. Auf diese Weise kann Scalas Typprüfung genutzt werden, um Transformationen und deren Komposition statisch zu verifizieren. / Domain-specific languages (DSLs) are software languages which are tailored to a specific application domain. DSLs enable domain experts to create domain-specific models, that is, high-level descriptions of domain knowledge. As any other software languages, DSLs rely on language tools which provide assistance for processing and managing domain-specific models. A domain-specific workbench is an integrated set of such tools for a DSL. A recently proposed approach is to automatically generate a domain-specific workbench for a DSL from a description of that DSL. However, existing tools which apply this approach do not support to describe and generate editable domain-specific views. A view is a part of domain-specific workbench that presents only one aspect of a model, for example, its hierarchical structure. This dissertation presents special model transformation languages which support the description of view synchronization in a generated domain-specific workbench. This allows a multi-view domain-specific workbench to be created with existing tools for language tool generation. We present a generated domain-specific workbench for the nanophysics domain and present a taxonomy of synchronization types. This allows us to precisely define what model transformations are required for view synchronization in that workbench. According to these requirements, we develop two transformation languages by adapting existing ones. In particular, we develop a bidirectional transformation language. With such a language one can describe a relation which defines whether two models are in sync and let the synchronization logic be inferred automatically. We implement model transformation languages as internal DSLs - that is, embedded as expressive libraries - in the Scala programming language and use Scala''s type checking for static verification of transformations and their composition.

This study presents a hybrid concurrent programming model combining the previously developed Fork-Join model (FJM) and Actor model (AM). With the advent of multi-core computers, there is a renewed interest in programming models that reduce the burden of reasoning about and writing efficient concurrent programs. The proposed hybrid model shows how the divide-and-conquer approach of the FJM and the no-shared mutable state and event-driven philosophy of the AM can be combined to solve certain classes of problems more efficiently and productively than either of the aforementioned models individually. The hybrid model adds actor creation and coordination to into the FJM, while also enabling parallelization within actors. This study uses the Habanero-Java and Scala programming languages as the base for the FJM and AM respectively, and provides an implementation of the hybrid model as an extension of the Scala language called Habanero-Scala. The hybrid model adds to the foundations of parallel programs, and to the tools available for the programmer to aid in productivity and performance while developing parallel software.

Texte remanié de: Diss.--Kassel, 1995. / Bibliogr. p. 309-330. Notes bibliogr.

BARROS, Francisca Jamilia Oliveira de. O desenvolvimento da escrita de sujeitos com deficiência intelectual por meio do software scala web. 2017. 173f.– Dissertação (Mestrado) – Universidade Federal do Ceará, Programa de Pós-graduação em Educação Brasileira, Fortaleza (CE), 2017. / Submitted by Gustavo Daher (gdaherufc@hotmail.com) on 2017-07-10T11:37:44Z No. of bitstreams: 1 2017_dis_fjobarros.pdf: 3092935 bytes, checksum: babc38df43edcac4a4b8647d429a54b4 (MD5) / Approved for entry into archive by Márcia Araújo (marcia_m_bezerra@yahoo.com.br) on 2017-07-25T11:23:05Z (GMT) No. of bitstreams: 1 2017_dis_fjobarros.pdf: 3092935 bytes, checksum: babc38df43edcac4a4b8647d429a54b4 (MD5) / Made available in DSpace on 2017-07-25T11:23:05Z (GMT). No. of bitstreams: 1 2017_dis_fjobarros.pdf: 3092935 bytes, checksum: babc38df43edcac4a4b8647d429a54b4 (MD5) Previous issue date: 2017 / A presente pesquisa se inscreve na abordagem psicogenética da escrita e teve por objetivo verificar se e como a aplicação do sistema de Comunicação Alternativa, Scala Web, favorece o desenvolvimento da linguagem escrita de sujeitos com deficiência intelectual. Participaram desta pesquisa 10 sujeitos (5 do grupo experimental e 5 do grupo controle) com deficiência intelectual que estavam em processo de desenvolvimento da escrita (variando do nível silábico e silábico-alfabético) e que frequentavam escolas da rede pública de Fortaleza. O procedimento da pesquisa consistiu em um estudo experimental no qual cada sujeito construiu 10 textos (orais e escritos), por meio do ambiente Narrativas Visuais do software Scala Web, com o auxílio da mediação, contabilizando um total de 50 produções. As intervenções aconteceram semanalmente, durante o período de três meses e foram realizadas em duas salas de recurso multifuncional (SRM) de duas escolas públicas de Fortaleza, com duração de aproximadamente 45 minutos. Somente os sujeitos do grupo experimental participaram dessas sessões. Durante as intervenções foi realizado um trabalho de mediação com os sujeitos tanto em relação a interação com o software, como também no sentido de favorecer a escrita dos textos. Todos os sujeitos foram submetidos a um pré e pós-teste visando avaliar o desenvolvimento da escrita e o desenvolvimento operatório dos mesmos. Comparações estatísticas foram efetuadas por meio dos testes não paramétricos U de Mann-Whitney e Teste-T. Do ponto de vista estatístico, nenhuma diferença pode ser observada entre o grupo controle e o experimental em relação a idade cronológica, o desenvolvimento operatório e a linguagem escrita. Porém, a análise qualitativa indica avanços no grupo experimental, no que se refere a evolução da escrita. Os dados revelaram que durante o processo de construção textual, no início da pesquisa quatro dos cinco sujeitos utilizavam a construção dos cenários para planejar o seu texto e organizar a apresentação das ideias. Ao término da pesquisa esses sujeitos já conseguiam organizar e construir os seus textos sem o apoio dos cenários. Durante toda a pesquisa a mediação se constitui um elemento importante para o desempenho dos sujeitos na produção escrita. Algumas fragilidades em relação ao software foram observadas, porém apenas durante a composição dos cenários. Tais fragilidades revelam que o ambiente pesquisado se torna de difícil acesso para sujeitos que não se encontram em nível alfabético. Na presente pesquisa essa fragilidade foi neutralizada pela mediação. Desta forma, podemos inferir que o ambiente Narrativas Visuais do Scala Web, sendo utilizado com fins pedagógicos pode auxiliar no desenvolvimento da língua escrita de sujeitos com deficiência intelectual, visto que, é um ambiente motivador que oferece diversas possibilidades de interação e disponibiliza recursos, que podem apoiar o processo de construção textual por parte desses sujeitos.