DOCSLIB.ORG

Using Oberon's Active Objects for Language Interoperability and Compilation Patrik Reali

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Using Oberon's Active Objects for Language Interoperability and Compilation Patrik Reali Using Oberon’s Active Objects for Language Interoperability and Compilation Patrik Reali Diss. ETH No. 15022 Using Oberon's Active Objects for Language Interoperability and Compilation A dissertation submitted to the SWISS FEDERAL INSTITUTE OF TECHNOLOGY ZURICH (ETH ZU¨ RICH) for the degree of Doctor of Technical Sciences presented by Patrik Rene´ Celeste Reali Dipl. Informatik-Ing. ETH born July 11, 1971 citizen of Isorno, Switzerland accepted on the recommendation of Prof. Dr. Jur¨ g Gutknecht, examiner Prof. Dr. Bertrand Meyer, co-examiner 2003 c Patrik Reali, 2003. All rights reserved i Programming in different languages is like composing pieces in different keys, particularly if you work at the keyboard. If you have learned or written pieces in many keys, each key will have its own special emotional aura. Also, certain kinds of figurations “lie in the hand” in one key but are awkward in another. So you are channeled by your choice of key. In some ways, even enharmonic keys, such as C-sharp and D-flat, are quite distinct in feeling. This shows how a notational system can play a significant role in shaping the final product. — D. Hofstadter; G¨odel, Escher, Bach: an eternal golden braid i Acknowledgments A thesis is supposed to be the work of one person. Nevertheless, this work would have not be possible without the collaboration, support, feedback, and encouragement from many persons. First of all, I would like to thank Prof. J. Gutknecht for giving me the chance to work in his group, and for his liberal supervision of the thesis. Prof. B. Meyer kindly accepted to be co-examiner and provided very competent feedbacks. I wish thank all the past and present members of the language and run-time research group, which created such an interesting and challenging environment, in particular Pieter Muller, who shared the same office with me for more than four years, and for introducing me to the secrets of system construction and of south african culture. Many thanks go also to A. Disteli, B. Egger, A. Fischer, T. Frey, P. Kramer, E. Oswald, K. Skoupy, E. Zeller, and E. Zueff. The Institute for Computer Systems at ETH provided a very lively frame to any kind of discus- sions and activities, ranging from technical topics to wine tasting. Life at ETH would have been dull without H. Domjan, R. Karrer, C. Kurmann, C. von Praun, E. Ruiz, H. Sommer, M. Taufer, and all the past and present members of the institute. Never miss a coffee break or an Assistentenabend for any reason! The student assignments of G. Banfi, R. Laich, and R. Morelli has been relevant for this thesis, and greatly helped me. Some external collaborations need also to be mentionned: P. Januschke for the interesting and productive discussions about the design and implementation of OberonX; M. van Hacken for fruit- ful collaboration in project Hostess; A. Freed and C. Langreiter for the constant encouragement. I’m deeply indebted to S. Brawer and A. Fischer for reading early drafts of this thesis and pointing out many errors or inconsistencies. Last but not least, I would like to thank my parents Annie and Carlo, and my wife Andrea, for their support and the great display of patience (or forced unto them). iii Table of Contents Acknowledgments iii Table of Contents v Abstract vii Kurzfassung ix 1 Introduction 1 1.1 Motivation . 2 1.2 This Thesis . 4 1.3 Overview . 5 2 Conceptual Framework 7 2.1 Layered system . 7 2.2 Components and Interoperability . 11 2.3 The Aos Approach . 16 2.4 Related Work . 19 3 Interoperability 25 3.1 Introduction . 25 3.2 Type Mapping . 27 3.3 Object Model Flavors . 32 3.4 Mappings and Conversions . 36 3.5 Examples . 45 3.6 Wrap-up . 47 3.7 The Jaos Approach . 50 4 Active Objects in Practice: the Active Oberon Language 53 4.1 Introduction . 53 4.2 Object Oriented Extensions . 58 4.3 Concurrency Support . 62 v vi Table of Contents 4.4 Other Language Extensions . 64 4.5 Interoperability Additions . 66 5 Case Study: The Active Oberon Compiler 67 5.1 The Compiler Framework . 67 5.2 Metadata Repository . 68 5.3 Scope Concurrent Parser . 73 5.4 Back-End Component . 76 5.5 Plug-Ins . 84 5.6 Interoperability with Java . 91 5.7 Compiler Testing and Maintenance . 96 6 The Aos Kernel as Language Interoperability Platform 101 6.1 Introduction . 101 6.2 Aos as Interoperability Platform . 101 6.3 Run-time Layer: API and Conventions . 103 7 Case Study: The Jaos JVM 115 7.1 Introduction . 115 7.2 Mapping Java To Aos . 120 7.3 JVM Implementation . 128 7.4 Interoperability with Oberon . 134 8 Conclusions 139 8.1 Achievements . 139 8.2 Future Directions . 140 8.3 Concluding Remarks . 142 A Active Oberon Examples 145 A.1 Synchronization Examples . 146 A.2 Active Object Examples . 152 B Critique of the Oberon Language 155 B.1 Syntax . 155 B.2 Semantic . 156 B.3 Design . 159 B.4 Other Proposals . 160 Bibliography 163 Curriculum Vitae 171 vi Abstract The modern run-time environments provide a high-level object-oriented programming model, re- flection capabilities, and a large amount of libraries. These platforms are particularly suitable to host programs written in many different languages. To let all languages reuse the common li- braries, the platform has a reflection mechanisms to access the metadata information, which can be used by the compilers to provide language interoperability in a seamless way. Writing a compiler for such platforms becomes an exercise in programming model mapping. Most of the languages rely on closely related flavors of the object-oriented model, but the mappings from one model to another are not always trivial. This thesis investigates the implementation of a language interoperability platform based on an active object-based object-oriented model. First, it analyzes the relations between the type systems of the platform and its subset used for interoperability, and the languages for the platform. Each language type system must be mappable to the platform type system, and the interoperability type system must be bidirectionally mappable to every language type system. Many languages implement a different flavor of the object-oriented model. A few simple mapping rules to transform each flavor onto another one are presented. Second, the Aos kernel implementing Active Oberon’s active object model is introduced as language interoperability platform. The language Active Oberon is presented as natural notation for the active object model. The Paco scope-parallel Active Oberon compiler is a case study that shows a non-trivial application relying on active objects. It parses each scope concurrently and solves forward references in the code with parser synchronization, instead of requiring a second parsing pass. Third, the Jaos Java Virtual Machine for Aos is presented. The jit-compiler maps the Java model to the active object model, and compiles the java byte-code using the data-layout and facili- ties provided by the kernel; the jit-compiler and the Java reflection libraries use the same metadata repository as the Active Oberon compiler: this allows both languages to interoperate seamlessly. Plugins for the metadata repository and for the kernel’s dynamic loader allow to use multiple meta- data persistency formats and multiple object-file formats at the same time. vii Kurzfassung Die modernen Laufzeitumgebungen definieren ein objektorientiertes Programmiermodel, Reflekti- onsfunktionalit¨at und umfangreiche Funktionsbibliotheken. Diese Plattformen eignen sich beson- ders gut um Programme zu unterst¨utzen, die in verschiedenen Programmiersprachen entwickelt worden sind. Um den Zugriff auf die gemeinsamen Funktionsbibliotheken zu erm¨oglichen, bietet die Plattform durch Reflektion Zugriff auf Metadaten an, damit die Compiler eine automatisierte und transparente Sprachinteroperabilit¨at gew¨ahrleisten k¨onnen. Ein Compiler f¨ur solche Platformen wird zum Programmiermodel¨ubersetzer. Obwohl die mei- sten Programmiersprachen auf Varianten des objektorientieren Modells basieren, sind die Abbil- dungen von Modelvariante zu Modelvariante sind nicht immer trivial, und oft mit semantischen Verlusten behaftet. Diese These untersucht die Implementation einer Sprachinteroperabilit¨atsplattform basierend auf aktiven Objekten. Zuerst werden die Beziehungen zwischen dem Programmiersprachtypsystems, dem Plattforms- typsystemen, und dem gemeinsamen Interoperabilit¨atstypsystem analysiert. Das Programmier- sprachtypsystem soll vollst¨andig auf das Plattformtypsystem abbildbar sein. Das Interoperabi- lit¨atstypsystem soll dazu bidirektional auf eine Untermenge des Programmiersprachtypsystem ab- bildbar sein. Es wird vorgestellt, wie die verschiedenen Varianten des objektorientierten Models aufeinander abgebildet werden k¨onnen. Zweitens wird der Aos-Kernel als Sprachinteroperabilit¨atsplattform vorgestellt. Das auf akti- ven Objekten basierte Modell und die Active Oberon Programmiersprache werden eingef¨uhrt. Der parallele Paco Compiler f¨ur Active Oberon wird als Fallstudie einer nicht trivialen Anwendung aktiver Objekte gezeigt. Paco ¨ubersetzt jeden Sichtbarkeitbereich im Quellecode nebenl¨aufig, und behandelt Symbolreferenzen, die vor der Symboldefinition auftreten, als Synchronisationsproblem, statt einen zweiten Durchlauf ¨uber den Quellcode zu verlangen. Drittens wird die Jaos Java Virtual Machine f¨ur Aos vorgestellt. Der just-in-time Compiler bil- det das Java-Model auf Oberons aktive Objekte ab. Die Abbildung verwendet so weit wie m¨oglich die Datenauslegung und Funktionalit¨at des Kernels; der jit-Compiler und die Java Reflektions- klassen bauen auf den selben Metadaten wie der Paco Compiler. Damit k¨onnen beide Sprachen transparent interoperieren. Die Plugin-basierte Architektur des Metadaten-Systems und des dy- namischen Laders erlauben die gleichzeitige Verwendung von unterschiedlichen Metadaten- und Objektfileformate. ix 1 Introduction Eine Verbesserung erfindet nur der, welcher zu fuhlen¨ weiss: dies ist nicht gut — Friedrich Nietzsche Language interoperability has been in use since the second programming language appeared, but in such a small extent, that awareness about it came only at a later stage. Every time two software components exchange information, they have to agree on a common protocol to be able to share the information: this is interoperability at work.
Load more

Recommended publications
  • ETH Eidgenossische Technische Hochschule Zurich H.Eberle
    ETH Eidgenossische lnstitut Technische fur lnformatik Hochschule ZUrich H.Eberle Hardware Description of the Workstation Ceres 11nuar 1987 ,70 70 . 61 .10 ETH Eidgenossische lnstitut Technische fur lnformatik Hochschule Zurich Eidrg. ~hn. ZI!rich lrricrm!!~!~:.~~lb;i::1H1a-k ETH~Zentrum CH..oo92 Zurich H.Eberle Hardware Description of the Workstation Ceres EidQ. lechn. He:ch'?~h'Jle Zilr\J::;!-: lnforme::!':.uib~iuthek El'l I-lei ili rn 11 CH-8002 ZOrtch gl,4-,23 Address of the author: lnstitut fiJr lnformatik ETH-Zentrum CH-8092 Zurich I Switzerland © 1987 lnstitut tor lnformatik, ETH Zurich 1 Hardware Description of the Workstation Ceres H.Eberle Abstract Ceres is a single-user computer based on the 32-bit microprocessor NS32000. The processor is oriented to the use of high-level languages. The hardware design concentrates on simplicity and modularity. The key features are the arbitrated memory bus and the high resolution bitmapped graphics display which promotes the attractivity of a programming workstation. This paper documents the hardware of the Ceres computer. 2 Contents 1 Introduction 3 2 Hardware Structure 4 2.1 Processor 4 2.2 Primary Memory 4 2.3 Secondary Memory 4 2.4 Input/Output Devices 4 3 Hardware Implementation 6 3.1 Processor Board 6 3.1.1 Processor 6 3.1.2 Memory Bus Arbiter 9 3.1.3 Boot ROM and Standard Input/Output Devices 12 3.2 Memory Board 15 3.3 Display Controller Board 18 3.3.1 Display Memory 18 3.3.2 Display Refresh Controller 19 3.4 Disk Controller Board 23 3.5 Motherboard 23 4 Hardware Extensions 24 References 26 Appendices A Circuit Diagrams 28 A.1 Processor Board 28 A.2 Memory Board 35 A.3 Display Controller Board 37 B PAL Design Specifications 42 c Interface Connectors 47 C.1 Processor Board 47 C.2 Display Controller Board 48 C.3 Motherboard 48 3 1 Introduction Todays working tools of a software engineer at the lnstitut fUr lnformatik of ETH ZOrich are the programming language Modula-2 [1] and the workstation computer Lilith [2].
    [Show full text]
  • Niklaus Wirth—A Pioneer of Computer Science 1
    Niklaus Wirth—A Pioneer of Computer Science 1 Niklaus Wirth — a Pioneer of Computer Science Gustav Pomberger, Hanspeter Mössenböck, Peter Rechenberg Johannes Kepler University of Linz [email protected], [email protected], [email protected] Abstract Niklaus Wirth is one of the most influential scientists of the early computer age. His ideas and especially his programming languages have shaped gen- erations of programmers worldwide. This paper tries to acknowledge the scientific achievements of Niklaus Wirth and to honor him as a person. A small part of the paper is also devoted to Wirth's influence on computer sci- ence at the Johannes Kepler University of Linz. 1 Introduction Ask computer specialists anywhere—be it in Europe or America, in Asia or Australia—who the most important computer scientists in the world are, and you can bet that the name Niklaus Wirth will be on every list. Ask programming language experts about the person with the greatest influence on the development of programming languages, and they would agree on Niklaus Wirth. Ask students, teachers and computer hobbyists about the most important programming lan- guages, and you can be sure that even today Pascal will be on every list. Finally, examine the literature of computer science in the elite circle of books with the greatest number of copies printed, the widest distribution, and the most transla- tions, and you will find books by Niklaus Wirth, especially the prominent book on Pascal. These few examples show that professor Niklaus Wirth is one of the world's leading computer scientists.
    [Show full text]
  • System Construction
    System Construction Autumn Semester 2017 ETH Zürich Felix Friedrich 1 Goals . Competence in building custom system software from scratch . Understanding of „how it really works“ behind the scenes across all levels . Knowledge of the approach of fully managed lean systems A lot of this course is about detail. A lot of this course is about bare metal programming. 2 Course Concept . Discussing elaborated case studies . In theory (lectures) . and practice (hands-on lab) . Learning by example vs. presenting topics 3 Prerequisite . Knowledge corresponding to lectures Systems Programming and/or Operating Systems . Do you know what a stack-frame is? . Do you know how an interrupt works? . Do you know the concept of virtual memory? . Good reference for recapitulation: Computer Systems – A Programmer's Perspective 4 Links . SVN repository https://svn.inf.ethz.ch/svn/lecturers/vorlesungen/trunk/syscon/2017/shared . Links on the course homepage http://lec.inf.ethz.ch/syscon 5 Background: Co-Design @ ETH Languages (Pascal Family) +MathOberon Active Modula Oberon ActiveOberon Cells Oberon07 Zonnon Operating / Runtime Systems Medos Oberon Aos A2 SoC HeliOs Minos LockFree Kernel Hardware x86 / IA64/ ARM TRM Lilith Ceres Emulations on (FPGA) Unix / Linux RISC (FPGA) 1980 1990 2000 2010 6 Course Overview Part1: Contemporary Hardware Case Study 1. Minos: Embedded System . Safety-critical and fault-tolerant monitoring system . Originally invented for autopilot system for helicopters . Topics: ARM Architecture, Cross-Development, Object Files and Module Loading, Basic OS Core Tasks (IRQs, MMUs etc.), Minimal Single-Core OS: Scheduling, Device Drivers, Compilation and Runtime Support. With hands-on lab on Raspberry Pi (2) 7 Course Overview Part1: Contemporary Hardware Case Study 2.
    [Show full text]
  • A Modula-2 Oriented Operating System for the Personal Computer Lilith
    Diss. ETH No. 7346 Medos-2: A Modula-2 Oriented Operating System for the Personal Computer Lilith A dissertation submitted to the SWISS FEDERAL INSTITUTE OF TECHNOLOGY ZURICH for the degree of Doctor of Technical Sciences presented by SVEND ERIK KNUDSEN Dipl. Phys. ETH born October 19,1947 citizen of Thalwil (Zurich) accepted to the recommendation of Prof. Dr. N. Wirth, examiner Prof. Dr. C.A. Zehnder, co-examiner Zurich 1983 C 1983 by Svend Erik Knudsen, Grundsteinstr. 2, CH-8804 Au/ZH Preface In the fall of 1977, Prof. N. Wirth started an integrated hardware and software project aiming at the construction of a modern personal computer, a highly desirable tool for the creative software engineer. The principal parts of the so-called Lilith project were the design of the programming language Modula-2 and the construction of a multipass compiler for it, the design of a suitable machine architecture for the execution of compiled programs, the design and construction of a computer capable of efficiently interpreting the defined machine architecture and equipped with the desired peripheral devices, the design and the implementation of the single-user operating system Medos-2, the development of modern text and graphic editors taking full advantage of the computer's capabilities, and the development of a whole range of utility programs and library modules supporting the preparation of documents and the development of programs. After successful prototyping a series of 20 computers was built. During the first year of the project, I was mainly involved in the programming language part of the project.
    [Show full text]
  • Project Oberon the Design of an Operating System and Compiler
    1 Niklaus Wirth Jürg Gutknecht Project Oberon The Design of an Operating System and Compiler Edition 2005 2 Project Oberon Preface This book presents the results of Project Oberon, namely an entire software environment for a modern workstation. The project was undertaken by the authors in the years 1986-89, and its primary goal was to design and implement an entire system from scratch, and to structure it in such a way that it can be described, explained, and understood as a whole. In order to become confronted with all aspects, problems, design decisions and details, the authors not only conceived but also programmed the entire system described in this book, and more. Although there exist numerous books explaining principles and structures of operating systems, there is a lack of descriptions of systems actually implemented and used. We wished not only to give advice on how a system might be built, but to demonstrate how one was built. Program listings therefore play a key role in this text, because they alone contain the ultimate explanations. The choice of a suitable formalism therefore assumed great importance, and we designed the language Oberon as not only an effective vehicle for implementation, but also as a publication medium for algorithms in the spirit in which Algol 60 had been created three decades ago. Because of its structure, the language Oberon is equally well suited to exhibit global, modular structures of programmed systems. In spite of the small number of man-years spent on realizing the Oberon System, and in spite of its compactness letting its description fit a single book, it is not an academic toy, but rather a versatile workstation system that has found many satisfied and even enthusiastic users in academia and industry.
    [Show full text]
  • Implementation of a Modula 2 Subset Compiler Supporting a 'C' Language Interface Using Commonly Available UNIX Tools Raymond Shear F
    Rochester Institute of Technology RIT Scholar Works Theses Thesis/Dissertation Collections 1989 Implementation of a Modula 2 subset compiler supporting a 'C' language interface using commonly available UNIX tools Raymond Shear F. Follow this and additional works at: http://scholarworks.rit.edu/theses Recommended Citation Shear, Raymond F., "Implementation of a Modula 2 subset compiler supporting a 'C' language interface using commonly available UNIX tools" (1989). Thesis. Rochester Institute of Technology. Accessed from This Thesis is brought to you for free and open access by the Thesis/Dissertation Collections at RIT Scholar Works. It has been accepted for inclusion in Theses by an authorized administrator of RIT Scholar Works. For more information, please contact [email protected]. Rochester Institute of Technology School of Computer Science And Technology Implementation of A Modula 2 Subset Compiler Supporting a 'C' Language Interface Using Commonly Available UNIX Tools by Raymond F. Shear, Jr. A thesis, submitted to The Faculty of the School of Computer Science and Technology, in partial fulfillment of the requirements for the degree of Master of Science in Computer Science. Approved by: Professor Peter Lutz11//1/" Profes""or Andrew KltC:t/t7/IJ<i /71f(Y \"r Pri5tessor Peter Anderson I April 2, 1989 Implementation of a Modula 2 Subset Compiler Supporting a 'C' Language Interface Using Commonly Available UNIX Tools I Raymond F. Shear, Jr. hereby grant permission to Wallace Memorial Library, of RIT, to reproduce my thesis in whole or in part. Any reproduction will not be for commercial use or profit. Raymond F. Shear April 19, 1989 ACKNOWLEDGEMENTS This document represents not just the efforts of its author but the intellectual, emotional and spiritual support of a great number of people over the duration of the thesis project and the educational experiences which have lead up to it.
    [Show full text]
  • Wirth Transcript Final
    A. M. Turing Award Oral History Interview with Niklaus Wirth by Elena Trichina ETH, Zürich, Switzerland March 13, 2018 Trichina: My name is Elena Trichina. It is my honor to interview Professor Niklaus Wirth for the Turing Award Winners Project of the Association for Computing Machinery, the ACM. The Turing Award, sometimes referred to as “the Nobel Prize of computing,” is given annually for major contributions of lasting importance in computing. Professor Wirth received his award in 1984 in recognition of his outstanding work in developing a sequence of programming languages – Euler, Algol-W, Pascal, Modula. The hallmarks of Wirth’s languages are their simplicity, economy of design, and high-level engineering. We will talk about it and many other things later today in the interview that takes place on the 13th of March, 2018, in the Swiss Federal Institute of Technology. So we start. Ready? Guten Tag, Niklaus. Gruetzi. Wirth: Добрый ден, Елена Василевна Здравствуи [Good morning, Elena. Hello. – ed.] Trichina: Well, although your command of Russian is sufficient, my command of Swiss German is a little bit rudimentary. Shall we continue in one of the languages where we both feel comfortable? What would it be? French? English? Wirth: Oh, I think English is better for me. Yes, yes. Trichina: Okay. It’s probably better for the audience. [laughs] Wirth: Okay. True. Trichina: Okay. We continue in English. Here in front of me there is a list of the most important days in your life. You were born in February 1934 in Winterthur, which is a sort of middle-size industrial town in Switzerland.
    [Show full text]
  • System Construction
    System Construction Autumn Semester 2015 Felix Friedrich 1 Goals . Competence in building custom system software from scratch . Understanding of „how it really works“ behind the scenes across all levels . Knowledge of the approach of fully managed lean systems A lot of this course is about detail. A lot of this course is about bare metal programming. 2 Course Concept . Discussing elaborated case studies . In theory (lectures) . and practice (hands-on lab) . Learning by example vs. presenting topics 3 Prerequisite . Knowledge corresponding to lectures Systems Programming and/or Operating Systems . Do you know what a stack-frame is? . Do you know how an interrupt works? . Do you know the concept of virtual memory? . Good reference for recapitulation: Computer Systems – A Programmer's Perspective 4 Links . SVN repository https://svn.inf.ethz.ch/svn/lecturers/vorlesungen/trunk/syscon/2015/shared . Links on the course homepage http://lec.inf.ethz.ch/syscon/2015 5 Background: Co-Design @ ETH Languages (Pascal Family) +MathOberon Active Modula Oberon ActiveOberon Cells Oberon07 Zonnon Operating / Runtime Systems Medos Oberon Aos A2 SoC HeliOs Minos LockFree Kernel Hardware x86 / IA64/ ARM TRM Lilith Ceres Emulations on (FPGA) Unix / Linux RISC (FPGA) 1980 1990 2000 2010 6 Course Overview Part1: Contemporary Hardware Case Study 1. Minos: Embedded System . Safety-critical and fault-tolerant monitoring system . Originally invented for autopilot system for helicopters . Topics: ARM Architecture, Cross-Development, Object Files and Module Loading, Basic OS Core Tasks (IRQs, MMUs etc.), Minimal Single-Core OS: Scheduling, Device Drivers, Compilation and Runtime Support. new Now with hands-on lab on Raspberry Pi (2) 7 Course Overview Part1: Contemporary Hardware Case Study 2.
    [Show full text]
  • Oberon = Education + Innovation, Hong Kong Baptist University, 2016-11-30 1
    F.V.Tkachov, Oberon = Education + innovation, Hong Kong Baptist University, 2016-11-30 1 HONG KONG BAPTIST UNIVERSITY FACULTY OF SCIENCE Department of Computer Science Colloquium 2016 Series Oberon = Education + Innovation Dr. Fyodor Tkachov Leading researcher, Russian Academy of Sciences Date: November 30, 2016 (Wednesday) Time: 2:30 - 3:30 pm Venue: SCT909, Cha Chi Ming Science Tower, Ho Sin Hang Campus Abstract The Project Oberon by Niklaus Wirth (Turing Award, 1984) and Jurg Gutknecht (ETH, Zurich) summarizes the essence of programming in a minimalistic language and IDE that are in a stunning contrast with mainstream tools in regard of size, robustness, flexibility and smooth workflow. Oberon has been influencing the IT industry (Java, C#, Golang ...) and proves to be a perfect backbone for systematic programming education encompassing students of ages 12 (introduction) to 20+ (software architecture, compiler construction etc.). It also proves to be a great tool (even a silver bullet in a number of cases) for various projects that are cost sensitive OR require a stringent quality of software OR are immune to the pressures of IT mainstream OR cannot push the costs of the mainstream complexity on to unsavvy customers, as in application areas such as: drones, nuclear power stations, various industrial automation, theoretical and experimental scientific research, teaching programming to 12-year old kids ... The talk is based on the diverse experiences accumulated by the participants of the educational project Informatika-21 since the
    [Show full text]
  • Tech-Savvy Girls
    Tech-SavvyTech-Savvy EducatingEducating GirlsGirls inin thethe NewNew ComputerComputer AgeAge aauw Educational foundation Commission on Technology, Gender, and Teacher Education TECH-SAVVYTECH-SAVVY Educating Girls in the New Computer Age By the AAUW Educational Foundation Commission on Technology, Gender, and Teacher Education This report was made possible, in part, by the generous contribution of Margaret Strauss Kramer. Special thanks to the Northern Palm Beach Branch of AAUW. Published by the American Association of University Women Educational Foundation 1111 Sixteenth Street N.W. Washington, DC 20036 202/728-7602 Fax: 202/872-1425 TDD: 202/785-7777 [email protected] www.aauw.org Copyright 2000 American Association of University Women Educational Foundation All rights reserved Printed in the United States First printing: April 2000 Cover design by Sabrina Meyers Layout by Vann Dailly Library of Congress Card Number: 00-100922 ISBN 1879922231 Cover photos: The Concord Consortium; Jeff Leaf; Judy Rolfe TABLE OF CONTENTS Foreword............................................................................................................v Executive Summary............................................................................................vii INTRODUCTION FROM THE COMMISSION: Dual Visions ...................................................................................................... 1 Chapter 1: “WE CAN, BUT I DON’T WANT TO”: Girls’ Perspectives on the Computer Culture.....................................................
    [Show full text]
  • System Construction
    System Construction Autumn Semester 2016 ETH Zürich Felix Friedrich 1 Goals . Competence in building custom system software from scratch . Understanding of „how it really works“ behind the scenes across all levels . Knowledge of the approach of fully managed lean systems A lot of this course is about detail. A lot of this course is about bare metal programming. 2 Course Concept . Discussing elaborated case studies . In theory (lectures) . and practice (hands-on lab) . Learning by example vs. presenting topics 3 Prerequisite . Knowledge corresponding to lectures Systems Programming and/or Operating Systems . Do you know what a stack-frame is? . Do you know how an interrupt works? . Do you know the concept of virtual memory? . Good reference for recapitulation: Computer Systems – A Programmer's Perspective 4 Links . SVN repository https://svn.inf.ethz.ch/svn/lecturers/vorlesungen/trunk/syscon/2016/shared . Links on the course homepage http://lec.inf.ethz.ch/syscon/2016 5 Background: Co-Design @ ETH Languages (Pascal Family) +MathOberon Active Modula Oberon ActiveOberon Cells Oberon07 Zonnon Operating / Runtime Systems Medos Oberon Aos A2 SoC HeliOs Minos LockFree Kernel Hardware x86 / IA64/ ARM TRM Lilith Ceres Emulations on (FPGA) Unix / Linux RISC (FPGA) 1980 1990 2000 2010 6 Course Overview Part1: Contemporary Hardware Case Study 1. Minos: Embedded System . Safety-critical and fault-tolerant monitoring system . Originally invented for autopilot system for helicopters . Topics: ARM Architecture, Cross-Development, Object Files and Module Loading, Basic OS Core Tasks (IRQs, MMUs etc.), Minimal Single-Core OS: Scheduling, Device Drivers, Compilation and Runtime Support. With hands-on lab on Raspberry Pi (2) 7 Course Overview Part1: Contemporary Hardware Case Study 2.
    [Show full text]
  • The Extent of Empirical Evidence That Could Inform Evidence-Based Design of Programming Languages
    JYVÄSKYLÄ LICENTIATE THESES IN COMPUTING 18 Antti-Juhani Kaijanaho The Extent of Empirical Evidence that Could Inform Evidence-Based Design of Programming Languages A Systematic Mapping Study JYVÄSKYLÄ LICENTIATE THESES IN COMPUTING 18 Antti-Juhani Kaijanaho The Extent of Empirical Evidence that Could Inform Evidence-Based Design of Programming Languages A Systematic Mapping Study UNIVERSITY OF JYVÄSKYLÄ JYVÄSKYLÄ 2014 The Extent of Empirical Evidence that Could Inform Evidence-Based Design of Programming Languages A Systematic Mapping Study JYVÄSKYLÄ LICENTIATE THESES IN COMPUTING 18 Antti-Juhani Kaijanaho The Extent of Empirical Evidence that Could Inform Evidence-Based Design of Programming Languages A Systematic Mapping Study UNIVERSITY OF JYVÄSKYLÄ JYVÄSKYLÄ 2014 Editor Timo Männikkö Department of Mathematical Information Technology, University of Jyväskylä URN:ISBN:978-951-39-5791-9 ISBN 978-951-39-5791-9 (PDF) ISBN 978-951-39-5790-2 (nid.) ISSN 1795-9713 Copyright © 2014, by University of Jyväskylä Jyväskylä University Printing House, Jyväskylä 2014 GLENDOWER. I can call spirits from the vasty deep. HOTSPUR. Why, so can I, or so can any man; But will they come when you do call for them? — William Shakespeare’s Henry IV Part 1 (III.1) ABSTRACT Kaijanaho, Antti-Juhani The extent of empirical evidence that could inform evidence-based design of pro- gramming languages. A systematic mapping study. Jyväskylä: University of Jyväskylä, 2014, 243 p. (Jyväskylä Licentiate Theses in Computing, ISSN 1795-9713; 18) ISBN 978-951-39-5790-2 (nid.) ISBN 978-951-39-5791-9 (PDF) Finnish summary Background: Programming language design is not usually informed by empirical studies.
    [Show full text]