Adding a Module System to Java
|
|
|
- Eustacia Poole
- 5 years ago
- Views:
Transcription
1 Adding a Module System to Java Rok Strniša Computer Laboratory, University of Cambridge Rok.Strnisa@cl.cam.ac.uk URL: May 8, The British Computer Society Joint work with Peter Sewell and Matthew Parkinson
2 1 What is a module system? 2 Why Java needs a module system 3 Current solutions 4 The Java Module System (JAM) 5 improved JAM (ijam) 6 Formalizations & proofs 7 Conclusion
3 What is a module system?
4 Definition module system A system in a programming language, which allows structuring programs of that language in modules.
5 Definition module system A system in a programming language, which allows structuring programs of that language in modules. module A piece of software that should implement a specific function in a largely independent manner.
6 Desirable properties abstraction hiding the implementation behind an interface.
7 Desirable properties abstraction hiding the implementation behind an interface. composition combining many modules.
8 Desirable properties abstraction hiding the implementation behind an interface. composition combining many modules. static reuse using module s code at many different places.
9 Desirable properties abstraction hiding the implementation behind an interface. composition combining many modules. static reuse using module s code at many different places. dynamic reuse sharing module s types and data.
10 Desirable properties abstraction hiding the implementation behind an interface. composition combining many modules. static reuse using module s code at many different places. dynamic reuse sharing module s types and data. separate compilation ability to compile a module in isolation.
11 Quick look at the ML module system Abstraction (abstract types, module types) module Foo = struct ( implementation ) type t = int let v = 5 end let x = 42 + Foo.v ( OK ) module type View = sig ( interface ) type t val v : t end module Bar : View = Foo ( abstraction ) let y = 42 + Bar.v ( COMPILE ERROR )
12 Quick look at the ML module system Composition Can be structured. Functors = functions over modules. Static reuse On the scale of each file (module). Dynamic reuse Not supported. Separate compilation Each file (module) compiled separately.
13 Why Java needs a module system
14 Java s current modularity constructs class A low-level software unit. Gives abstraction with private members, limited composition with inheritance and inner classes, and low-level static reuse.
15 Java s current modularity constructs class A low-level software unit. Gives abstraction with private members, limited composition with inheritance and inner classes, and low-level static reuse. object An instance of a class. Provides dynamic reuse for classes.
16 Java s current modularity constructs class A low-level software unit. Gives abstraction with private members, limited composition with inheritance and inner classes, and low-level static reuse. object An instance of a class. Provides dynamic reuse for classes. interface A more explicit form of the abstraction provided by classes.
17 Java s current modularity constructs class A low-level software unit. Gives abstraction with private members, limited composition with inheritance and inner classes, and low-level static reuse. object An instance of a class. Provides dynamic reuse for classes. interface A more explicit form of the abstraction provided by classes. package Part of class namespace. Serves as barrier for default access restriction, and so enables package-wide abstraction for class members.
18 Java s current modularity constructs class A low-level software unit. Gives abstraction with private members, limited composition with inheritance and inner classes, and low-level static reuse. object An instance of a class. Provides dynamic reuse for classes. interface A more explicit form of the abstraction provided by classes. package Part of class namespace. Serves as barrier for default access restriction, and so enables package-wide abstraction for class members. JAR file A group of classes/interfaces. Provides only high-level static reuse, nothing else.
19 An example XMLParser Key requires XSLT ServletEngine Cache WebCalendar Servlet is a small program that runs on a web-server.
20 An example XMLParser xml.parser package Key requires XSLT xslt ServletEngine engine Cache engine.cache WebCalendar webcalendar Servlet is a small program that runs on a web-server.
21 An example No high-level abstraction XMLParser xml.parser package Key requires sees XSLT xslt ServletEngine engine Cache engine.cache WebCalendar webcalendar Servlet is a small program that runs on a web-server.
22 An example No high-level abstraction XMLParser xml.parser package Key requires sees XSLT xslt ServletEngine + Cache engine WebCalendar webcalendar Servlet is a small program that runs on a web-server.
23 An example No high-level abstraction DLL/JAR Hell Key XMLParser (version 3.0) xml.parser XMLParser (version 2.0) xml.parser package requires XSLT xslt ServletEngine engine Cache engine.cache WebCalendar webcalendar Servlet is a small program that runs on a web-server.
24 Java s unsolved software engineering problems No high-level software units Have clear boundaries for high-level logical software units.
25 Java s unsolved software engineering problems No high-level software units Have clear boundaries for high-level logical software units. No high-level abstraction Allow different interfaces for different software units.
26 Java s unsolved software engineering problems No high-level software units Have clear boundaries for high-level logical software units. No high-level abstraction Allow different interfaces for different software units. DLL/JAR hell Allow software units of different versions to co-exist.
27 Java s unsolved software engineering problems No high-level software units Have clear boundaries for high-level logical software units. No high-level abstraction Allow different interfaces for different software units. DLL/JAR hell Allow software units of different versions to co-exist. No separate compilation Allow software units to be compiled in isolation.
28 Current solutions
29 Custom classloaders Classloaders are Java s mechanism for loading code (at runtime). How to use: 1 Extend Classloader class;
30 Custom classloaders Classloaders are Java s mechanism for loading code (at runtime). How to use: 1 Extend Classloader class; 2 implement loadclass (or findclass);
31 Custom classloaders Classloaders are Java s mechanism for loading code (at runtime). How to use: 1 Extend Classloader class; 2 implement loadclass (or findclass); 3 make an instance of the new classloader; and
32 Custom classloaders Classloaders are Java s mechanism for loading code (at runtime). How to use: 1 Extend Classloader class; 2 implement loadclass (or findclass); 3 make an instance of the new classloader; and 4 use it to resolve a class reference.
33 Custom classloaders Classloaders are Java s mechanism for loading code (at runtime). How to use: 1 Extend Classloader class; 2 implement loadclass (or findclass); 3 make an instance of the new classloader; and 4 use it to resolve a class reference. If loadclass is implemented, then the parent classloader is consulted first. Overriding findclass allow one to change this behavior.
34 Custom classloaders Classloaders are Java s mechanism for loading code (at runtime). How to use: 1 Extend Classloader class; 2 implement loadclass (or findclass); 3 make an instance of the new classloader; and 4 use it to resolve a class reference. If loadclass is implemented, then the parent classloader is consulted first. Overriding findclass allow one to change this behavior. Each classloader has its own namespace multiple versions!
35 Custom classloaders Classloaders are Java s mechanism for loading code (at runtime). How to use: 1 Extend Classloader class; 2 implement loadclass (or findclass); 3 make an instance of the new classloader; and 4 use it to resolve a class reference. If loadclass is implemented, then the parent classloader is consulted first. Overriding findclass allow one to change this behavior. Each classloader has its own namespace multiple versions! Hard to understand/use/debug. Each company makes their own.
36 Design patterns Factory Pattern is a good example: Uses interfaces & reflection to find/generate classes;
37 Design patterns Factory Pattern is a good example: Uses interfaces & reflection to find/generate classes; gives some low-level abstraction, and dynamic reuse.
38 Design patterns Factory Pattern is a good example: Uses interfaces & reflection to find/generate classes; gives some low-level abstraction, and dynamic reuse. Not very type-safe. Ad hoc.
39 Frameworks OSGi is currently the most widely used framework: Service-oriented: Modules (bundles) provide services (access to a module s capability). Services can be registered and discovered through the service registry.
40 Frameworks OSGi is currently the most widely used framework: Service-oriented: Modules (bundles) provide services (access to a module s capability). Services can be registered and discovered through the service registry. very customizable.
41 Frameworks OSGi is currently the most widely used framework: Service-oriented: Modules (bundles) provide services (access to a module s capability). Services can be registered and discovered through the service registry. very customizable. Not in language (not enforced). Not enough is enforced, e.g. no high-level abstraction or dynamic reuse.
42 The Java Module System (JAM)
43 Sun & friends are addressing the problem The Java Module System (JAM) is in development. JMS already stands for Java Messaging Service.
44 Sun & friends are addressing the problem The Java Module System (JAM) is in development. JSR-277 (runtime system) and JSR-294 (developer s view) have started in JMS already stands for Java Messaging Service. JSR stands for Java Specification Request.
45 Sun & friends are addressing the problem The Java Module System (JAM) is in development. JSR-277 (runtime system) and JSR-294 (developer s view) have started in Goals of JAM: provide high-level abstraction & remove JAR hell; JMS already stands for Java Messaging Service. JSR stands for Java Specification Request.
46 Sun & friends are addressing the problem The Java Module System (JAM) is in development. JSR-277 (runtime system) and JSR-294 (developer s view) have started in Goals of JAM: provide high-level abstraction & remove JAR hell; be as simple as possible to use (have modules with packages); JMS already stands for Java Messaging Service. JSR stands for Java Specification Request.
47 Sun & friends are addressing the problem The Java Module System (JAM) is in development. JSR-277 (runtime system) and JSR-294 (developer s view) have started in Goals of JAM: provide high-level abstraction & remove JAR hell; be as simple as possible to use (have modules with packages); be available to everyone automatically (put into the language); JMS already stands for Java Messaging Service. JSR stands for Java Specification Request.
48 Sun & friends are addressing the problem The Java Module System (JAM) is in development. JSR-277 (runtime system) and JSR-294 (developer s view) have started in Goals of JAM: provide high-level abstraction & remove JAR hell; be as simple as possible to use (have modules with packages); be available to everyone automatically (put into the language); be compatible with all Java sources (but only on JVM 7+). JMS already stands for Java Messaging Service. JSR stands for Java Specification Request.
49 The example Original Example with Packages XMLParser xml.parser package Key requires XSLT xslt ServletEngine engine Cache engine.cache WebCalendar webcalendar
50 The example Module definitions XMLParser XMLParser xml.parser package module definition Key imports XSLT xslt XSLT ServletEngine engine ServletEngine Cache engine.cache WebCalendar WebCalendar webcalendar
51 The example The source for the module definitions written in module files. superpackage XMLParser { member xml.parser; export xml. parser. Parser ; } superpackage XSLT { member xslt; import XMLParser; export xslt.xsltprocessor; } superpackage ServletEngine { member engine; member engine.cache; import XMLParser; export engine. ServletEngine ; } superpackage WebCalendar { member webcalendar; import ServletEngine ; import XSLT; }
52 The example Module definitions XMLParser XMLParser xml.parser package module definition Key imports XSLT xslt XSLT ServletEngine engine ServletEngine Cache engine.cache WebCalendar WebCalendar webcalendar
53 The example Module definitions and their instances XMLParser XMLParser xml.parser Key package module definition module instance imports instance of linked to XSLT xslt XSLT ServletEngine engine ServletEngine Cache engine.cache WebCalendar WebCalendar webcalendar
54 The example High-level abstraction XMLParser XMLParser xml.parser Key package module definition module instance imports instance of linked to sees XSLT xslt XSLT ServletEngine engine ServletEngine Cache engine.cache WebCalendar WebCalendar webcalendar
55 The example High-level abstraction No DLL/JAR hell XMLParser<3.0> XMLParser<2.0> Key XMLParser (version 3.0) xml.parser XMLParser (version 2.0) xml.parser package module definition module instance imports instance of linked to XSLT ServletEngine XSLT xslt ServletEngine engine Cache engine.cache WebCalendar WebCalendar webcalendar
56 Summary of JAM s concepts Module file A file naming the packages. Also mentions what is imported/exported. Module definition (a.k.a. superpackage) A file containing the packages. Compiled from a module file and classes. Module instance A runtime instance of a module definition that is linked up to other module instances. Repository A runtime entity where an administrator can (un-)install or initialize module definitions.
57 We discovered two major deficiencies with JAM 1. unintuitive class resolution XMLParser (exports: Parser) "Parser" Parser "Parser" XSLT Parser
58 We discovered two major deficiencies with JAM 2. only a single instance of each module permitted XMLParser XMLParser xml.parser Key package module definition module instance imports instance of linked to XSLT xslt XSLT ServletEngine engine ServletEngine Cache engine.cache WebCalendar WebCalendar webcalendar
59 improved JAM (ijam)
60 Our proposals to fix JAM s problems 1. adapt class resolution & allow class renaming XMLParser (exports: Parser) "Parser" Parser Parser as ImportedParser "ImportedParser" Parser XSLT "Parser" superpackage XSLT {.. import XMLParser with Parser as ImportedParser;.. }
61 Our proposals to fix JAM s problems Import Option 2. allow the user to specify sharing policies Short Description import m Uses JAM s default sharing policy. Can be overriden by replicating see below. import shared m Explicitly requests a shared instance of m. import own m Requests a separate instance of m. import m as amn Requests an instance (shared under name amn). Annotation (no annotation) replicating singleton Short Description Instantiation depends on the importer s policy. Default import results in a new instance. Always shares a single instance.
62 Our proposals to fix JAM s problems XMLParser XMLParser xml.parser Key package module definition module instance imports instance of linked to XSLT xslt XSLT ServletEngine engine ServletEngine Cache engine.cache WebCalendar WebCalendar webcalendar replicating superpackage XMLParser {...}
63 Reviewing desired modularity properties ML Java abstraction types, modules access, interface composition inner, functors inheritance, inner static reuse per file per class (JAR) dynamic reuse no per object separate compilation per file no JAM (LJAM) ijam abstraction [Java], exports [JAM], renaming composition [Java], imports [JAM], renaming static reuse [Java], mod. def.s [JAM] dynamic reuse [Java], forced per module [Java], optional per module separate compilation no* no* *SmartJavaMod [FTfJP 05] uses compositional constraints [POPL 05] to provide separate compilation for JAM-like modules.
64 Formalizations & proofs
65 What we did designed & formalized the core of JAM (40% JSR-277 & 80% JSR-294) on top of LJ obtaining LJAM. (where JSRs were ambiguous/incomplete we made reasonable choices and discussed alternatives);
66 What we did designed & formalized the core of JAM (40% JSR-277 & 80% JSR-294) on top of LJ obtaining LJAM. (where JSRs were ambiguous/incomplete we made reasonable choices and discussed alternatives); designed & formalized fixes to JAM obtaining ijam;
67 What we did designed & formalized the core of JAM (40% JSR-277 & 80% JSR-294) on top of LJ obtaining LJAM. (where JSRs were ambiguous/incomplete we made reasonable choices and discussed alternatives); designed & formalized fixes to JAM obtaining ijam; proved type soundness (in Isabelle/HOL) for LJ, for LJAM, and for ijam.
68 What we did designed & formalized the core of JAM (40% JSR-277 & 80% JSR-294) on top of LJ obtaining LJAM. (where JSRs were ambiguous/incomplete we made reasonable choices and discussed alternatives); designed & formalized fixes to JAM obtaining ijam; proved type soundness (in Isabelle/HOL) for LJ, for LJAM, and for ijam. tools used: Isabelle A tool for writing computer-verified maths. (essential for this scale). Ott A tool for writing definitions of PLs [ICFP 07]: ASCII source L A TEX/Coq/HOL/Isabelle
69 Why? The JAM JSRs are written in English only (+180 pages), including statements like: There is at most one module instance instantiated from each module definition per repository instance. A module definition can have multiple module instances through multiple repository instances.
70 Why? The JAM JSRs are written in English only (+180 pages), including statements like: There is at most one module instance instantiated from each module definition per repository instance. A module definition can have multiple module instances through multiple repository instances. Formalisation allows precise discussion.
71 Why? The JAM JSRs are written in English only (+180 pages), including statements like: There is at most one module instance instantiated from each module definition per repository instance. A module definition can have multiple module instances through multiple repository instances. Formalisation allows precise discussion. Subtle bugs are found early.
72 Why? The JAM JSRs are written in English only (+180 pages), including statements like: There is at most one module instance instantiated from each module definition per repository instance. A module definition can have multiple module instances through multiple repository instances. Formalisation allows precise discussion. Subtle bugs are found early. When available, one can (dis-)prove properties about the specification.
73 What does it mean to formalise? 1 Read the given prose carefully;
74 What does it mean to formalise? 1 Read the given prose carefully; 2 identify the key concepts;
75 What does it mean to formalise? 1 Read the given prose carefully; 2 identify the key concepts; 3 associate those with mathematical entities;
76 What does it mean to formalise? 1 Read the given prose carefully; 2 identify the key concepts; 3 associate those with mathematical entities; 4 give mathematical rules that relate these entities according to the intended semantics.
77 What does it mean to formalise? 1 Read the given prose carefully; 2 identify the key concepts; 3 associate those with mathematical entities; 4 give mathematical rules that relate these entities according to the intended semantics. An example statement reduction (config config ) rule: r field read L (x) = oid H (oid, f ) = v (P, L, H, var = x. f ; s l l ) (P, L [var v], H, s l l )
78 Formalization overview Name Description Ott LOD No. of rules LJ an imperative fragment of Java LJAM formalisation of core JAM ijam LJAM with fixes
79 Results We proved type-soundness for all three formalisations by proving: Theorem (Progress) Γ (P, L, H, s) s [] = config. (P, L, H, s) config and Theorem (Type Preservation) Γ config (config config config = Γ. Γ m Γ Γ config a config )
80 Definition & proof script reuse Definitions (lines) LJ (1381) Proof Scripts (lines, lemmas) LJ (2741, 254) LJAM (4386, 382) LJAM (2502) ijam (2671) ijam (4508, 393) Relative area corresponds to relative number of lines.
81 Implementation We wrote a proof-of-concept implementation in Java, which can closely follow the semantics of either LJAM or ijam. In particular, we implemented: module files (with JavaCC); repositories; module definitions; module instances; the module initialization mechanism; LJAM s and ijam s class resolution (with classloaders): each module is a classloader, which delegates class resolution according to the class lookup semantics.
82 Conclusion
83 Conclusions formalization is useful: concise, unambiguous def.; enables precise discussion of design; early bug detection!
84 Conclusions formalization is useful: concise, unambiguous def.; enables precise discussion of design; early bug detection! using the formalization we found & fixed some problems;
85 Conclusions formalization is useful: concise, unambiguous def.; enables precise discussion of design; early bug detection! using the formalization we found & fixed some problems; this work was completed relatively quickly, on the timescale of language evolution process;
86 Conclusions formalization is useful: concise, unambiguous def.; enables precise discussion of design; early bug detection! using the formalization we found & fixed some problems; this work was completed relatively quickly, on the timescale of language evolution process; formalizing real PLs and their updates now seems feasible (and recommended)!
87 Future plans extract implementation of LJ/LJAM/iJAM from its Isabelle definition; apply developed ideas to a large project.
88 More information For more information, publications, documentation, definitions, and Java implementation of LJAM/iJAM, see Papers: Strniša, R., Sewell, P., Parkinson, M.: The Java Module System: Core Design and Semantics Definition. In: Proc. of OOPSLA 07 Strniša, R.: Fixing the Java Module System, in Theory and in Practice. Submitted to FTfJP 08 (ECOOP).
Java Language Modularity With Superpackages
Java Language Modularity With Superpackages Alex Buckley JSR 294 Co-spec lead Sun Microsystems Andreas Sterbenz JSR 294 Co-spec lead Sun Microsystems TS-2401 2007 JavaOne SM Conference Session 2401 Goal
Intro to semantics; Small-step semantics Lecture 1 Tuesday, January 29, 2013
Harvard School of Engineering and Applied Sciences CS 152: Programming Languages Lecture 1 Tuesday, January 29, 2013 1 Intro to semantics What is the meaning of a program? When we write a program, we use
Java Modularity Support in OSGi R4. Richard S. Hall ApacheCon (San Diego) December 14 th, 2005
Java Modularity Support in OSGi R4 Richard S. Hall ApacheCon (San Diego) December 14 th, 2005 Modularity What is it? What is Modularity? (Desirable) property of a system, such that individual components
Types. Type checking. Why Do We Need Type Systems? Types and Operations. What is a type? Consensus
Types Type checking What is a type? The notion varies from language to language Consensus A set of values A set of operations on those values Classes are one instantiation of the modern notion of type
CSCI B522 Lecture 11 Naming and Scope 8 Oct, 2009
CSCI B522 Lecture 11 Naming and Scope 8 Oct, 2009 Lecture notes for CS 6110 (Spring 09) taught by Andrew Myers at Cornell; edited by Amal Ahmed, Fall 09. 1 Static vs. dynamic scoping The scope of a variable
Equinox OSGi: Pervasive Componentization
Equinox OSGi: Pervasive Componentization Thomas Watson Equinox Development Lead IBM Lotus Jeff McAffer, Eclipse RCP and Equinox Lead IBM Rational Software 10/3/2006 Why is Eclipse interesting? Extensible
Mixin Up the ML Module System
Mixin Up the ML Module System Derek Dreyer and Andreas Rossberg Max Planck Institute for Software Systems Saarbrücken, Germany ICFP 2008 Victoria, British Columbia September 24, 2008 The ML Module System
SAS 9.2 Foundation Services. Administrator s Guide
SAS 9.2 Foundation Services Administrator s Guide The correct bibliographic citation for this manual is as follows: SAS Institute Inc. 2009. SAS 9.2 Foundation Services: Administrator s Guide. Cary, NC:
Programming Languages
CSE 230: Winter 2008 Principles of Programming Languages Ocaml/HW #3 Q-A Session Push deadline = Mar 10 Session Mon 3pm? Lecture 15: Type Systems Ranjit Jhala UC San Diego Why Typed Languages? Development
Anatomy of a Compiler. Overview of Semantic Analysis. The Compiler So Far. Why a Separate Semantic Analysis?
Anatomy of a Compiler Program (character stream) Lexical Analyzer (Scanner) Syntax Analyzer (Parser) Semantic Analysis Parse Tree Intermediate Code Generator Intermediate Code Optimizer Code Generator
Breaking Apart the Monolith with Modularity and Microservices CON3127
Breaking Apart the Monolith with Modularity and Microservices CON3127 Neil Griffin Software Architect, Liferay Inc. Specification Lead, JSR 378 Portlet 3.0 Bridge for JavaServer Faces 2.2 Michael Han Vice
Semantic Analysis. Outline. The role of semantic analysis in a compiler. Scope. Types. Where we are. The Compiler Front-End
Outline Semantic Analysis The role of semantic analysis in a compiler A laundry list of tasks Scope Static vs. Dynamic scoping Implementation: symbol tables Types Static analyses that detect type errors
Formal Semantics of Programming Languages
Formal Semantics of Programming Languages Mooly Sagiv Reference: Semantics with Applications Chapter 2 H. Nielson and F. Nielson http://www.daimi.au.dk/~bra8130/wiley_book/wiley.html Benefits of formal
CSCE 314 Programming Languages. Type System
CSCE 314 Programming Languages Type System Dr. Hyunyoung Lee 1 Names Names refer to different kinds of entities in programs, such as variables, functions, classes, templates, modules,.... Names can be
Formal Semantics of Programming Languages
Formal Semantics of Programming Languages Mooly Sagiv Reference: Semantics with Applications Chapter 2 H. Nielson and F. Nielson http://www.daimi.au.dk/~bra8130/wiley_book/wiley.html Benefits of formal
High-level languages
High-level languages High-level languages are not immune to these problems. Actually, the situation is even worse: the source language typically operates over mixed-size values (multi-word and bitfield);
SAS 9.4 Foundation Services: Administrator s Guide
SAS 9.4 Foundation Services: Administrator s Guide SAS Documentation July 18, 2017 The correct bibliographic citation for this manual is as follows: SAS Institute Inc. 2013. SAS 9.4 Foundation Services:
CS558 Programming Languages
CS558 Programming Languages Fall 2016 Lecture 3a Andrew Tolmach Portland State University 1994-2016 Formal Semantics Goal: rigorous and unambiguous definition in terms of a wellunderstood formalism (e.g.
Wednesday, June 23, JBoss Users & Developers Conference. Boston:2010
JBoss Users & Developers Conference Boston:2010 Zen of Class Loading Jason T. Greene EAP Architect, Red Hat June 2010 What is the Class class? Represents a class, enum, interface, annotation, or primitive
Do you really get classloaders?
Do you really get classloaders? Jevgeni Kabanov CEO & Founder of ZeroTurnaround (how awesome is that?) Free! social.jrebel.com Over 50 million builds, redeploys & restarts prevented for 30,000+ Java developers
Fitting the Pieces Together: A Machine-Checked Model of Safe Composition. Benjamin Delaware William Cook Don Batory University of Texas at Austin
Fitting the Pieces Together: A Machine-Checked Model of Safe Composition Benjamin Delaware William Cook Don Batory University of Texas at Austin Safe Composition Features Word Processor has formatting,
Overview. Elements of Programming Languages. Objects. Self-Reference
Overview Elements of Programming Languages Lecture 10: James Cheney University of Edinburgh October 23, 2017 Last time: programming in the large Programs, packages/namespaces, importing Modules and interfaces
Adam Chlipala University of California, Berkeley ICFP 2006
Modular Development of Certified Program Verifiers with a Proof Assistant Adam Chlipala University of California, Berkeley ICFP 2006 1 Who Watches the Watcher? Program Verifier Might want to ensure: Memory
COS 320. Compiling Techniques
Topic 5: Types COS 320 Compiling Techniques Princeton University Spring 2016 Lennart Beringer 1 Types: potential benefits (I) 2 For programmers: help to eliminate common programming mistakes, particularly
Jam: A Smooth Extension With Java Mixins
Jam: A Smooth Extension With Java Mixins Davide Ancona, Giovanni Lagorio, Ellena Zucca Presentation created by Left-out Jam abstract syntax Formal definitions of Jam static semantics Formal definitions
CS152: Programming Languages. Lecture 11 STLC Extensions and Related Topics. Dan Grossman Spring 2011
CS152: Programming Languages Lecture 11 STLC Extensions and Related Topics Dan Grossman Spring 2011 Review e ::= λx. e x e e c v ::= λx. e c τ ::= int τ τ Γ ::= Γ, x : τ (λx. e) v e[v/x] e 1 e 1 e 1 e
COMP 181. Agenda. Midterm topics. Today: type checking. Purpose of types. Type errors. Type checking
Agenda COMP 181 Type checking October 21, 2009 Next week OOPSLA: Object-oriented Programming Systems Languages and Applications One of the top PL conferences Monday (Oct 26 th ) In-class midterm Review
The role of semantic analysis in a compiler
Semantic Analysis Outline The role of semantic analysis in a compiler A laundry list of tasks Scope Static vs. Dynamic scoping Implementation: symbol tables Types Static analyses that detect type errors
Safe Instantiation in Generic Java
Safe Instantiation in Generic Java January 31, 2003 Abstract This paper presents the safe-instantiation principle a new design principle for evaluating extensions of Java with support for generic types.
Semantic Analysis. Outline. The role of semantic analysis in a compiler. Scope. Types. Where we are. The Compiler so far
Outline Semantic Analysis The role of semantic analysis in a compiler A laundry list of tasks Scope Static vs. Dynamic scoping Implementation: symbol tables Types Statically vs. Dynamically typed languages
When Java technology burst onto the Internet scene in 1995,
MOBILE CODE SECURITY SECURE JAVA CLASS LOADING The class loading mechanism, LI GONG Sun Microsystems central to Java, plays a key role in JDK 1.2 by enabling When Java technology burst onto the Internet
Simply-Typed Lambda Calculus
#1 Simply-Typed Lambda Calculus #2 Back to School What is operational semantics? When would you use contextual (small-step) semantics? What is denotational semantics? What is axiomatic semantics? What
Overview. Elements of Programming Languages. Objects. Self-Reference
Overview Elements of Programming Languages Lecture 11: James Cheney University of Edinburgh November 3, 2015 Last time: programming in the large Programs, packages/namespaces, importing Modules and interfaces
Scala. Fernando Medeiros Tomás Paim
Scala Fernando Medeiros fernfreire@gmail.com Tomás Paim tomasbmp@gmail.com Topics A Scalable Language Classes and Objects Basic Types Functions and Closures Composition and Inheritance Scala s Hierarchy
Topics Covered Thus Far. CMSC 330: Organization of Programming Languages. Language Features Covered Thus Far. Programming Languages Revisited
CMSC 330: Organization of Programming Languages Type Systems, Names & Binding Topics Covered Thus Far Programming languages Syntax specification Regular expressions Context free grammars Implementation
Verified compilers. Guest lecture for Compiler Construction, Spring Magnus Myréen. Chalmers University of Technology
Guest lecture for Compiler Construction, Spring 2015 Verified compilers Magnus Myréen Chalmers University of Technology Mentions joint work with Ramana Kumar, Michael Norrish, Scott Owens and many more
Scripting Languages in OSGi. Thursday, November 8, 12
Scripting Languages in OSGi Frank Lyaruu CTO Dexels Project lead Navajo Framework Amsterdam www.dexels.com Twitter: @lyaruu Navajo Framework TSL XML based script language Compiled to Java Recently ported
An Approach to the Generation of High-Assurance Java Card Applets
An Approach to the Generation of High-Assurance Java Card Applets Alessandro Coglio Kestrel Institute 3260 Hillview Avenue, Palo Alto, CA 94304, USA Ph. +1-650-493-6871 Fax +1-650-424-1807 http://www.kestrel.edu/
Modularity in Java. With OSGi. Alex Docklands.LJC January Copyright 2016 Alex Blewitt
Modularity in Java With OSGi Alex Blewitt @alblue Docklands.LJC January 2016 Modularity in Java Modularity is Easy? Modularity is Hard! Modularity is Hard! Modularity is Hard! Modularity is Hard! Modularity
B. Assets are shared-by-copy by default; convert the library into *.jar and configure it as a shared library on the server runtime.
Volume A~B: 114 Questions Volume A 1. Which component type must an integration solution developer define for a non-sca component such as a Servlet that invokes a service component interface? A. Export
Programming Languages
: Winter 2010 Principles of Programming Languages Lecture 1: Welcome, etc. Ranjit Jhala UC San Diego Computation & Interaction Precisely expressed by PL Dependence means need for analysis Safety Security
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Type Systems, Names and Binding CMSC 330 - Spring 2013 1 Topics Covered Thus Far! Programming languages Ruby OCaml! Syntax specification Regular expressions
Joint Entity Resolution
Joint Entity Resolution Steven Euijong Whang, Hector Garcia-Molina Computer Science Department, Stanford University 353 Serra Mall, Stanford, CA 94305, USA {swhang, hector}@cs.stanford.edu No Institute
Introducing Wybe a language for everyone
Introducing Wybe a language for everyone Peter Schachte joint work with Matthew Giuca The University of Melbourne Department of Computing and Information Systems 4 December 2013 Peter Schachte (Melbourne)
JSR 277, 291 and OSGi, Oh My! - OSGi and Java Modularity
JSR 277, 291 and OSGi, Oh My! - OSGi and Java Modularity Richard S. Hall June 28 th, 2006 Agenda Modularity Modularity in Java Modularity in Java + OSGi technology Introduction to OSGi technology Apache
Written Presentation: JoCaml, a Language for Concurrent Distributed and Mobile Programming
Written Presentation: JoCaml, a Language for Concurrent Distributed and Mobile Programming Nicolas Bettenburg 1 Universitaet des Saarlandes, D-66041 Saarbruecken, nicbet@studcs.uni-sb.de Abstract. As traditional
Servlets. How to use Apache FOP in a Servlet $Revision: $ Table of contents
How to use Apache FOP in a Servlet $Revision: 505235 $ Table of contents 1 Overview...2 2 Example Servlets in the FOP distribution...2 3 Create your own Servlet...2 3.1 A minimal Servlet...2 3.2 Adding
IBS Software Services Technical Interview Questions. Q1. What is the difference between declaration and definition?
IBS Software Services Technical Interview Questions Q1. What is the difference between declaration and definition? The declaration tells the compiler that at some later point we plan to present the definition
G Programming Languages Spring 2010 Lecture 8. Robert Grimm, New York University
G22.2110-001 Programming Languages Spring 2010 Lecture 8 Robert Grimm, New York University 1 Review Last time Types Fun with O Caml 2 Outline Modules Sources: PLP, 3.3.4, 3.3.5, 3.7 Barrett. Lecture notes,
Representation Independence, Confinement and Access Control
Representation Independence, Confinement and Access Control Anindya Banerjee and David Naumann ab@cis.ksu.edu and naumann@cs.stevens-tech.edu Kansas State University and Stevens Institute of Technology
CS 6110 S11 Lecture 12 Naming and Scope 21 February 2011
CS 6110 S11 Lecture 12 Naming and Scope 21 February 2011 In this lecture we introduce the topic of scope in the context of the λ-calculus and define translations from λ-cbv to FL for the two most common
Atelier Java - J1. Marwan Burelle. EPITA Première Année Cycle Ingénieur.
marwan.burelle@lse.epita.fr http://wiki-prog.kh405.net Plan 1 2 Plan 3 4 Plan 1 2 3 4 A Bit of History JAVA was created in 1991 by James Gosling of SUN. The first public implementation (v1.0) in 1995.
CS558 Programming Languages
CS558 Programming Languages Fall 2017 Lecture 3a Andrew Tolmach Portland State University 1994-2017 Binding, Scope, Storage Part of being a high-level language is letting the programmer name things: variables
Seminar report Java Submitted in partial fulfillment of the requirement for the award of degree Of CSE
A Seminar report On Java Submitted in partial fulfillment of the requirement for the award of degree Of CSE SUBMITTED TO: www.studymafia.org SUBMITTED BY: www.studymafia.org 1 Acknowledgement I would like
Appendix A - Glossary(of OO software term s)
Appendix A - Glossary(of OO software term s) Abstract Class A class that does not supply an implementation for its entire interface, and so consequently, cannot be instantiated. ActiveX Microsoft s component
Semantic Analysis. Lecture 9. February 7, 2018
Semantic Analysis Lecture 9 February 7, 2018 Midterm 1 Compiler Stages 12 / 14 COOL Programming 10 / 12 Regular Languages 26 / 30 Context-free Languages 17 / 21 Parsing 20 / 23 Extra Credit 4 / 6 Average
Compiler Construction
Compiler Construction Thomas Noll Software Modeling and Verification Group RWTH Aachen University https://moves.rwth-aachen.de/teaching/ws-1819/cc/ Generation of Intermediate Code Outline of Lecture 15
Lecture 13: Subtyping
Lecture 13: Subtyping Polyvios Pratikakis Computer Science Department, University of Crete Type Systems and Programming Languages Pratikakis (CSD) Subtyping CS546, 2018-2019 1 / 15 Subtyping Usually found
Second-Order Type Systems
#1 Second-Order Type Systems Homework 5 Summary Student : 37.9704 Student : 44.4466 ORIGINAL : 50.2442 Student : 50.8275 Student : 50.8633 Student : 50.9181 Student : 52.1347 Student : 52.1633 Student
Hiding local state in direct style: a higher-order anti-frame rule
1 / 65 Hiding local state in direct style: a higher-order anti-frame rule François Pottier January 28th, 2008 2 / 65 Contents Introduction Basics of the type system A higher-order anti-frame rule Applications
Service-Oriented Programming
Service-Oriented Programming by Guy Bieber, Lead Architect, ISD C4I, Motorola ABSTRACT - The Service-Oriented Programming (SOP) model is the most exciting revolution in programming since Object Oriented
Advanced Database Applications. Object Oriented Database Management Chapter 13 10/29/2016. Object DBMSs
Object Oriented Database Chapter 13 1 Object DBMSs Underlying concepts: Freely sharing data across processing routines creates unacceptable data dependencies All software should be constructed out of standard,
DESIGN PATTERN - INTERVIEW QUESTIONS
DESIGN PATTERN - INTERVIEW QUESTIONS http://www.tutorialspoint.com/design_pattern/design_pattern_interview_questions.htm Copyright tutorialspoint.com Dear readers, these Design Pattern Interview Questions
Exam Name: IBM Certified System Administrator - WebSphere Application Server Network Deployment V7.0
Vendor: IBM Exam Code: 000-377 Exam Name: IBM Certified System Administrator - WebSphere Application Server Network Deployment V7.0 Version: Demo QUESTION 1 An administrator would like to use the Centralized
Inheritance (Chapter 7)
Inheritance (Chapter 7) Prof. Dr. Wolfgang Pree Department of Computer Science University of Salzburg cs.uni-salzburg.at Inheritance the soup of the day?! Inheritance combines three aspects: inheritance
Open XML Requirements Specifications, a Xylia based application
Open XML Requirements Specifications, a Xylia based application Naeim Semsarilar Dennis K. Peters Theodore S. Norvell Faculty of Engineering and Applied Science Memorial University of Newfoundland November
Comparing JavaBeans and OSGi
Comparing JavaBeans and OSGi Towards an Integration of Two Complementary Component Models HUMBERTO CERVANTES JEAN-MARIE FAVRE 09/02 Who I Am Humberto Cervantes 3d year PhD at Adèle team, LSR, Grenoble
CS558 Programming Languages
CS558 Programming Languages Winter 2017 Lecture 9b Andrew Tolmach Portland State University 1994-2017 Programming in the large Language features for modularity are crucial for writing large programs Idea:
SUN. Java Platform Enterprise Edition 6 Web Services Developer Certified Professional
SUN 311-232 Java Platform Enterprise Edition 6 Web Services Developer Certified Professional Download Full Version : http://killexams.com/pass4sure/exam-detail/311-232 QUESTION: 109 What are three best
CS 565: Programming Languages. Spring 2008 Tu, Th: 16:30-17:45 Room LWSN 1106
CS 565: Programming Languages Spring 2008 Tu, Th: 16:30-17:45 Room LWSN 1106 Administrivia Who am I? Course web page http://www.cs.purdue.edu/homes/peugster/cs565spring08/ Office hours By appointment Main
Data Structures (list, dictionary, tuples, sets, strings)
Data Structures (list, dictionary, tuples, sets, strings) Lists are enclosed in brackets: l = [1, 2, "a"] (access by index, is mutable sequence) Tuples are enclosed in parentheses: t = (1, 2, "a") (access
Liberate your components with OSGi services
Liberate your components with OSGi services One products journey through the Modularity Maturity Model Alasdair Nottingham (not@uk.ibm.com) WebSphere Application Server V8.5 Liberty Profile Development
Pierce Ch. 3, 8, 11, 15. Type Systems
Pierce Ch. 3, 8, 11, 15 Type Systems Goals Define the simple language of expressions A small subset of Lisp, with minor modifications Define the type system of this language Mathematical definition using
A Type System for Functional Traversal-Based Aspects
A Type System for Functional Traversal-Based Aspects Bryan Chadwick College of Computer & Information Science Northeastern University, 360 Huntington Avenue Boston, Massachusetts 02115 USA chadwick@ccs.neu.edu
J2EE Interview Questions
1) What is J2EE? J2EE Interview Questions J2EE is an environment for developing and deploying enterprise applications. The J2EE platform consists of a set of services, application programming interfaces
.Net. Course Content ASP.NET
.Net Course Content ASP.NET INTRO TO WEB TECHNOLOGIES HTML ü Client side scripting langs ü lls Architecture ASP.NET INTRODUCTION ü What is ASP.NET ü Image Technique and code behind technique SERVER SIDE
What are the characteristics of Object Oriented programming language?
What are the various elements of OOP? Following are the various elements of OOP:- Class:- A class is a collection of data and the various operations that can be performed on that data. Object- This is
CS558 Programming Languages
CS558 Programming Languages Winter 2018 Lecture 7b Andrew Tolmach Portland State University 1994-2018 Dynamic Type Checking Static type checking offers the great advantage of catching errors early And
Representation Independence, Confinement and Access Control
Representation Independence, Confinement and Access Control Anindya Banerjee and David Naumann ab@cis.ksu.edu and naumann@cs.stevens-tech.edu Kansas State University and Stevens Institute of Technology,
Goal. CS152: Programming Languages. Lecture 15 Parametric Polymorphism. What the Library Likes. What The Client Likes. Start simpler.
Goal Understand what this interface means and why it matters: CS152: Programming Languages Lecture 15 Parametric Polymorphism Dan Grossman Spring 2011 type a mylist; val mt_list : a mylist val cons : a
Modular Programming. Prof. Clarkson Fall Today s music: "Giorgio By Moroder" by Daft Punk
Modular Programming Prof. Clarkson Fall 2017 Today s music: "Giorgio By Moroder" by Daft Punk Moog modular synthesizer Based in Trumansburg, NY, 1953-1971 Game changing! picked up by the Beatles, the Rolling
Today s Class. Programming Languages Topic of Ultimate Mastery. Reasonable Initial Skepticism. Meta-Level Information
Programming Languages Topic of Ultimate Mastery Reasonable Initial Skepticism Wes Weimer CS 615 TR 5:00-6:15 @ OLS 005 http://www.cs.virginia.edu/~weimer/615 (note: CS 615 == CS 655) Today s Class Vague
Theorem proving. PVS theorem prover. Hoare style verification PVS. More on embeddings. What if. Abhik Roychoudhury CS 6214
Theorem proving PVS theorem prover Abhik Roychoudhury National University of Singapore Both specification and implementation can be formalized in a suitable logic. Proof rules for proving statements in
1. Introduction to the Common Language Infrastructure
Miller-CHP1.fm Page 1 Wednesday, September 24, 2003 1:50 PM to the Common Language Infrastructure The Common Language Infrastructure (CLI) is an International Standard that is the basis for creating execution
Programming Languages FILS Andrei Vasilateanu
Programming Languages FILS 2014-2015 Andrei Vasilateanu Course Master: Administration Andrei Vasilateanu, andraevs@gmail.com Teaching Assistants: Radu Serban Grading: Final exam 40% Laboratory 60% 2 Tests
Names, Scope, and Bindings
Names, Scope, and Bindings COMS W4115 Prof. Stephen A. Edwards Spring 2007 Columbia University Department of Computer Science What s In a Name? Name: way to refer to something else variables, functions,
OSGi on the Server. Martin Lippert (it-agile GmbH)
OSGi on the Server Martin Lippert (it-agile GmbH) lippert@acm.org 2009 by Martin Lippert; made available under the EPL v1.0 October 6 th, 2009 Overview OSGi in 5 minutes Apps on the server (today and tomorrow)
Turning proof assistants into programming assistants
Turning proof assistants into programming assistants ST Winter Meeting, 3 Feb 2015 Magnus Myréen Why? Why combine proof- and programming assistants? Why proofs? Testing cannot show absence of bugs. Some
Assuring Software Protection in Virtual Machines
Assuring Software Protection in Virtual Machines Andrew W. Appel Princeton University 1 Software system built from components Less-trusted components More-trusted components (non-core functions) INTERFACE
Compiler Theory. (Semantic Analysis and Run-Time Environments)
Compiler Theory (Semantic Analysis and Run-Time Environments) 005 Semantic Actions A compiler must do more than recognise whether a sentence belongs to the language of a grammar it must do something useful
Java EE 6 - Update Harpreet Singh GlassFish Portfolio Product Manager
Java EE 6 - Update Harpreet Singh GlassFish Portfolio Product Manager Sun Microsystems 1 The Elephant In The Room 2 Here's what I can... Show Say 3 Business As Usual 4 Business As Usual = Participate in
Nothing to see here...
Nothing to see here... Work in progress. Does not reflect reality, purely the thoughts of a mad man Deployment Models Single JVM Redundant JVM Externalized System Services Fully Distributed Or some other
Tradeoffs. CSE 505: Programming Languages. Lecture 15 Subtyping. Where shall we add useful completeness? Where shall we add completeness?
Tradeoffs CSE 505: Programming Languages Lecture 15 Subtyping Zach Tatlock Autumn 2017 Desirable type system properties (desiderata): soundness - exclude all programs that get stuck completeness - include
CS558 Programming Languages
CS558 Programming Languages Winter 2017 Lecture 4a Andrew Tolmach Portland State University 1994-2017 Semantics and Erroneous Programs Important part of language specification is distinguishing valid from
A Modular Package Language for Haskell
A Modular Package Language for Haskell Scott Kilpatrick MPI-SWS Joint work with: Derek Dreyer (MPI-SWS) Simon Marlow (Microsoft Research) Simon Peyton Jones (Microsoft Research) University of Pennsylvania
Object-Oriented Programming
Object-Oriented Programming 3/18/14 Presentation for use with the textbook Data Structures and Algorithms in Java, 6th edition, by M. T. Goodrich, R. Tamassia, and M. H. Goldwasser, Wiley, 2014 Object-Oriented
The Java Language Implementation
CS 242 2012 The Java Language Implementation Reading Chapter 13, sections 13.4 and 13.5 Optimizing Dynamically-Typed Object-Oriented Languages With Polymorphic Inline Caches, pages 1 5. Outline Java virtual
Lecture 7: Type Systems and Symbol Tables. CS 540 George Mason University
Lecture 7: Type Systems and Symbol Tables CS 540 George Mason University Static Analysis Compilers examine code to find semantic problems. Easy: undeclared variables, tag matching Difficult: preventing
Compilers and computer architecture: Semantic analysis
1 / 1 Compilers and computer architecture: Semantic analysis Martin Berger Alex Jeffery October 2018 Recall the function of compilers 2 / 1 3 / 1 Recall the structure of compilers Source program Lexical
JOI - Java Objects by Interface
JOI - Java Objects by Interface Heiko von Drachenfels, Oliver Haase, and Robert Walter HTWG Konstanz - University of Applied Sciences, Constance, Germany drachenfels haase rwalter@htwg-konstanz.de 1 Introduction