DOCSLIB.ORG

Reflection for the Masses*

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Reflection for the Masses* Reflection for the Masses? Charlotte Herzeel, Pascal Costanza, and Theo D'Hondt Vrije Universiteit Brussel [email protected] Abstract. A reflective programming language provides means to render explicit what is typically abstracted away in its language constructs in an on-demand style. In the early 1980's, Brian Smith introduced a gen- eral recipe for building reflective programming languages with the notion of procedural reflection. It is an excellent framework for understanding and comparing various metaprogramming and reflective approaches, in- cluding macro programming, first-class environments, first-class contin- uations, metaobject protocols, aspect-oriented programming, and so on. Unfortunately, the existing literature of Brian Smith's original account of procedural reflection is hard to understand: It is based on terminology derived from philosophy rather than computer science, and takes con- cepts for granted that are hard to reconstruct without intimate knowl- edge of historical Lisp dialects from the 1960's and 1970's. We attempt to untangle Smith's original account of procedural reflection and make it accessible to a new and wider audience. On the other hand, we then use its terminological framework to analyze other metaprogramming and reflective approaches, especially those that came afterwards. 1 Introduction Programming languages make programming easier because they provide an ab- stract model of computers. For example, a Lisp or Smalltalk programmer does not think of computers in terms of clock cycles or transistors, but in terms of a virtual machine that understands s-expressions, and performs evaluation and function application, or understands class hierarchies, and performs mes- sage sending and dynamic dispatch. The implementation of the particular pro- gramming language then addresses the actual hardware: It is the interpreter or compiler that translates the language to the machine level. Programming languages do not only differ in the programming models they provide (functional, object-oriented, logic-based, multi-paradigm, and so on), but also in fine-grained design choices and general implementation strategies. These differences involve abstractions that are implemented as explicit language constructs, but also \hidden" concepts that completely abstract away from cer- tain implementation details. For example, a language may or may not abstract away memory management through automatic garbage collection, may or may ? In: R. Hirschfeld and K. Rose (Eds.): S3 2008, LNCS 5146, pp. 87{122, 2008. c Springer-Verlag Berlin Heidelberg 2008. not support recursion, may or may not abstract away variable lookup through lexical scoping, and so on. The implementation details of features like garbage collection, recursion and lexical scoping are not explicitly mentioned in programs and are thus said to be absorbed by the language [1]. Some languages absorb less and reveal more details about the internal workings of their implementation (the interpreter, the compiler or ultimately the hardware) than others. We know that all computational problems can be expressed in any Turing- complete language, but absorption has consequences with regard to the way we think about and express solutions for computational problems. While some kinds of absorption are generally considered to have strong advantages, it is also obvious that some hard problems are easier to solve when one does have con- trol over the implementation details of a language. For example, declaring weak references tells the otherwise invisible garbage collector to treat certain objects specially, using the cut operator instructs Prolog to skip choices while otherwise silently backtracking, and first-class continuations enable manipulating the oth- erwise implicit control flow in Scheme. When designing a programming language, choosing which parts of the implementation model are or are not absorbed is about finding the right balance between generality and conciseness [2], and it is hard to determine what is a good balance in the general case. A reflective programming language provides means to render explicit what is being absorbed in an on-demand style. To support this, it is equipped with a model of its own implementation, and with constructs for explicitly manipulating that implementation. This allows the programmer to change the very model of the programming language from within itself! In a way, reflection strips away a layer of abstraction, bringing the programmer one step closer to the actual machine. However, there is no easy escape from the initially chosen programming model and its general implementation strategy: For example, it is hard to turn an object-oriented language into a logic language. Rather think of the programmer being able to change the fine-grained details. For example, one can define versions of an object-oriented language with single or multiple inheritance, with single or multiple dispatch, with or without specific scoping rules, and so on. In the literature, it is said that a reflective language is an entire region in the design space of languages rather than a single, fixed language [3]. In order to support reflective programming, the implementation of the pro- gramming language needs to provide a reflective architecture. In the beginning of the 1980's, Smith et al. introduced procedural reflection, which is such a re- flective architecture that introduces the essential concepts for building reflective programming languages. Since the introduction of procedural reflection, many people have used, refined and extended these concepts for building their own re- flective programming languages. As such, understanding procedural reflection is essential for understanding and comparing various metaprogramming and reflec- tive approaches, including macro programming, first-class environments, first- class continuations, metaobject protocols, aspect-oriented programming, and so on. Unfortunately, the existing literature of Smith's original account of proce- dural reflection is hard to understand: It is based on terminology derived from Syntactic Domain Structural Field Real World <float> 5.0 'five' <function call> (+ 23 (+ 10 9)) 'forty-two' <float> (lambda (x) 'increment (+ 1 x)) function' <function call> <closure> "john" <['j, 'o, 'h, 'n]> Internalization Normalization Denotation Fig. 1. Smith's theory of computation. philosophy rather than computer science, and takes concepts known in the Lisp community in the 1960's and 1970's for granted that are hard to reconstruct without intimate knowledge of historical Lisp dialects. In this paper, we report on our own attempt to untangle and reconstruct the original account of procedural reflection. Our approach was to actually reim- plement a new interpreter for 3-Lisp, using Common Lisp as a modern imple- mentation language. In our work, we also build upon experiences and insights that came after the introduction of procedural reflection in [1], and also add some refinements based on our own insights. Additionally we use the concepts introduced by procedural reflection to analyze various other metaprogramming and reflective approaches, especially those that came after Smith's conception of procedural reflection. 2 Self representation for a programming language By introducing procedural reflection, Smith introduced a general framework for adding reflective capabilities to programming languages. In order to turn a pro- gramming language into a reflective version, one must extend the language with a model of the same language's implementation. That self representation must be causally connected to the language's implementation: When we manipulate the self representation, this should be translated into a manipulation of the real implementation. What parts of the implementation are possibly relevant to in- clude in the model can by large be derived from mapping the non-reflective version of the programming language to Smith's theory of computation. 2.1 A model of computation According to Smith [1], computation can be modeled as a relational mapping between three distinct domains: a syntactic domain, an internal representational domain (the structural field) and the \real world". The syntactic domain consists of program source code. The structural field consists of all runtime entities that make up the language implementation. In extremis, this includes the electrons and molecules of the hardware on which the interpreter runs. However, for the purpose of procedural reflection, the structural field typically consists of high- level data structures for implementing the values native to the programming language, such as numbers, characters, functions, sequences, strings, and so on. The real world consists of natural objects and abstract concepts that program- mers and users want to refer to in programs, but that are typically out of reach of a computer. Fig. 1 shows a graphical representation for computation as a mapping from programs, to their internal representation, to their meaning in the real world. The three labelled boxes represent each of the domains. The collection of arrows depict the mapping. The figure is meant to represent a model for computation rendered by a Lisp interpreter, written in C { hence the s-expressions as example elements of the syntactic domain. The <type> notation is used to denote an instance of a particular C type or struct. For example, the \number 5" is written as \5.0" in the programming language. Internally, it is represented by a C value of type float and it means, as to be expected,
Load more

Recommended publications
  • LISP Working Group S. Barkai Internet-Draft B
    LISP Working Group S. Barkai Internet-Draft B. Fernandez-Ruiz Intended status: Experimental S. ZionB Expires: March 10, 2020 R. Tamir Nexar Inc. A. Rodriguez-Natal F. Maino Cisco Systems A. Cabellos-Aparicio J. Paillissé Vilanova Technical University of Catalonia D. Farinacci lispers.net October 10, 2019 Network-Hexagons: H3-LISP Based Mobility Network draft-barkai-lisp-nexagon-11 Abstract This document specifies combined use of H3 and LISP for mobility-networks: - Enabling real-time tile by tile indexed annotation of public roads - For sharing: hazards, blockages, conditions, maintenance, furniture.. - Between MobilityClients producing-consuming road geo-state information - Using addressable grid of channels of physical world state representation Status of This Memo This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79. Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet- Drafts is at https://datatracker.ietf.org/drafts/current/. Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress." This Internet-Draft will expire on October 4, 2019. Copyright Notice Copyright (c) 2019 IETF Trust and the persons identified as the document authors. All rights reserved. This document is subject to BCP 78 and the IETF Trust’s Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document.
    [Show full text]
  • Bringing GNU Emacs to Native Code
    Bringing GNU Emacs to Native Code Andrea Corallo Luca Nassi Nicola Manca [email protected] [email protected] [email protected] CNR-SPIN Genoa, Italy ABSTRACT such a long-standing project. Although this makes it didactic, some Emacs Lisp (Elisp) is the Lisp dialect used by the Emacs text editor limitations prevent the current implementation of Emacs Lisp to family. GNU Emacs can currently execute Elisp code either inter- be appealing for broader use. In this context, performance issues preted or byte-interpreted after it has been compiled to byte-code. represent the main bottleneck, which can be broken down in three In this work we discuss the implementation of an optimizing com- main sub-problems: piler approach for Elisp targeting native code. The native compiler • lack of true multi-threading support, employs the byte-compiler’s internal representation as input and • garbage collection speed, exploits libgccjit to achieve code generation using the GNU Com- • code execution speed. piler Collection (GCC) infrastructure. Generated executables are From now on we will focus on the last of these issues, which con- stored as binary files and can be loaded and unloaded dynamically. stitutes the topic of this work. Most of the functionality of the compiler is written in Elisp itself, The current implementation traditionally approaches the prob- including several optimization passes, paired with a C back-end lem of code execution speed in two ways: to interface with the GNU Emacs core and libgccjit. Though still a work in progress, our implementation is able to bootstrap a func- • Implementing a large number of performance-sensitive prim- tional Emacs and compile all lexically scoped Elisp files, including itive functions (also known as subr) in C.
    [Show full text]
  • Common Lispworks User Guide
    LispWorks® for the Windows® Operating System Common LispWorks User Guide Version 5.1 Copyright and Trademarks Common LispWorks User Guide (Windows version) Version 5.1 February 2008 Copyright © 2008 by LispWorks Ltd. All Rights Reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by any means, electronic, mechanical, photocopying, recording, or otherwise, without the prior written permission of LispWorks Ltd. The information in this publication is provided for information only, is subject to change without notice, and should not be construed as a commitment by LispWorks Ltd. LispWorks Ltd assumes no responsibility or liability for any errors or inaccuracies that may appear in this publication. The software described in this book is furnished under license and may only be used or copied in accordance with the terms of that license. LispWorks and KnowledgeWorks are registered trademarks of LispWorks Ltd. Adobe and PostScript are registered trademarks of Adobe Systems Incorporated. Other brand or product names are the registered trade- marks or trademarks of their respective holders. The code for walker.lisp and compute-combination-points is excerpted with permission from PCL, Copyright © 1985, 1986, 1987, 1988 Xerox Corporation. The XP Pretty Printer bears the following copyright notice, which applies to the parts of LispWorks derived therefrom: Copyright © 1989 by the Massachusetts Institute of Technology, Cambridge, Massachusetts. Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, pro- vided that this copyright and permission notice appear in all copies and supporting documentation, and that the name of M.I.T.
    [Show full text]
  • Towards a Portable and Mobile Scheme Interpreter
    Towards a Portable and Mobile Scheme Interpreter Adrien Pi´erard Marc Feeley Universit´eParis 6 Universit´ede Montr´eal [email protected] [email protected] Abstract guage. Because Mobit implements R4RS Scheme [6], we must also The transfer of program data between the nodes of a distributed address the serialization of continuations. Our main contribution is system is a fundamental operation. It usually requires some form the demonstration of how this can be done while preserving the in- of data serialization. For a functional language such as Scheme it is terpreter’s maintainability and with local changes to the original in- clearly desirable to also allow the unrestricted transfer of functions terpreter’s structure, mainly through the use of unhygienic macros. between nodes. With the goal of developing a portable implemen- We start by giving an overview of the pertinent features of the tation of the Termite system we have designed the Mobit Scheme Termite dialect of Scheme. In Section 3 we explain the structure interpreter which supports unrestricted serialization of Scheme ob- of the interpreter on which Mobit is based. Object serialization is jects, including procedures and continuations. Mobit is derived discussed in Section 4. Section 5 compares Mobit’s performance from an existing Scheme in Scheme fast interpreter. We demon- with other interpreters. We conclude with related and future work. strate how macros were valuable in transforming the interpreter while preserving its structure and maintainability. Our performance 2. Termite evaluation shows that the run time speed of Mobit is comparable to Termite is a Scheme adaptation of the Erlang concurrency model.
    [Show full text]
  • The Evolution of Lisp
    1 The Evolution of Lisp Guy L. Steele Jr. Richard P. Gabriel Thinking Machines Corporation Lucid, Inc. 245 First Street 707 Laurel Street Cambridge, Massachusetts 02142 Menlo Park, California 94025 Phone: (617) 234-2860 Phone: (415) 329-8400 FAX: (617) 243-4444 FAX: (415) 329-8480 E-mail: [email protected] E-mail: [email protected] Abstract Lisp is the world’s greatest programming language—or so its proponents think. The structure of Lisp makes it easy to extend the language or even to implement entirely new dialects without starting from scratch. Overall, the evolution of Lisp has been guided more by institutional rivalry, one-upsmanship, and the glee born of technical cleverness that is characteristic of the “hacker culture” than by sober assessments of technical requirements. Nevertheless this process has eventually produced both an industrial- strength programming language, messy but powerful, and a technically pure dialect, small but powerful, that is suitable for use by programming-language theoreticians. We pick up where McCarthy’s paper in the first HOPL conference left off. We trace the development chronologically from the era of the PDP-6, through the heyday of Interlisp and MacLisp, past the ascension and decline of special purpose Lisp machines, to the present era of standardization activities. We then examine the technical evolution of a few representative language features, including both some notable successes and some notable failures, that illuminate design issues that distinguish Lisp from other programming languages. We also discuss the use of Lisp as a laboratory for designing other programming languages. We conclude with some reflections on the forces that have driven the evolution of Lisp.
    [Show full text]
  • Balancing the Eulisp Metaobject Protocol
    Balancing the EuLisp Metaob ject Proto col x y x z Harry Bretthauer and Harley Davis and Jurgen Kopp and Keith Playford x German National Research Center for Computer Science GMD PO Box W Sankt Augustin FRG y ILOG SA avenue Gallieni Gentilly France z Department of Mathematical Sciences University of Bath Bath BA AY UK techniques which can b e used to solve them Op en questions Abstract and unsolved problems are presented to direct future work The challenge for the metaob ject proto col designer is to bal One of the main problems is to nd a b etter balance ance the conicting demands of eciency simplicity and b etween expressiveness and ease of use on the one hand extensibili ty It is imp ossible to know all desired extensions and eciency on the other in advance some of them will require greater functionality Since the authors of this pap er and other memb ers while others require greater eciency In addition the pro of the EuLisp committee have b een engaged in the design to col itself must b e suciently simple that it can b e fully and implementation of an ob ject system with a metaob ject do cumented and understo o d by those who need to use it proto col for EuLisp Padget and Nuyens intended This pap er presents a metaob ject proto col for EuLisp to correct some of the p erceived aws in CLOS to sim which provides expressiveness by a multileveled proto col plify it without losing any of its p ower and to provide the and achieves eciency by static semantics for predened means to more easily implement it eciently The current metaob
    [Show full text]
  • Allegro CL User Guide
    Allegro CL User Guide Volume 1 (of 2) version 4.3 March, 1996 Copyright and other notices: This is revision 6 of this manual. This manual has Franz Inc. document number D-U-00-000-01-60320-1-6. Copyright 1985-1996 by Franz Inc. All rights reserved. No part of this pub- lication may be reproduced, stored in a retrieval system, or transmitted, in any form or by any means electronic, mechanical, by photocopying or recording, or otherwise, without the prior and explicit written permission of Franz incorpo- rated. Restricted rights legend: Use, duplication, and disclosure by the United States Government are subject to Restricted Rights for Commercial Software devel- oped at private expense as specified in DOD FAR 52.227-7013 (c) (1) (ii). Allegro CL and Allegro Composer are registered trademarks of Franz Inc. Allegro Common Windows, Allegro Presto, Allegro Runtime, and Allegro Matrix are trademarks of Franz inc. Unix is a trademark of AT&T. The Allegro CL software as provided may contain material copyright Xerox Corp. and the Open Systems Foundation. All such material is used and distrib- uted with permission. Other, uncopyrighted material originally developed at MIT and at CMU is also included. Appendix B is a reproduction of chapters 5 and 6 of The Art of the Metaobject Protocol by G. Kiczales, J. des Rivieres, and D. Bobrow. All this material is used with permission and we thank the authors and their publishers for letting us reproduce their material. Contents Volume 1 Preface 1 Introduction 1.1 The language 1-1 1.2 History 1-1 1.3 Format
    [Show full text]
  • Attachment A
    Board of Governors, State University System of Florida Request to Offer a New Degree Program (Please do not revise this proposal format without prior approval from Board staff) University of West Florida Fall 2018 University Submitting Proposal Proposed Implementation Term Hal Marcus College of Science and Engineering Computer Science Name of College(s) or School(s) Name of Department(s)/ Division(s) Bachelor of Science in Computer Computer Science Science Academic Specialty or Field Complete Name of Degree 11.0701 Proposed CIP Code The submission of this proposal constitutes a commitment by the university that, if the proposal is approved, the necessary financial resources and the criteria for establishing new programs have been met prior to the initiation of the program. Date Approved by the University Board of President Date Trustees Signature of Chair, Board of Date Provost and Senior Vice Date Trustees President Provide headcount (HC) and full-time equivalent (FTE) student estimates of majors for Years 1 through 5. HC and FTE estimates should be identical to those in Table 1 in Appendix A. Indicate the program costs for the first and the fifth years of implementation as shown in the appropriate columns in Table 2 in Appendix A. Calculate an Educational and General (E&G) cost per FTE for Years 1 and 5 (Total E&G divided by FTE). Projected Implementation Projected Program Costs Enrollment Timeframe (From Table 2) (From Table 1) E&G Contract E&G Auxiliary Total HC FTE Cost per & Grants Funds Funds Cost FTE Funds Year 1 150 96.87 3,241 313,960 0 0 313,960 Year 2 150 96.87 Year 3 160 103.33 Year 4 160 103.33 Year 5 170 109.79 3,426 376,087 0 0 376,087 1 Note: This outline and the questions pertaining to each section must be reproduced within the body of the proposal to ensure that all sections have been satisfactorily addressed.
    [Show full text]
  • Wisp: Whitespace to Lisp
    wisp: Whitespace to Lisp Dr. Arne Babenhauserheide <2013-03-26 Di> » I love the syntax of Python, but crave the simplicity and power of Lisp.« display "Hello World!" 7! (display "Hello World!") define : factorial n (define (factorial n) if : zero? n 7! (if (zero? n) . 1 1 * n : factorial {n - 1} (* n (factorial {n - 1})))) Wisp basics • Wisp turns indentation into lisp expressions. • Why Wisp? • Get it – from its Mercurial repository: hg clone https://hg.sr.ht/~arnebab/wisp – Or via GNU Guix: guix install guile guile-wisp – Or via the package guile-wisp-hg for Arch Linux. – Or via ./configure; make install from the releases. • See more examples and tests. 1 »ArneBab’s alternate sexp syntax is best I’ve seen; pythonesque, hides parens but keeps power« — Christopher Webber in twitter, in identi.ca and in their blog: Wisp: Lisp, minus the parentheses ~ wow ~ »Wisp allows people to see code how Lispers perceive it. Its structure becomes apparent.« — Ricardo Wurmus in IRC, paraphrasing the wisp statement from his talk at FOSDEM 2019 about Guix for reproducible science in HPC. ^¨ Yay! ^¨ with (open-file "with.w" "r") as port format #t "~a\n" : read port Familiar with-statement in 25 lines. 2 ↓ skip updates and releases ↓ Update (2021-05-21): If you use GNU Guix, you can get an instant wisp shell with a single command: guix environment --ad-hoc guile guile-wisp -- wisp That’s the guix wisp insta-REPL ^¨ $ guix environment --ad-hoc guile guile-wisp -- wisp GNU Guile 3.0.7 Copyright (C) 1995-2021 Free Software Foundation, Inc.
    [Show full text]
  • The Circle Meta-Model
    Document:P2062R0 Revises: (original) Date: 01-11-2020 Audience: SG7 Authors: Wyatt Childers ([email protected]) ​ ​ Andrew Sutton ([email protected]) ​ ​ Faisal Vali ([email protected]) Daveed Vandevoorde ([email protected]) The Circle Meta-model Introduction During the November 2019 meeting in Belfast, some of the SG7 participants enthusiastically mentioned Circle1 as providing a more intuitive compile-time programming model and suggested that SG7 investigate overhauling the de-facto SG7 approach (P1240+P17332) to follow Circle's ​ ​ ​ general approach (to reflection and metaprogramming). This paper describes a framework for understanding metaprogramming systems and provides a high-level overview of some of Circle's main characteristics, contrasting them to P1240's ​ ​ approach augmented with an injection mechanism along the lines of P1717. ​ ​ While we appreciate some of Circle’s powerful capabilities, we also raise some concerns with its underlying model and provide arguments in support of P1240’s choices as being a more ​ ​ suitable fit for C++’s evolution. The Dimensions of Reflective Programming In P0633, we identified three “dimensions” of compile-time reflective metaprogramming: ​ ​ 1. Control: How are compile-time computations effected/interpreted? What are metaprograms? 2. Reflection: How are source constructs are made available as data for use in metaprograms? 3. Synthesis: How can “code” be generated from a programmatic representation? 1 https://www.circle-lang.org/ Circle is an impressive project: Sean Baxter developed a brand new ​ ​ C++17-like front end on top of LLVM, incorporating a variety of new compile-time capabilities that align closely with SG7's goals. For Sean’s motivations, see https://github.com/seanbaxter/circle/blob/master/examples/README.md#why-i-wrote-circle.
    [Show full text]
  • Comparative Studies of Programming Languages; Course Lecture Notes
    Comparative Studies of Programming Languages, COMP6411 Lecture Notes, Revision 1.9 Joey Paquet Serguei A. Mokhov (Eds.) August 5, 2010 arXiv:1007.2123v6 [cs.PL] 4 Aug 2010 2 Preface Lecture notes for the Comparative Studies of Programming Languages course, COMP6411, taught at the Department of Computer Science and Software Engineering, Faculty of Engineering and Computer Science, Concordia University, Montreal, QC, Canada. These notes include a compiled book of primarily related articles from the Wikipedia, the Free Encyclopedia [24], as well as Comparative Programming Languages book [7] and other resources, including our own. The original notes were compiled by Dr. Paquet [14] 3 4 Contents 1 Brief History and Genealogy of Programming Languages 7 1.1 Introduction . 7 1.1.1 Subreferences . 7 1.2 History . 7 1.2.1 Pre-computer era . 7 1.2.2 Subreferences . 8 1.2.3 Early computer era . 8 1.2.4 Subreferences . 8 1.2.5 Modern/Structured programming languages . 9 1.3 References . 19 2 Programming Paradigms 21 2.1 Introduction . 21 2.2 History . 21 2.2.1 Low-level: binary, assembly . 21 2.2.2 Procedural programming . 22 2.2.3 Object-oriented programming . 23 2.2.4 Declarative programming . 27 3 Program Evaluation 33 3.1 Program analysis and translation phases . 33 3.1.1 Front end . 33 3.1.2 Back end . 34 3.2 Compilation vs. interpretation . 34 3.2.1 Compilation . 34 3.2.2 Interpretation . 36 3.2.3 Subreferences . 37 3.3 Type System . 38 3.3.1 Type checking . 38 3.4 Memory management .
    [Show full text]
  • ITC - Loc/ID Separation SIG Report 2014
    ITC - Loc/ID Separation SIG Report 2014 In the framework of ITC Special Interest Groups activities, the Locator/ID Separation SIG has been created in 2012, aiming at gathering and disseminating activities about the Locator/ Identifier Separation paradigm. The paradigm is instantiated in LISP (Locator/Identifier Separation Protocol) and the highlights of 2013/2014 activities concern the advances in the IETF LISP WG, the evolution of the OpenLISP implementation, and the growth of the LISP Beta Network. The LISP WG at the IETF, in the last year, has worked in order to complete the milestones in its charter. The WG gave priority to the document aiming at describing the overall LISP architecture to newbies (draft-ietf-lisp-introduction). The document was lingering without real progress, until mid-2014, when new editors have been assigned to carry on the work. As of November 2014, the document just went over Working Group Last Call, which makes it ready to be forwarded to the IESG (Internet Engineering Steering Group) for evaluation and publication. Another main work item has been the request to IANA (Internet Assigned Numbers Authority) of an IPv6 address space reserved for LISP. Such work has been split in two documents, a first one - draft-ietf-lisp-eid-block - just simply requesting to IANA to reserve the addressing space for experimental purposes for at least 3 years; a second one - draft-ietf-lisp-eid-block-mgmnt - providing policy guidelines on how such dressing space has to be administered. The first document already went through Working Group Last Call and is now waiting the second document in order to move together forward to the IESG.
    [Show full text]