The goal of the IWST workshop series is to create and foster a forum around advancements of or experience in Smalltalk. The workshop welcomes contributions to all aspects, theoretical as well as practical, of Smalltalk-related topics. / Zweck der IWST-Workshop-Reihe ist die Formung und Pflege eines Forums fŸr die Diskussion von Fortschritten und Arbeitsergebnissen mit der Programmierumgebung Smalltalk. Der Workshop beinhaltet BeitrŠge zu allen Aspekten von auf Smalltalk bezogenen Arbeiten sowohl theoretischer als auch praktischer Natur.

M.S. / Computer Science & Engineering / QUICKTALK is a dialect of Smalltalk-80 that can be compiled directly into native machine code, instead of virtual machine bytecodes. The dialect includes "hints" on the class of method arguments, instance variables, and class variables. The dialect is designed to describe primitive Smalltalk methods. Improved performance over bytecodes is achieved by eliminating the interpreter loop on bytecode execution, by reducing the number of message send/returns via binding some target methods at compilation, and by eliminating redundant class checking. Changes to the Smalltalk- 80 system and compiler to support the dialect are identified and performance measurements are given.

Thesis (M.S.)--Rochester Institute of Technology, 1984. / Typescript. Includes bibliographical references and appendices.

Thesis (M.S.)--Rochester Institute of Technology, 1991. / Spine title: Hypermedia construction and browsing system in ... Includes bibliographical references (leaves 33-34).

Thesis (Ph. D.) Oregon Graduate Center.

The variety of platforms for describing models of discrete event systems brings about the problem of how these models should be represented in order to be easily shared across platforms (shared for the purposes of model validation, effective execution, model reusing,  or model integration). This study develops and implements the language DEVSML for the representation of the DEVS models. For the description of these models components, I use state diagrams, which are represented by SCXML. Actions and guards of the state diagrams are described using the language Scheme. This study also presents a visual tool for creation of the state diagrams, which is incorporated in the SmallDEVS system. For the Adevs environment, a transformer of the models described by DEVSML is implemented.

Les systèmes actuels tendent à être intégrés les uns avec les autres. Mais cette intégration n'est pas forcément prévue à l'origine du système. Cette tendance créée des systèmes de systèmes. Un système de système de systèmes est un système constitué de systèmes qui sont gérés par des équipes indépendantes, qui sont fonctionnellement indépendants, qui collaborent, qui évoluent et qui sont géographiquement distribués. La communication entre les différentes équipes facilite la conception d'un système de systèmes. Cette communication peut être réalisée par l'utilisation de modèles et de simulation. Cependant, la modélisation du système de systèmes et la modélisation des simulations ne reposent pas sur les mêmes langages. Pour assurer la cohérence des modèles, il faut pouvoir créer les modèles de simulation à partir des modèles système. Cependant, il faut tenir compte des contraintes liées aux propriétés des systèmes de systèmes. Il faut être capable de manipuler des modèles systèmes réalisés dans des langages différents, de réaliser des simulations de natures différentes et suivre les évolutions des langages de modélisation et des outils de simulation. Pour répondre à ces problématiques, nous avons défini l'environnement Role4AII pour la manipulation de modèles systèmes réalisés dans des langages hétérogènes. Role4AII est basé sur la notion de rôles. Les rôles permettent de créer des simulations en accédant aux informations contenues dans des éléments de modèles indépendamment de leur type. Role4AII est capable de prendre en entrée des modèles sérialisés par différents outils grâce à l'utilisation de parsers combinateurs. Ces derniers apportent modularité et extensibilité aux fonctionnalités d'import. L'environnement Role4AII a été utilisé sur un exemple de système de systèmes : l'observatoire sous-marin MeDON. / Current Systems tend to become integrated with each others. However, this intégration may not be designed for the System. This trend raises the concept of System of Systems. A System of Systems is a System made of Systems which are managed independently, functionaly independent, collaborating, evolving and geographically distributed. The communication among the different teams eases the design of the System of Systems. This communication may be made through the use of models and simulation.However, System of Systems models and simulation models do not rely on the same modeling languages. In order to ensure coherency between the two types of models, simulation models should be obtained from System models. But this approach should take into account the constraints coming from the properties of System of Systems. System models made in different modeling languages should be handled, simulation of different kinds should be generated and the evolution of both modeling languages and simulation tools should be managed.In order to tackle these issues, we defined the Role4AII environment to manipulate System models made in heterogeneous modeling languages. Role4AII is based on the concept of rôles. Rôles enable to create simulations by accessing to information stored in model éléments despite their types differences. Role4AII is able to take as input serialized models from different modeling tools by using parser combinators. Parser combinators bring modularity and extensibility to the import features. Role4AII has been used on a System of System example: the MeDON seafloor observatory.

<p>This thesis presents the work of developing and testing a programming tool specially designed for children. The purpose of this tool is to make children capable of creating visual simulations and games that consist of actors interacting in a virtual world. The name of the programming tool is Behavior Cards, which comes from the fact that actors are programmed by giving them cards representing different kinds of behaviors. Behaviors are to some extent pre-programmed and can include general events specifying how the actors should act in different situations, in contrast to specifying every possible situation that can occur. The idea is that Behavior Cards should be easier to use than a more traditional text based programming tool, but it should also be expressive within the domain of visual games. These goals can be accomplished by using different types of representations – such as icons, symbols and text – combined with an interaction technique based on direct manipulation of objects. Two versions of Behavior Cards have been developed and tested together with 11-year-old children. The results show that behaviors were useful for programming relatively advanced visual programs in a quick and effective manner, and that the children were able to learn and use the concept for creating simple programs. Further studies are needed to examine if children also can analyze and solve more complex programming problems.</p> / <p>Arbetet som den här uppsatsen beskriver omfattar utveckling och testning av ett programmeringsverktyg för barn. Syftet med verktyget är att barn ska kunna skapa visuella simulationer och spel genom att programmera aktörer som agerar och interagerar med varandra i en värld. Programmeringsverktygets namn är Behavior Cards, vilket kommer av att aktörernas agerande programmeras genom att tilldela dem kort som representerar olika typer av beteenden. Beteenden är till viss del förprogrammerade och kan innehålla generella händelser för hur aktörer ska agera i olika situationer, i motsats till att definiera varje tänkbar situation som kan uppkomma. Tanken är att programmerandet ska vara enklare än med traditionella, textbaserade, programmeringsspråk, men samtidigt kraftfullt inom den specifika domänen. Detta kan åstadkommas genom att använda olika typer av representationer – såsom ikoner, symboler och text – i kombination med en interaktionsteknik baserad på direktmanipulation av objekt. Två prototyper av programmeringsverktyget har utvecklats och testats på barn i 11-årsåldern. Resultaten visar att beteenden är tillämpbart för att programmera relativt avancerade visuella program på ett snabbt och effektivt sätt, och att barnen kunde lära sig och använda konceptet för att skapa enkla program. Det krävs dock fördjupade studier för att ta reda på om barn kan analysera samt lösa mer komplexa programmeringsproblem.</p>

Highly dynamic languages like Smalltalk do not have much static type information immediately available before the program runs. Static types can still be inferred by analysis tools, but historically, such analysis is only effective on smaller programs of at most a few tens of thousands of lines of code. This dissertation presents a new type inference algorithm, DDP, that is effective on larger programs with hundreds of thousands of lines of code. The approach of the algorithm borrows from the field of knowledge-based systems: it is a demand-driven algorithm that sometimes prunes subgoals. The algorithm is formally described, proven correct, and implemented. Experimental results show that the inferred types are usefully precise. A complete program understanding application, Chuck, has been developed that uses DDP type inferences. This work contributes the DDP algorithm itself, the most thorough semantics of Smalltalk to date, a new general approach for analysis algorithms, and experimental analysis of DDP including determination of useful parameter settings. It also contributes an implementation of DDP, a general analysis framework for Smalltalk, and a complete end-user application that uses DDP.

Doctor en Ciencias, Mención Computación / Los lenguajes de tipado dinámico permiten un desarrollo ágil, el cual es util para construir prototipos rápidamente. Sin embargo, cuando estos pequeños programas se convierten en aplicaciones grandes, depurar se vuelve una tarea tediosa. Esto se debe principalmente a que los errores son solo detectables en tiempo de ejecución. Smalltalk, al ser un lenguaje de tipado dinámico, sufre de estos problemas. Los sistemas de tipos pueden disminuir ciertos errores de los lenguajes de tipado dinámico. Además, la inserción de tipos mejora la documentación de APIs, provee mejor soporte a los editores y ayuda a optimizar la compilación. Los sistema de tipos, especialmente diseñados para lenguajes existentes, son llamados sistema de tipos retro-alimentados (retrofitted type systems en inglés). Diseñar un sistema de tipos retro-alimentado es una tarea complicada. Esto se debe a que tales sistemas de tipos deben soportar patrones de programación muy particulares (llamados idioms), minimizar la refactorización de código por la inserción de tipos, y proveer una integración entre las partes (ej. módulos) con y sin tipos. Estos problemas son exacerbados cuando el lenguaje destino es altamente dinámico, como Smalltalk. Si bien se ha intentado insertar tipos en Smalltalk, el ejemplo mas notable es Strongtalk, ellos no han sido diseñados de un modo de ser sistemas de tipos retro-alimentados. Ademas Strongtalk es un sistema de tipos opcional, es decir que las garantías estáticas no necesariamente se cumple en tiempo de ejecución. En este trabajo de tesis, nosotros presentamos Gradualtalk, un sistema de tipos retro-alimentado para Smalltalk, que soporta la mayoría de las características particulares e idioms de Smalltalk. En la parte del diseño, nosotros analizamos detalladamente cual es el mejor sistema de tipos gradual y aquellas extensiones que mejor encajan en Gradualtalk. Cada una de estas extensiones son claramente justificadas usando evidencia (empírica) disponible en la literatura o propuesta por nosotros. En detalle, nosotros presentamos como evidencia empirical dos estudios a larga escala sobre las características dinámicas de Smalltalk y sobre los predicados de tipos. Ademas presentamos tres estudios preliminares sobre el uso de self, el uso de variables que pueden representar varios valores de diferente tipos, y el uso de colecciones. Con toda esta información implementamos una primera version de Gradualtalk. Finalmente, validamos Gradualtalk mediante la inserción de tipos de varios proyectos Smalltalk reales.