The work in this thesis covers mainly the design and analysis of many important Non-Numerical Parallel Algorithms that run on MIMD type Parallel Computer Systems (PCSs), in particular the NEPTUNE and the SEQUENT BALANCE 8000 PCSs available at Loughborough University of Technology.

abstract: Laboratory automation systems have seen a lot of technological advances in recent times. As a result, the software that is written for them are becoming increasingly sophisticated. Existing software architectures and standards are targeted to a wider domain of software development and need to be customized in order to use them for developing software for laboratory automation systems. This thesis proposes an architecture that is based on existing software architectural paradigms and is specifically tailored to developing software for a laboratory automation system. The architecture is based on fairly autonomous software components that can be distributed across multiple computers. The components in the architecture make use of asynchronous communication methodologies that are facilitated by passing messages between one another. The architecture can be used to develop software that is distributed, responsive and thread-safe. The thesis also proposes a framework that has been developed to implement the ideas proposed by the architecture. The framework is used to develop software that is scalable, distributed, responsive and thread-safe. The framework currently has components to control very commonly used laboratory automation devices such as mechanical stages, cameras, and also to do common laboratory automation functionalities such as imaging. / Dissertation/Thesis / Thesis Presentation / M.S. Computer Science 2012

Le web est une plate-forme universelle pour développer des applications riches en interactions avec les utilisateurs et des services distants. Ces interactions sont implémentées sous forme d’évènements asynchrones pouvant survenir à n’importe quel instant de l’exécution de l’application. JavaScript, le langage du web, gère les évènements asynchrones de façon peu abstraite, ce qui rend l’écriture, la vérification et la maintenance d’applications interactives difficile. La contribution de cette thèse est l’élaboration et l’implémentation du langage Hiphop.js qui dote JavaScript d’abstractions de plus haut niveau pour gérer les évènements asynchrones. Hiphop.js est une implémentation JavaScript de constructions temporelles du langage réactif synchrone Esterel. Grâce à ces constructions, le flot de contrôle d’une application Hiphop.js est explicite. Il est donc possible de savoir précisément quand et sous quelles conditions un évènement est traité par simple lecture du code source de l’application. Ceci facilite la vérification et la maintenance de l’application. L’intégration profonde du langage Hiphop.js avec l’environnement dynamique du web est une part importante des travaux entrepris dans cette thèse. Les programmes sont construits et compilés pendant l’exécution de l’application JavaScript ce qui permet d’adapter automatiquement le traitement des évènements asynchrones en fonction des changements de l’environnement au cours de l’exécution (par exemple, la connexion ou déconnexion de participants pendant une visioconférence). / The web is an universal platform used to develop applications interacting with users and remote services. These interactions are implemented as asynchronous events that can be fired anytime. JavaScript, the mainstream language of the web, handles asynchronous events using low-level abstractions that makes it difficult to write, verify, and maintain interactive applications. We have addressed this problem by designing and implementing a new domain specific language called Hiphop.js. It offers an alternative to JavaScript event handling mechanism by reusing temporal constructions coming from the synchronous programming language Esterel. These constructions make the control flow of the program explicit and deterministic. Hiphop.js is embedded in JavaScript and suits the traditional dynamic programming style of the Web. It is tighly coupled to JavaScript with which it can exchange values and access any data structures. It can also support dynamic modifications of existing programs needed to support on-demand download on the Web. It can run on both end of Web applications, namely on servers and on clients. In this thesis, we present Hiphop.js, its design and implementation. We overview its programming environment and we present the prototypical web applications we have implemented to validate the approach.

The main goal of this thesis was to implement a functional programming (FP) library named Funk that extends C# with support for concepts present in functional programming languages, such as F# and Scala. Funk utilizes many functional programming concepts, including immutability, pattern matching, and various types of monads, together with stronger typing. Introduction of these concepts into C# helps in avoiding many runtime errors and boilerplate code, and it also lets developers write C# code in a declarative rather than in an imperative way, making the day-to-day software development easier and less error-prone. Additionally, the thesis analyzes and compares Funk with existing functional programming libraries such as Language-ext and FuncSharp. Finally, it analyzes the new features of C# 8, which include nullable reference types and pattern matching and compares them with the functionalities of the Funk library.

Kandidatarbete inom medieteknik med målsättning att förbättra det befintliga begreppet Community utveckling. Detta kandidatarbete visar hur definitionen av Community utvecklats och förändrats med hjälp av modern teknik. Det är inte alltid positiv med nya definitioner. Nya problem uppstår inom communities med management, etikfrågor och underhåll. Detta Kandidatarbetet analyserar dessa problem och strävar efter att lösa dem i en modern standard, med hjälp av rhizomatic och participatory design. Eftersom Community rör sig mot online definitionen, så användes de senaste verktygen som finns tillgängliga inom webbteknik, till att bygga en produkt som använder sig av situated kunskap som ledord och kombinerar participatory design och rhizomatic. Detta för att lösa de pågående problemen som online-Communities stöter på gällande underhållsmässighet och etik. / Bachelors level thesis in Media Technology that aims to improve an existing concept of community development. The thesis shows how the definition of Community has advanced and changed its meanings with the help of modern technology. It is not always positive with new definitions. New problems arise within the community regarding management, ethics, and maintenance. This thesis analyses these problems and aim to solve them in a modern standard, with help of rhizomatic and participatory design. With the community shifting towards an online definition, the thesis uses the latest tools available in web technology, to build a product that uses situated knowledge as a mindset and combines participatory design and rhizomatic. This to solve the ongoing problems that online communities face with maintainability and ethics.

Software components expose Application Programming Interfaces (APIs) as a means to access their functionality, and facilitate reuse. Developers use APIs supplied by programming languages to access the core data structures and algorithms that are part of the language framework. They use the APIs of third-party libraries for specialized tasks. Thus, APIs play a central role in mediating a developer's interaction with software, and the interaction between different software components. However, APIs are often large, complex and hard to navigate. They may have hundreds of classes and methods, with incomplete or obsolete documentation. They may encapsulate concurrency behaviour that the developer is unaware of. Finding the right functionality in a large API, using APIs correctly, and maintaining software that uses a constantly evolving API are challenges that every developer runs into. In this thesis, we design automated techniques to address two problems pertaining to APIs (1) Concurrency analysis of APIs, and (2) API mining. Speci cally, we consider the concurrency analysis of asynchronous APIs, and mining of math APIs to infer the functional behaviour of API methods. The problem of concurrency bugs such as race conditions and deadlocks has been well studied for multi-threaded programs. However, developers have been eschewing a pure multi-threaded programming model in favour of asynchronous programming models supported by asynchronous APIs. Asynchronous programs and multi-threaded programs have different semantics, due to which existing techniques to analyze the latter cannot detect bugs present in programs that use asynchronous APIs. This thesis addresses the problem of concurrency analysis of programs that use asynchronous APIs in an end-to-end fashion. We give operational semantics for important classes of asynchronous and event-driven systems. The semantics are designed by carefully studying real software and serve to clarify subtleties in scheduling. We use the semantics to inform the design of novel algorithms to find races and deadlocks. We implement the algorithms in tools, and show their effectiveness by finding serious bugs in popular open-source software. To begin with, we consider APIs for asynchronous event-driven systems supporting pro-grammatic event loops. Here, event handlers can spin event loops programmatically in addition to the runtime's default event loop. This concurrency idiom is supported by important classes of APIs including GUI, web browser, and OS APIs. Programs that use these APIs are prone to interference between a handler that is spinning an event loop and another handler that runs inside the loop. We present the first happens-before based race detection technique for such programs. Next, we consider the asynchronous programming model of modern languages like C]. In spite of providing primitives for the disciplined use of asynchrony, C] programs can deadlock because of incorrect use of blocking APIs along with non-blocking (asynchronous) APIs. We present the rst deadlock detection technique for asynchronous C] programs. We formulate necessary conditions for deadlock using a novel program representation that represents procedures and continuations, control ow between them and the threads on which they may be scheduled. We design a static analysis to construct the pro-gram representation and use it to identify deadlocks. Our ideas have resulted in research tools with practical impact. Sparse Racer, our tool to detect races, found 13 previously unknown use-after-free bugs in KDE Linux applications. Dead Wait, our deadlock detector, found 43 previously unknown deadlocks in asynchronous C] libraries. Developers have fixed 43 of these races and deadlocks, indicating that our techniques are useful in practice to detect bugs that developers consider worth fixing. Using large APIs effectively entails finding the right functionality and calling the methods that implement it correctly, possibly composing many API elements. Automatically infer-ring the information required to do this is a challenge that has attracted the attention of the research community. In response, the community has introduced many techniques to mine APIs and produce information ranging from usage examples and patterns, to protocols governing the API method calling sequences. We show how to mine unit tests to match API methods to their functional behaviour, for the specific but important class of math APIs. Math APIs are at the heart of many application domains ranging from machine learning to scientific computations, and are supplied by many competing libraries. In contrast to obtaining usage examples or identifying correct call sequences, the challenge in this domain is to infer API methods required to perform a particular mathematical computation, and to compose them correctly. We let developers specify mathematical computations naturally, as a math expression in the notation of interpreted languages (such as Matlab). Our unit test mining technique maps subexpressions to math API methods such that the method's functional behaviour matches the subexpression's executable semantics, as defined by the interpreter. We apply our technique, called MathFinder, to math API discovery and migration, and validate it in a user study. Developers who used MathFinder nished their programming tasks twice as fast as their counterparts who used the usual techniques like web and code search, and IDE code completion. We also demonstrate the use of MathFinder to assist in the migration of Weka, a popular machine learning library, to a different linear algebra library.