Combining functional and object-imperative software components

Yksi ensimmäisistä tehtävistä ohjelman toteutuksen alkuvaiheessa on ohjelmointikielen valinta. Tutkimukset ovat osoittaneet, että sopivan ohjelmointikielen valinnalla on suuri merkitys ohjelman elinkaarikustannuksiin. Siksi valinta tulisikin tehdä hyvin perusteltujen syiden pohjalta. Koska yleisimmin käytetyt ohjelmointikielet ovat olio-imperatiivisia, on siksi olemassa erittäin paljon valmiita ohjelmistokomponentteja, jotka on toteutettu näillä kielillä. Täysin uuttakaan ohjelmaa toteutettaessa ei yleensä haluta toteuttaa kaikkia ominaisuuksia aivan alusta asti, vaan ohjelmiston suunnittelussa pyritään hyödyntämään olemassa olevia komponentteja. Kun ohjelmointikieleksi valitaan esimerkiksi funktionaalinen kieli, on usein varauduttava liittymään jollain muulla ohjelmointikielellä toteutettuun komponenttiin. Tällaisissa tapauksissa kahden erilaisen ohjelmointikielen ja niiden paradigmojen yhdistäminen saattaa olla haasteellista. Tässä diplomityössä tutkitaan, miten C#:lla ja F#:lla toteutettujen komponenttien yhdistäminen voidaan tehdä ja miten eri paradigmojen yhdistämisestä seuraavat ongelmat voidaan ratkaista. Tämän lisäksi työssä tutkittiin C#:n ja F#:n käytettävyyttä haastattelututkimuksen avulla. Tutkimuksella selvitettiin, millaisia etuja funktionaalisen F#:n käytöllä on verrattuna olio-imperatiiviseen C#:iin ja saadaanko sen käytöstä niin paljon hyötyä, että sitä kannattaa käyttää vaikka joutuisi tekemään lisätyötä C#:lla toteutettuun ohjelmaan liittyäkseen. Tämä diplomityö on tehty Atostek Oy:lle, jossa C#- ja F#-kieliä on hyödynnetty useissa käytännön ohjelmistoprojekteissa. Siinä missä C# on yleisesti käytetty olio-imperatiivinen kieli, on F# funktionaalinen. C#:n ja F#:n tapauksessa yhteinen ajoympäristö, Microsoftin .NET, ratkaisee ison osan eri kielillä kirjoitettujen komponenttien yhdistämisen ongelmista. Ratkaisematta kuitenkin jää edelleen paradigmojen yhdistämisestä aiheutuvat haasteet. Haastattelututkimuksella onnistuttiin saamaan selville ohjelmistosuunnittelijoiden kummankin kielen käytännön hyödyntämiseen perustuvat mielipiteet. Haastattelujen tulokset ovat keskenään hyvin yhdenmukaisia ja antavat hyvän kuvan funktionaalisen F#:n hyödyntämisestä käytännössä.One of the first tasks when starting the implementation of a new program is to choose a programming language. Studies show that software life cycle cost can be influenced by choosing an appropriate programming language. Therefore the selection of the language should be based on rational reasoning. The most popular programming languages today are object-imperative. Therefore there exist plenty of ready-made software components implemented in those languages. Even when implementing a completely new program, it is not usually appropriate to implement all its features from scratch. Therefore, ready-made components are used. When, for example, a functional programming language is chosen as the implementation language, the program must be prepared to be integrated to components implemented in some other language. In these cases integrating different languages and different paradigms may raise problems. This master’s thesis describes how software components implemented with C# and F# can be integrated, and how the problems caused by the different programming paradigms can be solved. Also the usability of C# and F# is studied by interviewing software developers who have used the languages in practice. The study also tried to find out what are the benefits of using F# compared to C# and if the benefits overcome the extra work that is required to integrate components implemented in another programming paradigm. This master’s thesis is made for Atostek Oy, where C# and F# programming languages are used in software projects. C# is a widely used object-imperative language, and F# is its functional counterpart. Both languages are executed in the Microsoft’s .NET framework. In the case of C# and F#, the runtime environment solves most of the problems of integrating software components implemented in different programming languages. However, the problems caused by different paradigms must still be solved. Results of the interviews show what are the software developers’ thoughts on using both languages in practice. The results were consistent and provide a comprehensive view to the practical use of F#

The Polylith Software Bus

We describe a system called POLYLITH that helps programmers prepare and interconnect mixedlanguage software components for execution in heterogeneous environments. POLYLITH'S principal benefit is that programmers are free to implement functional requirements separately from their treatment of interfacing requirements; this means that once an application has been developed for use in one execution environment (such as a distributed network) it can be adapted for reuse in other environments (such as a share d-memory multiprocessor) by automatic techniques. This flexibility is provided without loss of performance. We accomplish this by creating a new run-time organization for software. An abstract decoupling agent, called the software toolbus, is introduced between the system components. Heterogeneity in language and architecture is accommodated since program units are prepared to interface directly to the toolbus, not to other program units. Programmers specify application structure in terms of a module interconnection language (MIL); POLYLITH uses this specification to guide packaging (static interfacing acti vities such as stub generation, source program adaptation, compilation and linking). At run time, an implementation of the toolbus abstraction may assist in message delivery, name service or system reconfiguration. (Also cross-referenced as UMIACS-TR-90-65

Language Design for Reactive Systems: On Modal Models, Time, and Object Orientation in Lingua Franca and SCCharts

Reactive systems play a crucial role in the embedded domain. They continuously interact with their environment, handle concurrent operations, and are commonly expected to provide deterministic behavior to enable application in safety-critical systems. In this context, language design is a key aspect, since carefully tailored language constructs can aid in addressing the challenges faced in this domain, as illustrated by the various concurrency models that prevent the known pitfalls of regular threads. Today, many languages exist in this domain and often provide unique characteristics that make them specifically fit for certain use cases. This thesis evolves around two distinctive languages: the actor-oriented polyglot coordination language Lingua Franca and the synchronous statecharts dialect SCCharts. While they take different approaches in providing reactive modeling capabilities, they share clear similarities in their semantics and complement each other in design principles. This thesis analyzes and compares key design aspects in the context of these two languages. For three particularly relevant concepts, it provides and evaluates lean and seamless language extensions that are carefully aligned with the fundamental principles of the underlying language. Specifically, Lingua Franca is extended toward coordinating modal behavior, while SCCharts receives a timed automaton notation with an efficient execution model using dynamic ticks and an extension toward the object-oriented modeling paradigm

ESys.Net : a new .Net based system-level design environment

Mémoire numérisé par la Direction des bibliothèques de l'Université de Montréal

Nouvelles approches pour la conception d'outils CAO pour le domaine des systèmes embarqués

Thèse numérisée par la Division de la gestion de documents et des archives de l'Université de Montréal

Models of higher-order, type-safe, distributed computation over autonomous persistent object stores

A remote procedure call (RPC) mechanism permits the calling of procedures in another address space. RPC is a simple but highly effective mechanism for interprocess communication and enjoys nowadays a great popularity as a tool for building distributed applications. This popularity is partly a result of their overall simplicity but also partly a consequence of more than 20 years of research in transpaxent distribution that have failed to deliver systems that meet the expectations of real-world application programmers. During the same 20 years, persistent systems have proved their suitability for building complex database applications by seamlessly integrating features traditionally found in database management systems into the programming language itself. Some research. effort has been invested on distributed persistent systems, but the outcomes commonly suffer from the same problems found with transparent distribution. In this thesis I claim that a higher-order persistent RPC is useful for building distributed persistent applications. The proposed mechanism is: realistic in the sense that it uses current technology and tolerates partial failures; understandable by application programmers; and general to support the development of many classes of distributed persistent applications. In order to demonstrate the validity of these claims, I propose and have implemented three models for distributed higher-order computation over autonomous persistent stores. Each model has successively exposed new problems which have then been overcome by the next model. Together, the three models provide a general yet simple higher-order persistent RPC that is able to operate in realistic environments with partial failures. The real strength of this thesis is the demonstration of realism and simplicity. A higherorder persistent RPC was not only implemented but also used by programmers without experience of programming distributed applications. Furthermore, a distributed persistent application has been built using these models which would not have been feasible with a traditional (non-persistent) programming language

Supporting distributed computation over wide area gigabit networks

The advent of high bandwidth fibre optic links that may be used over very large distances has lead to much research and development in the field of wide area gigabit networking. One problem that needs to be addressed is how loosely coupled distributed systems may be built over these links, allowing many computers worldwide to take part in complex calculations in order to solve "Grand Challenge" problems. The research conducted as part of this PhD has looked at the practicality of implementing a communication mechanism proposed by Craig Partridge called Late-binding Remote Procedure Calls (LbRPC). LbRPC is intended to export both code and data over the network to remote machines for evaluation, as opposed to traditional RPC mechanisms that only send parameters to pre-existing remote procedures. The ability to send code as well as data means that LbRPC requests can overcome one of the biggest problems in Wide Area Distributed Computer Systems (WADCS): the fixed latency due to the speed of light. As machines get faster, the fixed multi-millisecond round trip delay equates to ever increasing numbers of CPU cycles. For a WADCS to be efficient, programs should minimise the number of network transits they incur. By allowing the application programmer to export arbitrary code to the remote machine, this may be achieved. This research has looked at the feasibility of supporting secure exportation of arbitrary code and data in heterogeneous, loosely coupled, distributed computing environments. It has investigated techniques for making placement decisions for the code in cases where there are a large number of widely dispersed remote servers that could be used. The latter has resulted in the development of a novel prototype LbRPC using multicast IP for implicit placement and a sequenced, multi-packet saturation multicast transport protocol. These prototypes show that it is possible to export code and data to multiple remote hosts, thereby removing the need to perform complex and error prone explicit process placement decisions

Solving the year 2000 dilemma

https://egrove.olemiss.edu/aicpa_guides/1551/thumbnail.jp