DOCSLIB.ORG

First-Class Effect Reflection for Effect-Guided Programming Yuheng Long Iowa State University

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
First-Class Effect Reflection for Effect-Guided Programming Yuheng Long Iowa State University Computer Science Conference Presentations, Computer Science Posters and Proceedings 10-20-2016 First-class effect reflection for effect-guided programming Yuheng Long Iowa State University Yu David Liu State University of New York at Binghamton Hridesh Rajan Iowa State University, [email protected] Follow this and additional works at: http://lib.dr.iastate.edu/cs_conf Part of the Software Engineering Commons Recommended Citation Long, Yuheng; Liu, Yu David; and Rajan, Hridesh, "First-class effect reflection for effect-guided programming" (2016). Computer Science Conference Presentations, Posters and Proceedings. 16. http://lib.dr.iastate.edu/cs_conf/16 This Conference Proceeding is brought to you for free and open access by the Computer Science at Iowa State University Digital Repository. It has been accepted for inclusion in Computer Science Conference Presentations, Posters and Proceedings by an authorized administrator of Iowa State University Digital Repository. For more information, please contact [email protected]. First-class effect reflection for effect-guided programming Abstract This paper introduces a novel type-and-effect calculus, first-class effects, where the computational effect of an expression can be programmatically reflected, passed around as values, and analyzed at run time. A broad range of designs “hard-coded” in existing effect-guided analyses — from thread scheduling, version-consistent software updating, to data zeroing — can be naturally supported through the programming abstractions. The core technical development is a type system with a number of features, including a hybrid type system that integrates static and dynamic effect analyses, a refinement type system to verify application-specific effect management properties, a double-bounded type system that computes both over-approximation of effects and their under-approximation. We introduce and establish a notion of soundness called trace consistency, defined in terms of how the effect and trace correspond. The property sheds foundational insight on “good” first-class effect programming. Disciplines Computer Sciences | Software Engineering Comments This article is published as Long, Yuheng, Yu David Liu, and Hridesh Rajan. "First-class effect reflection for effect-guided programming." In Proceedings of the 2016 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications, pp. 820-837. ACM, 2016. doi: 10.1145/3022671.2984037. Posted with permission. Rights © ACM, 2016. This is the author's version of the work. It is posted here by permission of ACM for your personal use. Not for redistribution. The definitive version was published in Proceedings of the 2016 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications, 2016. https://doi.org/10.1145/2983990.2984037 This conference proceeding is available at Iowa State University Digital Repository: http://lib.dr.iastate.edu/cs_conf/16 Preprint First-Class Effect Reflection for Effect-Guided Programming Yuheng Longα, Yu David Liuβ, and Hridesh Rajanγ α,γ Iowa State University, βSUNY Binghamton α,γ fcsgzlong,[email protected] β[email protected] Abstract comes part of the program itself. The resulting calculus, λfe, This paper introduces a novel type-and-effect calculus, first- is endowed with powerful programming abstractions: class effects, where the computational effect of an expression [EFFECT REFLECTION] Programmers can query the ef- can be programmatically reflected, passed around as values, fect of any expression e through a λfe primitive, query e. and analyzed at run time. A broad range of designs “hard- The result is a first-class value we call effect closure, which coded” in existing effect-guided analyses — from thread contains the queried expression e and e’s effects, in the scheduling, version-consistent software updating, to data ze- form of memory region accesses. For convenience, we call roing — can be naturally supported through the program- e the passenger expression of the closure. ming abstractions. The core technical development is a type [EFFECT INSPECTION] The memory access details repre- system with a number of features, including a hybrid type sented by an effect closure can be analyzed through a λ ef- system that integrates static and dynamic effect analyses, fe fect pattern matching expression, enabling effect-based dis- a refinement type system to verify application-specific ef- patch to naturally support effect-guided programming. fect management properties, a double-bounded type system that computes both over-approximation of effects and their [EFFECT REALIZATION] The dual of effect reflection is under-approximation. We introduce and establish a notion of effect realization: the realize x expression evaluates the soundness called trace consistency, defined in terms of how passenger expression of the effect closure x. the effect and trace correspond. The property sheds founda- Foundationally, effect reflection and effect realization are tional insight on “good” first-class effect programming. the introduction and elimination of first-class effects, in the form of effect closures. As effect closures may cross modu- 1. Introduction larity boundaries, it can be viewed as “effect-carrying code.” The direct benefit of λfe is its support in flexible effect- Type-and-effect systems, either purely static [36, 42, 52], dy- guided programming. For example, thread scheduling in namic [4, 29, 46] or hybrid [2, 34], have proven to be useful concurrent programs is an active and prolific area of re- for program construction, reasoning, and verification. In ex- search [29, 44, 46]. With λfe, programmers can flexibly isting approaches, the logic of accessing effects and making develop a variety of thread management strategies through decisions over them is defined by the language designer, and principled λfe programming. We will further demonstrate a supported by the compiler or the runtime system. The end- broad range of applications beyond thread scheduling in §8 user programmer is generally a consumer of the “hardcoded” and §B. Overall, a variety of meta-level designs currently logic for effect management. “hidden” behind the compiler and language runtime are now Our work is motivated by two fundamental questions. in the hands of programmers. First, are there benefits of empowering programmers with With great power comes great responsibility1. The grand application-specific effect management? Second, is there a challenge of designing an expressive and flexible program- principled design for the effect management, so that pro- ming model lies in principled and precise reasoning. The grammers are endowed with powerful abstractions while in core technical development of λfe is a type system with the meantime provided with strong correctness guarantees? a number of features. First, effect reflection is designed first-class effects In this paper, we develop , a novel type- through dynamic typing, resulting in a hybrid type-and- and-effect system where the effects of program expressions effect system [2, 34] that employs run-time information are available as first-class values to programmers. The life- to improve precision. Second, λfe provides static guaran- cycle of effect management over program expressions be- tees to application-specific effect management properties through refinement types, promoting “correct-by-design” effect-guided programming. Third, λfe computes not only [Copyright notice will appear here once ’preprint’ option is removed.] 1 Marvel’s Spiderman 2nd submission to OOPSLA’16 1 2016/7/25 - - - - - - - - - - - - - - - - - - - Server - - - - - - - - - - - - - - - - - - - - notation meaning 1 let buf = refr 0 in query e effect reflection 2 let scheduler = λ x1:exact, x2:exact. effcase x : T where P ) e predicated effect dispatch 3 let (p, c) = effcase x1: realize e effect realization 4 | EC(l ∼ u) where wrr <<: l =>(x1, x2) x ∼ y lower bound effect x & upper bound y 5 | default =>(x2, x1) in EC(x ∼ y) effect closure type 6 {wrr <<: c |−> wrr <<: p} realize p; realize c x <<:y effect x is a subset of y - - - - - - - - - - - - - - - - - - - - Client - - - - - - - - - - - - - - - - - - - - |−> logical implication 7 let reader = (query !buf) in {P }e refinement type 8 let writer = (query buf := 1) in wrr write effect to region r 9 scheduler reader writer exact lower and upper bounds are equal Figure 1. A Producer-First Scheduler (The new notations introduced by first-class effects are explained on the right.) the over-approximation of effects, the may-effect, but also tively, created by the Client side of the program (lines 7-9). their under-approximation, the must-effect. The duality uni- According to a well-known scheduling strategy for multi- fies the common theme of permission [24] vs. obligation [7] threaded programs [33], data producer should be scheduled in effect reasoning. Fourth, we establish a stronger notion before its consumer. For this program, the programmer may of soundness called trace consistency, defined in terms of wish writer to be scheduled before the reader, regard- how the effect and the trace (the “post-execution effect”) less of whether scheduler reader writer appears correspond. To maintain trace consistency, we introduce a on line 9, or scheduler writer reader. notion of polarity to predicates defined over effects, provid- In λfe, the query expression can retrieve the effects of ing a general solution to a long-standing problem in type- the tasks, on lines 7-8. The resulting
Load more

Recommended publications
  • Cross-Platform Language Design
    Cross-Platform Language Design THIS IS A TEMPORARY TITLE PAGE It will be replaced for the final print by a version provided by the service academique. Thèse n. 1234 2011 présentée le 11 Juin 2018 à la Faculté Informatique et Communications Laboratoire de Méthodes de Programmation 1 programme doctoral en Informatique et Communications École Polytechnique Fédérale de Lausanne pour l’obtention du grade de Docteur ès Sciences par Sébastien Doeraene acceptée sur proposition du jury: Prof James Larus, président du jury Prof Martin Odersky, directeur de thèse Prof Edouard Bugnion, rapporteur Dr Andreas Rossberg, rapporteur Prof Peter Van Roy, rapporteur Lausanne, EPFL, 2018 It is better to repent a sin than regret the loss of a pleasure. — Oscar Wilde Acknowledgments Although there is only one name written in a large font on the front page, there are many people without which this thesis would never have happened, or would not have been quite the same. Five years is a long time, during which I had the privilege to work, discuss, sing, learn and have fun with many people. I am afraid to make a list, for I am sure I will forget some. Nevertheless, I will try my best. First, I would like to thank my advisor, Martin Odersky, for giving me the opportunity to fulfill a dream, that of being part of the design and development team of my favorite programming language. Many thanks for letting me explore the design of Scala.js in my own way, while at the same time always being there when I needed him.
    [Show full text]
  • Blossom: a Language Built to Grow
    Macalester College DigitalCommons@Macalester College Mathematics, Statistics, and Computer Science Honors Projects Mathematics, Statistics, and Computer Science 4-26-2016 Blossom: A Language Built to Grow Jeffrey Lyman Macalester College Follow this and additional works at: https://digitalcommons.macalester.edu/mathcs_honors Part of the Computer Sciences Commons, Mathematics Commons, and the Statistics and Probability Commons Recommended Citation Lyman, Jeffrey, "Blossom: A Language Built to Grow" (2016). Mathematics, Statistics, and Computer Science Honors Projects. 45. https://digitalcommons.macalester.edu/mathcs_honors/45 This Honors Project - Open Access is brought to you for free and open access by the Mathematics, Statistics, and Computer Science at DigitalCommons@Macalester College. It has been accepted for inclusion in Mathematics, Statistics, and Computer Science Honors Projects by an authorized administrator of DigitalCommons@Macalester College. For more information, please contact [email protected]. In Memory of Daniel Schanus Macalester College Department of Mathematics, Statistics, and Computer Science Blossom A Language Built to Grow Jeffrey Lyman April 26, 2016 Advisor Libby Shoop Readers Paul Cantrell, Brett Jackson, Libby Shoop Contents 1 Introduction 4 1.1 Blossom . .4 2 Theoretic Basis 6 2.1 The Potential of Types . .6 2.2 Type basics . .6 2.3 Subtyping . .7 2.4 Duck Typing . .8 2.5 Hindley Milner Typing . .9 2.6 Typeclasses . 10 2.7 Type Level Operators . 11 2.8 Dependent types . 11 2.9 Hoare Types . 12 2.10 Success Types . 13 2.11 Gradual Typing . 14 2.12 Synthesis . 14 3 Language Description 16 3.1 Design goals . 16 3.2 Type System . 17 3.3 Hello World .
    [Show full text]
  • Distributive Disjoint Polymorphism for Compositional Programming
    Distributive Disjoint Polymorphism for Compositional Programming Xuan Bi1, Ningning Xie1, Bruno C. d. S. Oliveira1, and Tom Schrijvers2 1 The University of Hong Kong, Hong Kong, China fxbi,nnxie,[email protected] 2 KU Leuven, Leuven, Belgium [email protected] Abstract. Popular programming techniques such as shallow embeddings of Domain Specific Languages (DSLs), finally tagless or object algebras are built on the principle of compositionality. However, existing program- ming languages only support simple compositional designs well, and have limited support for more sophisticated ones. + This paper presents the Fi calculus, which supports highly modular and compositional designs that improve on existing techniques. These im- provements are due to the combination of three features: disjoint inter- section types with a merge operator; parametric (disjoint) polymorphism; and BCD-style distributive subtyping. The main technical challenge is + Fi 's proof of coherence. A naive adaptation of ideas used in System F's + parametricity to canonicity (the logical relation used by Fi to prove co- herence) results in an ill-founded logical relation. To solve the problem our canonicity relation employs a different technique based on immediate substitutions and a restriction to predicative instantiations. Besides co- herence, we show several other important meta-theoretical results, such as type-safety, sound and complete algorithmic subtyping, and decidabil- ity of the type system. Remarkably, unlike F<:'s bounded polymorphism, + disjoint polymorphism in Fi supports decidable type-checking. 1 Introduction Compositionality is a desirable property in programming designs. Broadly de- fined, it is the principle that a system should be built by composing smaller sub- systems.
    [Show full text]
  • Bs-6026-0512E.Pdf
    THERMAL PRINTER SPEC BAS - 6026 1. Basic Features 1.) Type : PANEL Mounting or DESK top type 2.) Printing Type : THERMAL PRINT 3.) Printing Speed : 25mm / SEC 4.) Printing Column : 24 COLUMNS 5.) FONT : 24 X 24 DOT MATRIX 6.) Character : English, Numeric & Others 7.) Paper width : 57.5mm ± 0.5mm 8.) Character Size : 5times enlarge possible 9.) INTERFACE : CENTRONICS PARALLEL I/F SERIAL I/F 10.) DIMENSION : 122(W) X 90(D) X 129(H) 11.) Operating Temperature range : 0℃ - 50℃ 12.) Storage Temperature range : -20℃ - 70℃ 13.) Outlet Power : DC 12V ( 1.6 A )/ DC 5V ( 2.5 A) 14.) Application : Indicator, Scale, Factory automation equipments and any other data recording, etc.,, - 1 - 1) SERIAL INTERFACE SPECIFICATION * CONNECTOR : 25 P FEMALE PRINTER : 4 P CONNECTOR 3 ( TXD ) ----------------------- 2 ( RXD ) 2 2 ( RXD ) ----------------------- 1 ( TXD ) 3 7 ( GND ) ----------------------- 4 ( GND ) 5 DIP SWITCH BUAD RATE 1 2 3 ON ON ON 150 OFF ON ON 300 ON OFF ON 600 OFF OFF ON 1200 ON ON OFF 2400 OFF ON OFF 4800 ON OFF OFF 9600 OFF OFF OFF 19200 2) BAUD RATE SELECTION * PROTOCOL : XON / XOFF Type DIP SWITCH (4) ON : Combination type * DATA BIT : 8 BIT STOP BIT : 1 STOP BIT OFF: Complete type PARITY CHECK : NO PARITY * DEFAULT VALUE : BAUD RATE (9600 BPS) - 2 - PRINTING COMMAND * Explanation Command is composed of One Byte Control code and ESC code. This arrangement is started with ESC code which is connected by character & numeric code The control code in Printer does not be still in standardization (ESC Control Code). All printers have a code structure by themselves.
    [Show full text]
  • Cormac Flanagan Fritz Henglein Nate Nystrom Gavin Bierman Jan Vitek Gilad Bracha Philip Wadler Jeff Foster Tobias Wrigstad Peter Thiemann Sam Tobin-Hochstadt
    PC: Amal Ahmed SC: Matthias Felleisen Robby Findler (chair) Cormac Flanagan Fritz Henglein Nate Nystrom Gavin Bierman Jan Vitek Gilad Bracha Philip Wadler Jeff Foster Tobias Wrigstad Peter Thiemann Sam Tobin-Hochstadt Organizers: Tobias Wrigstad and Jan Vitek Schedule Schedule . 3 8:30 am – 10:30 am: Invited Talk: Scripting in a Concurrent World . 5 Language with a Pluggable Type System and Optional Runtime Monitoring of Type Errors . 7 Position Paper: Dynamically Inferred Types for Dynamic Languages . 19 10:30 am – 11:00 am: Coffee break 11:00 am – 12:30 pm: Gradual Information Flow Typing . 21 Type Inference with Run-time Logs . 33 The Ciao Approach to the Dynamic vs. Static Language Dilemma . 47 12:30 am – 2:00 pm: Lunch Invited Talk: Scripting in a Concurrent World John Field IBM Research As scripting languages are used to build increasingly complex systems, they must even- tually confront concurrency. Concurrency typically arises from two distinct needs: han- dling “naturally” concurrent external (human- or software-generated) events, and en- hancing application performance. Concurrent applications are difficult to program in general; these difficulties are multiplied in a distributed setting, where partial failures are common and where resources cannot be centrally managed. The distributed sys- tems community has made enormous progress over the past few decades designing specialized systems that scale to handle millions of users and petabytes of data. How- ever, combining individual systems into composite applications that are scalable—not to mention reliable, secure, and easy to develop maintain—remains an enormous chal- lenge. This is where programming languages should be able to help: good languages are designed to facilitate composing large applications from smaller components and for reasoning about the behavior of applications modularly.
    [Show full text]
  • Download the JSR-000202 Java Class File Specification
    CHAPTER 4 The class File Format THIS chapter describes the Java virtual machine class file format. Each class file contains the definition of a single class or interface. Although a class or interface need not have an external representation literally contained in a file (for instance, because the class is generated by a class loader), we will colloquially refer to any valid representation of a class or interface as being in the class file format. A class file consists of a stream of 8-bit bytes. All 16-bit, 32-bit, and 64-bit quantities are constructed by reading in two, four, and eight consecutive 8-bit bytes, respectively. Multibyte data items are always stored in big-endian order, where the high bytes come first. In the Java and Java 2 platforms, this format is supported by interfaces java.io.DataInput and java.io.DataOutput and classes such as java.io.DataInputStream and java.io.DataOutputStream. This chapter defines its own set of data types representing class file data: The types u1, u2, and u4 represent an unsigned one-, two-, or four-byte quantity, respectively. In the Java and Java 2 platforms, these types may be read by methods such as readUnsignedByte, readUnsignedShort, and readInt of the interface java.io.DataInput. This chapter presents the class file format using pseudostructures written in a C- like structure notation. To avoid confusion with the fields of classes and class instances, etc., the contents of the structures describing the class file format are referred to as items. Successive items are stored in the class file sequentially, without padding or alignment.
    [Show full text]
  • Type Systems
    A Simple Language <t> ::= true | false | if <t> then <t> else <t> | 0 | succ <t> | pred <t> | iszero <t> Type Systems . Simple untyped expressions . Natural numbers encoded as succ … succ 0 . E.g. succ succ succ 0 represents 3 . Pierce Ch. 3, 8, 11, 15 . term: a string from this language . To improve readability, we will sometime write parentheses: e.g. iszero (pred (succ 0)) CSE 6341 1 CSE 6341 2 Semantics (informally) Equivalent Ways to Define the Syntax . A term evaluates to a value . Inductive definition: the smallest set S s.t. Values are terms themselves . { true, false, 0 } S . Boolean constants: true and false . if t1S, then {succ t1, pred t1, iszero t1 } S . Natural numbers: 0, succ 0, succ (succ 0), … . if t1 , t2 , t3 S, then if t1 then t2 else t3 S . Given a program (i.e., a term), the result . Same thing, written as inference rules of “running” this program is a boolean trueS falseS 0S axioms (no premises) value or a natural number t1S t1S t1St2St3S . if false then 0 else succ 0 succ 0 succ t1 S pred t1 S if t1 then t2 else t3 S . iszero (pred (succ 0)) true t S If we have established the premises . Problematic: succ true or if 0 then 0 else 0 1 (above the line), we can derive the iszero t1 S CSE 6341 3 conclusion (below the line) 4 Why Does This Matter? Inductive Proofs . Key property: for any tS, one of three things . Structural induction – used very often must be true: .
    [Show full text]
  • Semantics and Types for Objects with First-Class Member Names
    Semantics and Types for Objects with First-Class Member Names Joe Gibbs Politz Arjun Guha Shriram Krishnamurthi Brown University Cornell University Brown University [email protected] [email protected] [email protected] Abstract In summary, we make the following contributions: Objects in many programming languages are indexed by first-class 1. extract the principle of first-class member names from existing ob strings, not just first-order names. We define λS (“lambda sob”), languages; an object calculus for such languages, and prove its untyped sound- ob 2. provide a dynamic semantics that distills this feature; ness using Coq. We then develop a type system for λS that is built around string pattern types, which describe (possibly infi- 3. identify key problems for type-checking objects in programs nite) collections of members. We define subtyping over such types, that employ first-class member names; extend them to handle inheritance, and discuss the relationship 4. extend traditional record typing with sound types to describe between the two. We enrich the type system to recognize tests objects that use first-class member names; and, for whether members are present, and briefly discuss exposed in- heritance chains. The resulting language permits the ascription 5. briefly discuss a prototype implementation. of meaningful types to programs that exploit first-class member We build up our type system incrementally. All elided proofs and names for object-relational mapping, sandboxing, dictionaries, etc. definitions are available online: We prove that well-typed programs never signal member-not-found errors, even when they use reflection and first-class member names.
    [Show full text]
  • Advanced Logical Type Systems for Untyped Languages
    ADVANCED LOGICAL TYPE SYSTEMS FOR UNTYPED LANGUAGES Andrew M. Kent Submitted to the faculty of the University Graduate School in partial fulfillment of the requirements for the degree Doctor of Philosophy in the Department of Computer Science, Indiana University October 2019 Accepted by the Graduate Faculty, Indiana University, in partial fulfillment of the requirements for the degree of Doctor of Philosophy. Doctoral Committee Sam Tobin-Hochstadt, Ph.D. Jeremy Siek, Ph.D. Ryan Newton, Ph.D. Larry Moss, Ph.D. Date of Defense: 9/6/2019 ii Copyright © 2019 Andrew M. Kent iii To Caroline, for both putting up with all of this and helping me stay sane throughout. Words could never fully capture how grateful I am to have her in my life. iv ACKNOWLEDGEMENTS None of this would have been possible without the community of academics and friends I was lucky enough to have been surrounded by during these past years. From patiently helping me understand concepts to listening to me stumble through descriptions of half- baked ideas, I cannot thank enough my advisor and the professors and peers that donated a portion of their time to help me along this journey. v Andrew M. Kent ADVANCED LOGICAL TYPE SYSTEMS FOR UNTYPED LANGUAGES Type systems with occurrence typing—the ability to refine the type of terms in a control flow sensitive way—now exist for nearly every untyped programming language that has gained popularity. While these systems have been successful in type checking many prevalent idioms, most have focused on relatively simple verification goals and coarse interface specifications.
    [Show full text]
  • CS 6110 S18 Lecture 23 Subtyping 1 Introduction 2 Basic Subtyping Rules
    CS 6110 S18 Lecture 23 Subtyping 1 Introduction In this lecture, we attempt to extend the typed λ-calculus to support objects. In particular, we explore the concept of subtyping in detail, which is one of the key features of object-oriented (OO) languages. Subtyping was first introduced in Simula, the first object-oriented programming language. Its inventors Ole-Johan Dahl and Kristen Nygaard later went on to win the Turing award for their contribution to the field of object-oriented programming. Simula introduced a number of innovative features that have become the mainstay of modern OO languages including objects, subtyping and inheritance. The concept of subtyping is closely tied to inheritance and polymorphism and offers a formal way of studying them. It is best illustrated by means of an example. This is an example of a hierarchy that describes a Person Student Staff Grad Undergrad TA RA Figure 1: A Subtype Hierarchy subtype relationship between different types. In this case, the types Student and Staff are both subtypes of Person. Alternatively, one can say that Person is a supertype of Student and Staff. Similarly, TA is a subtype of the Student and Person types, and so on. The subtype relationship is normally a preorder (reflexive and transitive) on types. A subtype relationship can also be viewed in terms of subsets. If σ is a subtype of τ, then all elements of type σ are automatically elements of type τ. The ≤ symbol is typically used to denote the subtype relationship. Thus, Staff ≤ Person, RA ≤ Student, etc. Sometimes the symbol <: is used, but we will stick with ≤.
    [Show full text]
  • The Java® Virtual Machine Specification Java SE 9 Edition
    The Java® Virtual Machine Specification Java SE 9 Edition Tim Lindholm Frank Yellin Gilad Bracha Alex Buckley 2017-08-07 Specification: JSR-379 Java® SE 9 Release Contents ("Specification") Version: 9 Status: Final Release Release: September 2017 Copyright © 1997, 2017, Oracle America, Inc. and/or its affiliates. 500 Oracle Parkway, Redwood City, California 94065, U.S.A. All rights reserved. Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners. The Specification provided herein is provided to you only under the Limited License Grant included herein as Appendix A. Please see Appendix A, Limited License Grant. Table of Contents 1 Introduction 1 1.1 A Bit of History 1 1.2 The Java Virtual Machine 2 1.3 Organization of the Specification 3 1.4 Notation 4 1.5 Feedback 4 2 The Structure of the Java Virtual Machine 5 2.1 The class File Format 5 2.2 Data Types 6 2.3 Primitive Types and Values 6 2.3.1 Integral Types and Values 7 2.3.2 Floating-Point Types, Value Sets, and Values 8 2.3.3 The returnAddress Type and Values 10 2.3.4 The boolean Type 10 2.4 Reference Types and Values 11 2.5 Run-Time Data Areas 11 2.5.1 The pc Register 12 2.5.2 Java Virtual Machine Stacks 12 2.5.3 Heap 13 2.5.4 Method Area 13 2.5.5 Run-Time Constant Pool 14 2.5.6 Native Method Stacks 14 2.6 Frames 15 2.6.1 Local Variables 16 2.6.2 Operand Stacks 17 2.6.3 Dynamic Linking 18 2.6.4 Normal Method Invocation Completion 18 2.6.5 Abrupt Method Invocation Completion 18 2.7 Representation of Objects
    [Show full text]
  • Schema Transformation Processors for Federated Objectbases
    PublishedinProc rd Intl Symp on Database Systems for Advanced Applications DASFAA Daejon Korea Apr SCHEMA TRANSFORMATION PROCESSORS FOR FEDERATED OBJECTBASES Markus Tresch Marc H Scholl Department of Computer Science Databases and Information Systems University of Ulm DW Ulm Germany ftreschschollgin formatik uni ul mde ABSTRACT In contrast to three schema levelsincentralized ob jectbases a reference architecture for fed erated ob jectbase systems prop oses velevels of schemata This pap er investigates the funda mental mechanisms to b e provided by an ob ject mo del to realize the pro cessors transforming between these levels The rst pro cess is schema extension which gives the p ossibil itytodene views The second pro cess is schema ltering that allows to dene subschemata The third one schema composition brings together several so far unrelated ob jectbases It is shown how comp osition and extension are used for stepwise b ottomup integration of existing ob jectbases into a federation and how extension and ltering supp ort authorization on dierentlevels in a federation A p owerful View denition mechanism and the p ossibil ity to dene subschemas ie parts of a schema are the key mechanisms used in these pro cesses elevel schema ar Keywords Ob jectoriented database systems federated ob jectbases v chitecture ob ject algebra ob ject views INTRODUCTION Federated ob jectbase FOB systems as a collection of co op erating but autonomous lo cal ob ject bases LOBs are getting increasing attention To clarify the various issues a rst reference
    [Show full text]