Proposal for a Working Group on Programming Language Design We ...

6 downloads 485 Views 464KB Size Report
We have organized a group to discuss programming language design and propose to .... and have been proposed for inclusio

Proposal for a Working Group on Programming Language Design We have organized a group to discuss programming language design and propose to become an IFIP TC2 working group. While the theory and implementation of programming languages are both well developed fields with strong institutions, there is currently less acknowledgement and support for work on the design of programming languages. We take the position that programming languages are not just a notation for instructing a computer — they are a medium for expressing the structure and intention of software and communicating these to other programmers. Thus human factors must weigh heavily in language design decisions, requiring a well-judged balance between conflicting goals that are qualitative in nature. Other fields, like Architecture, call such balancing acts Design, with a capital D, and recognize this activity as a practice with its own methodologies, distinct from both science and engineering. Ivan Chermayeff wrote "Design is directed toward human beings. To design is to solve human problems by identifying them and executing the best solution." Steve Jobs wrote: "In most people's vocabularies, design means veneer. It's interior decorating. It's the fabric of the curtains or the sofa. But to me, nothing could be further from the meaning of design. Design is the fundamental soul of a human-made creation." We feel that this notion of design captures the essential difficulty of creating useful programming languages. Design issues are what programming language developers argue about amongst themselves. We have formed a working group of experts active in programming language research and development that is focused on discussion at the design level. Our reason for forming a new group is that there is no existing venue that brings together experts to exchange and refine new ideas in programming language design. Computer science conferences no longer serve this role, because they are dedicated to the presentation of contributions that have been rigorously evaluated. While such conferences serve a crucial role in scientific progress, they tend to filter out discussion of early stage ideas as well as design issues that are qualitative in nature. Neither do they facilitate conversations on open problems and emerging issues. We note that some of the landmark papers on language design could not be published today: Liskov on data abstraction, Parnas on modules, or Landin on the next 700 languages. These papers consisted of informal but carefully reasoned arguments for the power of a new idea. These ideas were communicated promptly and triggered vibrant debates. We seek a venue that cultivates such ideas, arguments, and debates in a concentrated setting with a cohesive group of researchers and developers. We have chosen to propose a new TC2 working group for two reasons. First, TC2 working groups are a proven model that has provided great benefit to our field, and indeed to some of

us who are members of existing groups. Secondly, we feel that our charter complements the existing range of working groups. Groups such as WG 2.4 (Software Implementation Languages) and WG 2.8 (Functional Programming) specialize in specific kinds of programming languages. We believe it is vital to also have a forum that cross-fertilizes perspectives from the entire spectrum of programming language paradigms and communities, and that the lack of such communication has led in the past to wasteful intellectual duplication. Our initial membership already represents OO (static, dynamic, and Scandinavian), FP, distributed, parallel, LISP family, Java, C#, JavaScript. We intend to deepen and broaden this coverage as we fill out the initial membership. WG 2.1 (Algorithmic Languages and Calculi) covers all programming languages, focusing on their formal aspects. In so doing they necessarily de-emphasize discussion of informal and qualitative design issues. We believe that sound theory is a necessary foundation for successful design work. Conversely, we would welcome the opportunity to bring emerging topics to the attention of WG 2.1 when there is a need for more formal investigation of a significant new idea. We might play an opposite role with WG 2.3 (Programming Methodology), designing language features in support of their methodological proposals. In this sense, we fill the gap between WG 2.1 and WG 2.3. In sum, while our group overlaps to some extent with the subject areas of existing working groups, we differ more on an orthogonal axis, that of method. Our focus on design tempers the methods of mathematics and engineering with an appreciation of the pervasive influence of human factors throughout the act of programming. We feel the need to shift the discourse in this direction in order to progress as programming language researchers and developers. We further hope that this also is a step towards bridging the unfortunate chasm between industry and academic computer science. The charter of TC2 is “Software: Theory and Practice”. We respectfully submit that our group would help TC2 more completely fulfill that charter. Our inaugural meeting was held June 1-3 2011 preceding PLDI, hosted by Google in Mountain View CA USA. A report on this meeting is attached. To summarize, we left the meeting with a consensus that it was a uniquely valuable experience and with the intention to proceed in formalizing the group, our first choice being an IFIP TC2 working group. The next meeting will be in the Summer of 2012, either at Imperial College in London or colocated with ECOOP in Beijing. Longer term, we are considering colocating on a regular basis with OOPSLA or ECOOP, and also sponsoring an associated workshop at those venues. We thank the TC2 committee for entertaining this proposal and look forward to discussing its merits at the upcoming annual meeting.

Mission Statement of the Working Group on Programming Language Design Aim: To explore and evaluate new ideas in programming language design. Our stance is that programming languages are foremost a medium for expressing the structure and intention of software, and communicating these to other programmers. As such human factors must weigh heavily in language design decisions, requiring a well-judged balance between conflicting goals that are qualitative in nature. Scope: ● ● ● ● ● ● ● ●

exploring programming paradigms and major language features, both established and novel; co-designing programming environments with such language features; articulating more clearly the problems of programming that language features are designed to address; identifying key design decisions that balance conflicting goals such as usability, expressivity, and the ability to provide tool support combining experiences and perspectives from the full spectrum of language paradigms and communities; conversing at a conceptual level that practicing language designers find useful, not restricted to mathematical formalisms or empirical hypotheses; meta-discussion of techniques for evaluating language design decisions; promulgating the appreciation of design considerations among researchers, practitioners, students, and teachers.

Founding Members Andrew P. Black, Portland State University Gilad Bracha, SAP Kim Bruce, Pomona College William Cook (Vice Chair), University of Texas at Austin Jonathan Edwards (Secretary), MIT Susan Eisenbach, Imperial College London Erik Ernst, Aarhus University Robert Bruce Findler, Northwestern University Matthew Flatt, University of Utah Dan Ingalls, SAP Cristina Lopes, University of California Irvine Jan-Willem Maessen, Google Erik Meijer, Microsoft Mark S. Miller, Google James Noble, Victoria University of Wellington Mads Torgersen, Microsoft David Ungar, IBM Research Tom Van Cutsem, Vrije Universiteit Brussel Eelco Visser (Chair), Delft University of Technology Alessandro Warth, Viewpoints Research Institute

Talks given at the inaugural meeting, June 1-3 2011 Google Mountain View David Ungar: Values, principles, and practices Jonathan Edwards: Mutable state without imperative programming John Field (visitor): Toward a declarative foundation for compositional distributed programming Mark S. Miller: Programming as planning William Cook: Ensō Mads Torgersen: Await! Taking the misery out of asynchronous programming Kim Bruce: Modularity & Visibility in Object-Oriented Languages Dan Ingalls: End-user programming William Cook: Batches: A unifying approach to remote execution, services, and database access Eelco Visser: Linguistic Abstraction for the Web Tom Van Cutsem: Communicating event-loop concurrency and distribution David Herman (visitor): The evolution of Javascript Gilad Bracha: Newspeak: a Principled Language Erik Ernst: Combination of structure and behavior as an algebra Annie Liu (visitor): Languages for Distributed Algorithms Magne Haveraaen (visitor): Large Scale Modularity James Noble: Methods of Grace Robby Findler: Matching Contexts Andrew Black: Object Constructors in Grace Jan-Willem Maessen: Library as language in Fortress Matthew Flatt: The design implications of structs in Racket Alessandro Warth: Worlds: Controlling the Scope of Side Effects

Member Profiles Prof Andrew P. Black Portland State University [email protected] Andrew Black is a Professor of Computer Science at Portland State University, and former Head of the Department of Computer Science and Engineering at the Oregon Graduate Institute, both in Oregon, USA. Prof. Black has been involved in programming language design since he started his doctoral research in 1977, and in distributed systems since 1981. He designed and implemented the Eden Programming language, which included the first objectoriented remote method invocation mechanism (RMI). RMI is the object-oriented analogue of remote procedure call (RPC). Other significant work includes Infopipes (with Walpole et at) and an Equational Theory for Transactions (with Oderksy et al). More recently, Black was one of the designers of Traits, a language extension that enable classes to be composed from smaller pieces and to viewed in multiple ways. Traits have subsequently appeared, in various forms, in commercial dialects of Smalltalk, in Java, in C#, in Scala, in Fortress and in Perl 6. Traits are supported by the Joose framework for JavaScript, and have been proposed for inclusion in PHP and ActionScript 3.0. Black has also worked on user-friendly refactoring tools. The key to this work is the recognition that rigorous empirical evaluation of any new tool is required to see if the tool actually improves programmer performance on realistic tasks. This line of research culminated in Murphy-Hill's doctoral dissertation (2009), as well as several collaborative publications. Relevant publications: Nathanael Sch ̈arli, Stéphane Ducasse, Oscar Nierstrasz, and Andrew Black. Traits: Composable units of behavior. In Proceedings ECOOP 2003 (European Conference on ObjectOriented Programming), volume 2743 of LNCS, pages 248–274. Springer Verlag, July 2003. Emerson R. Murphy-Hill, Chris Parnin, and Andrew P. Black. How we refactor, and how we know it. In ICSE, pages 287–297. IEEE, 2009. Andrew P. Black, Norman C. Hutchinson, Eric Jul, and Henry M. Levy. The development of the Emerald programming language. In Barbara G. Ryder and Brent Hailpern, editors, HOPL III: Proceedings of the third ACM SIGPLAN con- ference on History of programming languages, pages 11-1–11-51, New York, NY, USA, 2007. ACM. Personal Motivation: A programing language exists to communicate: between people and computers, but also

between people. So its design cannot be reduced to mathematics: the human element must be paramount. A sound and unambiguous semantics is necessary, but not sufficient. In the long term, a language will be proved through use. It will either develop a user community, or it will not. However, language design, like any other form of design, benefits from /rapid/ feedback: it is infeasible to apply the test of widespread adoption, or even controlled user studies, to every feature that one might consider adding to a language — still less to every combination of features! Instead we substitute experience and good taste. A community of language designers who are able and willing to share the benefits of their experience (and their opinions about taste!) is invaluable in the formative stages of a language's design. My goal in forming the working group on language design was to create just such a community.

Kim Bruce Pomona College [email protected] Kim Bruce is the Reuben C. and Eleanor Winslow Professor of Computer Science, where he was recruited to be the founding chair of the relatively new Department of Computer Science. From 1977 to 2005 he was on the faculty at Pomona College where he was also the founding chair of a new Computer Science Department and was the Frederick Latimer Wells Professor of Computer Science. Before that he was an Instructor in the Princeton University Math Department. While his degrees are all in mathematics, Bruce quickly saw the error of his ways and moved into Computer Science five years after his Ph. D. in Mathematics. His work has focused on the design and semantics of programming languages, especially object-oriented languages. Early work focused on models of the polymorphic lambda calculus, while later work was directed at type systems for object-oriented languages, with special focus on safe static type systems for languages with a “MyType” construct and generalizations. Lately he has also been pursuing research in Linguistics. Bruce also has a long-standing interest in computer science education, especially at small high quality liberal arts colleges. He was a founding member of the Liberal Arts Computer Science Consortium, contributing to each of their three model curricula for liberal arts colleges. He was also a member of the ACM-IEEE CS Joint Curriculum Task Force responsible for Curricula 1991. More recently he served as founding chair of the SIGPLAN Education Board. With colleagues at Williams College, he developed an innovative introductory course based on Java that integrates graphics, event-driven programming, and concurrency. The resulting text, “Java: An eventful approach” was published in 2005 by Prentice Hall. In 2005 he was presented the

ACM SIGCSE award for Outstanding Contributions to Computer Science Education. His work in both programming languages and education has been supported by numerous NSF grants. Bruce’s current research is on the design of Grace, an object-oriented language designed for novices. Relevant publications: Foundations of Object-Oriented Languages: Types and Semantics, MIT Press, 2002. (with J. Nathan Foster ) LOOJ: Weaving LOOM into Java, ECOOP 2004 conference proceedings, LNCS 3086, Springer-Verlag, pp. 390-414, 2004. (with Luca Cardelli and Benjamin C. Pierce ) Comparing Object Encodings, Information and Computation 155, pp. 108-133 (1999). Motivation: My motivation in participating in the Working Group on Language Design is to explore the design space of programming languages. While my own work has been with statically typed languages, I find that programmers in dynamically typed languages often develop productive styles and idioms that can be safely imported into the statically typed world. My own goal is to meld the expressiveness of dynamically typed languages with the safety and efficiency of statically typed languages. Moreover, we are entering an era where we will be hard pressed to better understand and support parallel and concurrent programming. Working with a likeminded group of researchers should be stimulating and productive in attacking these very difficult problems.

William Cook University of Texas at Austin William Cook is Associate Professor of Computer Science at The University of Texas at Austin. He was previously VP Engineering, Chief Technical Officer and founder of Allegis Corporation, and Software Architect at two smaller startups, Net-It Software and BAM! Software. He was Engineering Manager, of the AppleScript project at Apple Computer starting in 1991, and Member of Technical Staff at HP Labs from 1998 to 1991. He earned his Ph.D. Computer Science at Brown University in 1989. Prof. Cook was General Chair of SPLASH 2010, having been Research Program Committee Chair for OOPSLA in 2006. He co-organizer and was program committee chair for the First Dynamic Languages Symposium in 2006. He has served on program committees for ECOOP, TOOLS, GPCE, OOPLSA, ICFP, Coordination, CC, and POPL. He has been a member of

IFIP WG 2.3 Programming Methodology and IFIP WG 2.11 Program Generation of Technical Committee since 2009. He is a member of ACM and IEEE. Relevant publications: A. Ibrahim, Y. Jiao, E. Tilevich, and W. R. Cook. Remote batch invocation for compositional object services. In Proceedings of the European Conference on Object-Oriented Programming (ECOOP), 2009. J. Misra and W. R. Cook. Computation orchestration: A basis for wide-area computing. Journal of Software and Systems Modeling, May 2006. W. R. Cook. AppleScript. In Proceedings of the ACM SIGPLAN Conference on History of Programming Languages (HOPL III), 2007. Motivation: My motivation for participating in the Working Group on Language Design is to understand and improve the languages we use for developing software solutions, with the end goal of developing better software for the benefit of society as a whole. The last 15 years have seen an explosion in experimentation in software languages, driven by the advent of the internet and changes in hardware to multicore. While there are many specialized working groups that sometimes participate in language design (for specification, functional programming, graphics, etc) there is no working group that is focused on the issues of designing languages and integrating them together. Jonathan Edwards MIT [email protected] Jonathan Edwards was co-founder and CTO of IntraNet Inc, a leader in bank-to-bank money transfer systems. His technical work there was in high availability distributed databases specialized to complex message workflows. In modern terms, this was a document-oriented database with integrated queuing, incremental versioning, ACID transactions, and synchronous replication with hot failover. Multiple instances in the World Trade Center ran through 9/11. In 1978 he built what may have been the first user-level threads library. He is now a Research Fellow at the Computer Science and Artificial Intelligence Lab at MIT, in Daniel Jackson's software design group. Relevant publications: Jonathan Edwards. 2005. Subtext: uncovering the simplicity of programming. In Proceedings of the 20th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications (OOPSLA '05). ACM, New York, NY, USA, 505-518.

Jonathan Edwards. 2007. No ifs, ands, or buts: uncovering the simplicity of conditionals. In Proceedings of the 22nd annual ACM SIGPLAN conference on Object-oriented programming systems and applications (OOPSLA '07). ACM, New York, NY, USA, 639-658. Jonathan Edwards. 2009. Coherent reaction. In Proceeding of the 24th ACM SIGPLAN conference companion on Object oriented programming systems languages and applications (OOPSLA '09). ACM, New York, NY, USA, 925-932. Motivation: I believe that programming is a new form of intellectual expression fundamentally different from those that have come before, and that it is currently hobbled by assumptions inherited from those prior forms. I have been experimenting with the co-design of novel interactive development environments along with alternative language semantics, in order to more fully explore the potential design space. My main motivation for membership in the working group is to be challenged to substantiate my ideas to a panel of highly accomplished and insightful programming language designers. I have never before seen such a concentration of programming language talent in one room. I bring to the group a different perspective arising from reflection on my career in the software industry, which sometimes crosscuts the standard breakdown of problems in computer science. Above all, I hope to contribute to lasting progress in the practice of programming.

Susan Eisenbach Imperial College London Susan EIsenbach is Professor of Computing at Imperial College London. After being responsible for the teaching in the department for fifteen years, she is now Head of the Department of Computing there. She has worked on a wide range of programming languages and features. These range from chairing the first Modula 2 standards committee, specifying the coordination language Darwin, producing a formal semantics of a large subset of Java, modelling dynamic behavior, to her current work on concurrency constructs. Relevant publications: Jeff Magee, Naranker Dulay, Susan Eisenbach, and Jeff Kramer. Specifying Distributed Software Architectures. In W. Schafer and P. Botella, editors, Proc. 5th European Software Engineering Conf. (ESEC 95), volume 989, pages 137–153, Sitges, Spain, 1995. Sophia Drossopoulou and Susan Eisenbach. Java is Type Safe — Probably. In 11th European Conference on Object Oriented Programming (ECOOP’97), volume 1241 of LNCS, pages 389– 418. Springer- Verlag, June 1997.

Sophia Drossopoulou, Susan Eisenbach, and David Wragg. A Fragment Calculus - towards a Model of Separate Compilation, Linking and Binary Compatibility. In 14th Symposium on Logic in Computer Science (LICS’99), pages 147–156. IEEE, July 1999.

Motivation for membership: I have a personal mission to produce the highest quality programmers. I have taught introductory programming for over thirty years, in nine languages and four programming paradigms. I believe that there is a strong correlation between the design of the programming language and the ease of production of high quality software. Critical to good design is the existence of appropriate constructs for modelling the problem domain. Today’s dynamic environment, with massively distributed, multi-core machines, provides many exciting challenges to what the new languages should be. I would like to be part of a working group that tackles these challenges.

Erik Ernst Aarhus University [email protected][email protected] Erik Ernst is an associate professor of computer science at Aarhus University, Denmark. He has been working on programming language design starting with his doctoral research in the late 90'ies, grounded in the Scandinavian tradition of object-oriented languages that started with the first OO language Simula in the 60'ies and continued with the language BETA in the 70'ies. He created the language gbeta, which is a deep generalization of BETA that introduced several new language concepts. In particular, this language supports propagating combination (aka deep mixin composition) whereby combination of classes and methods propagates recursively into the block structure; family polymorphism, which enables a simple variant of dependent types (aka path dependent types) to ensure static type safety for collaboration of instances of mutually dependent classes without imposing static dependencies on clients about the exact choice of class family; and higher-order hierarchies, which enable entire class hierarchies to derive other class hierarchies, based on virtual classes that are related to each other by programmer-specified subclass constraints which are solved automatically in the semantics of the language. Some of the ideas associated with virtual classes reached the mainstream when the Java

programming language J2SE 5 was extended with wildcards, and Ernst took part in the project involving Sun Microsystems, Inc., and Aarhus University where this extension to Java was designed and implemented. Ernst also took part in research where the formal foundations for wildcards were built. Recently, Ernst's research has included a number of formalizations with fully mechanized proofs, e.g., contributing to the search for clear and general foundations of aspect-orientation. In 2010, Ernst received the Dahl-Nygaard junior prize because he 'greatly contributed to bridging the gap between the Scandinavian and the rest of the OO community'. Relevant publications: Erik Ernst. Family polymorphism. In Proceedings ECOOP 2001, volume 2072 of LNCS, pages 303-326. Springer-Verlag, 2001. Erik Ernst. Higher-Order Hierarchies. In Proceedings ECOOP 2003, volume 2743 of LNCS, pages 303-329. Springer-Verlag, 2003. Nicholas Cameron, Sophia Drossopoulou, and Erik Ernst. A Model for Java with Wildcards. In Proceedings of ECOOP 2008, volume 5142 of LNCS, pages 2-26. Springer-Verlag, 2008. Personal Motivation: Programming languages are fascinating and wonderfully powerful beasts requiring a delicate balance in a bewildering plethora of dimensions. Human perception and thinking plays a crucial role here. Language design must enable programs to fit smoothly into the brains of human beings---whose patterns of thinking may even be significantly shaped by years of daily work constructing complex computerized systems, such that language design must also overcome blind spots created by the preference for familiarity. At the same time, it must be possible to implement a programming language under the constraint that compilation (if applicable) and program execution can be achieved without spending excessive amounts of resources. On the contrary, a generous amount of resources should be spent on incisive analyses of proposed language designs, in order to resolve ambiguities and ferret out mistakes. Techniques based on mathematical models, including mechanized reasoning about them, is an extremely powerful tool to this end.

At this point it is probably no secret that I care deeply about programming language design. I have had the pleasure to discover that I share this passion with the other members of this working group, and also that this group of people constitutes an inspiring environment for language design discussions which is very rare. That's my personal motivation.

Robert Bruce Findler Associate Professor Northwestern University [email protected] Biography: Findler is the primary maintainer of DrRacket, a program development environment for programming languages in the Racket ecosystem. Racket and DrRacket are downloaded about 300 times a day. Findler has written two books: How to Design Programs, an introductory programming textbook and Semantics Engineering with PLT Redex, an overview of operational semantics with an emphasis on building and maintaining them. Both are published by MIT Press. Findler received his PhD from Matthias Felleisen at Rice University in 2002. He joined the faculty at the University of Chicago shortly thereafter and in 2009 joined the faculty at Northwestern University. Relevant Publications: Slideshow: Functional Presentations. Findler, Flatt. International Conference on Functional Programming (ICFP) 224-235 2004 Kill-Safe Synchronization Abstractions. Flatt, Findler. Programming Language Design and Implementation (PLDI) 47-58 2004 A Visual Environment for Developing Context-Sensitive Term Rewriting Systems Matthews. Findler, Flatt, Felleisen. International Conference on Rewriting Techniques and Applications (RTA) 301-312 2004 Interest Statement:

I am interested in giving programmers better abstractions to express computation by providing an extensible base language and extensible program development environment that they can exploit to build domain-specific languages. To understand how to do this effectively, I need to understand how to effectively design programming languages and their development environments and then turn that knowledge into tools to support the design process. This working group provides a unique opportunity to supplement my own experience building languages and learn from others.

Matthew Flatt University of Utah Matthew Flatt is an associate professor of computer science at the University of Utah. He is one of the main developers of the Racket programming language and a co-author of the introductory programming textbook "How to Design Programs". Matthew received his PhD in computer science from Rice University in 1999, and he joined Utah immediately afterward. Relevant publications: "Languages as Libraries". Sam Tobin-Hochstadt, Vincent St-Amour, Ryan Culpepper, Matthew Flatt, and Matthias Felleisen. PLDI 2011. "Scribble: Closing the Book on Ad Hoc Documentation Tools". Matthew Flatt, Eli Barzilay, and Robert Bruce Findler. ICFP 2009. "Adding Delimited and Composable Control to a Production Programming Environment". Matthew Flatt, Gang Yu, Robert Bruce Findler, and Matthias Felleisen. ICFP 2007. Motivation for membership: My work spans the design of extensible programming languages, languages that incorporate operating-system concepts (such as processes), and languages that enforce abstraction boundaries while allowing the line between operating system, programming language, library, and application to move more fluidly. The working group provides a unique environment for discussing design issues that span programming layers and for reassessing the current established divide between layers.

Jan-Willem Maessen

Software Engineer, Google [email protected] Jan-Willem Maessen is a Software Engineer at Google in Cambridge, MA. He was part of Project Fortress from its inception in 2003 until 2010, and acted as primary maintainer of the libraries for the Fortress programming language. He was heavily involved in the design of the Fortress language and in its implementation, and drafted the original specifications of the parallel portions of the language. Prior to joining Sun, Jan developed Eager Haskell, a Haskell implementation that executes programs using resource-bounded eager evaluation rather than lazy evaluation. He also contributed heavily to the compiler, libraries, and run-time system for pH, an implicitly-parallel programming language based on Haskell. His many interests include language design, memory consistency models, concurrent algorithms, compilation, semantics, and architecture. Three key publications relevant to the WG: “pH Language Reference Manual, Version 1.0”. R.S. Nikhil, Arvind, J. Hicks, S. Aditya, L. Augustsson, J. Maessen and Y. Zhou. CSG Memo 369, Jan 1995. memos/Memo-369/memo-369.pdf “Eager Haskell: Resource-bounded execution yields efficient iteration”. Jan-Willem Maessen. Proc. Haskell Workshop, Pittsburgh, PA, Oct 2002. id=581694 “Fortress Language Specification, v.1.0”. Eric E. Allen, David Chase, Joseph Hallett, Victor Luchangco, Jan-Willem Maessen, Sukyoung Ryu, Guy L. Steele, Jr., and Sam Tobin-Hochstadt. Motivation for membership: Programming is an expressive exercise, and a programming language must first be read and understood by maintainers, and second be written and debugged by programmers. Our industry has learned to its cost that every language must be designed for programming in the large, for every successful language is ultimately employed to build large systems written and maintained by numerous programmers. This also means that we must design languages suited to support by tools such as IDEs, debuggers, and code indexers: tools that lighten the cognitive burden on the programmer. Finally, every successful language is ultimately defined by the libraries that are built for it; I am very interested in how the initial libraries included with a language impact its usability and coding idiom.

Mark S. Miller

Research Scientist, Google Research Mark S. Miller is the main designer of the E and Caja object-capability programming languages, inventor of Miller Columns, a pioneer of agoric (market-based secure distributed) computing, an architect of the Xanadu hypertext publishing system, and a representative to the EcmaScript (JavaScript) committee. Relevant Key Publications: “Robust Composition: Towards a Unified Approach to Access Control and Concurrency Control”, Mark S. Miller, 2006, JHU dissertation. “Institutions as Abstraction Boundaries”, Bill Tulloh, Mark S. Miller, Humane Economics: Essays in Honor of Don Lavoie, 2006, pp. 136-188. “Capability-based Financial Instruments”, Mark S. Miller, Chip Morningstar, Bill Frantz, Proc. Financial Cryptography 2000, pp. 349-378. “Markets and Computation: Agoric Open Systems”, Mark S. Miller, K. Eric Drexler, The Ecology of Computation, 1988, pp. 133-176. Motivation for membership: Programs are plans people formulate for machines to execute. A central question of programming and of economics is: How do people separately formulate plans and then compose them, such that they tend to mesh productively and with few unanticipated conflicts? My programming language, abstraction mechanism, and security designs are driven by this question, often borrowing insights from economics and observations about market organization. These considerations fall outside of conventional conversations about language design. This working group is unique in its ability to seriously explore language design issues from unconventional and inter-disciplinary perspectives.

James Noble School of Engineering and Computer Science, Victoria University of Wellington, New Zealand James Noble is Professor of Computer Science and Software Engineering at Victoria University of Wellington, New Zealand. James's research centres around software design. This includes the design of the users' interface, the parts of software that users have to deal with every day, and the programmers' interface, the internal languages, structures, and organisations of software that programmers see only when they are designing, building, or modifying software. His research in both of these areas is coloured by his longstanding interest in object-oriented

approaches to design, and topics he has studied range from aliasing and object ownership, design patterns, agile methodology, via usability, visualisation and computer music, to postmodernism and the semiotics of programming. Professor Noble has (co-)written one book, eight book chapters, 16 journal articles, 142 conference papers, 56 miscellaneous reports, and one patent. He has been awarded the Association for Computing Machinery (ACM) SIGPLAN "Most Influential OOPSLA Paper in the last 10 years" Award; the Australian Software Engineering Conference' "Most Influential Paper in the last 10 years" Award; the Neil B. Harrison Shepherding Award from the European Conference on Pattern Languages of Program Design, and a Research Excellence Award from Victoria University of Wellington, New Zealand. Professor Noble is a senior member of the ACM, and a member of the IEEE and the British and New Zealand Computer Societies.

Three key publications relevant to the WG: JavaCOP: Declarative Pluggable Types for Java. Shane Markstrum, Daniel Marino, Matthew Esquivel, Todd Millstein , Chris Andreae, James Noble. In the ACM Transactions on Programming Languages and Systems (TOPLAS) 23:2, Article 4, 2010. Scale-Free Geometry of Object-Oriented Programs. Alex Potanin, James Noble, Marcus Frean, Robert Biddle. Communications of the ACM. 48:5, 99-103, May 2005 Flexible Alias Protection. James Noble, Jan Vitek, John Potter. In Proceedings of the European Conference on Object Oriented Programming, Brussels. (ECOOP) Springer-Verlag, 1998. Personal motivation for membership of the WG: The key personal benefit I expect working group membership to provide is the informed perspective and critique provided by a highly experienced group of programming language designers --- both from academia and from industry. My major current research projects involve many aspects of programming language design: I have received significant useful feedback from the single meeting of the working group so far, and expect to alter the direction of at least one project based on that feedback. I expect my membership of the working group would also have many benefits for my colleagues working on programming language research throughout New Zealand. As a relatively small country, distant from the centres of scientific endeavour, participation in IFIP working groups (and other international scientific organisations in all fields) is crucial for maintaining best practice in research in New Zealand. The key contribution I can bring to the working group is a relatively broad background in Computer Science, ranging from the fine details of programming language design, to the design

patterns that are used when applying programming languages to design problems, to the programming techniques and tools required in agile software development teams. My expertise includes perspectives developed using research methodologies that are not generally applied to programming language design, including semiotics, corpus analysis, and grounded theory.

Mads Torgersen Microsoft Corporation [email protected] Mads Torgersen is a Principal Program Manager at Microsoft. For six years he has been responsible for the design process for the C# programming language, and has contributed significantly to the feature sets of versions 3.0, 4.0 and 5.0. Mads has also been part of the design efforts for Visual Basic, F# and other programming languages at Microsoft, plus several .NET APIs such as Language Integrated Query (LINQ), the Dynamic Language Runtime (DLR) and the Task-based Asynchronous Pattern. Before joining Microsoft Mads was an Associate Professor at the Computer Science Department of the University of Aarhus, where among other things he contributed to Java generics. In particular Mads led the group which implemented Generic Wildcards in Sun's Java compiler for Java 5.0. Three key publications relevant to the WG: Anders Hejlsberg, Mads Torgersen, Scott Wiltamuth, Peter Golde: The C# Programming Language,Fourth Edition. Addison-Wesley (2010) Gavin M. Bierman, Erik Meijer, Mads Torgersen: Adding Dynamic Types to C#. ECOOP 2010: 76-100 Mads Torgersen, Erik Ernst, Christian Plesner Hansen, Peter von der Ahé, Gilad Bracha, Neal M. Gafter: Adding Wildcards to the Java Programming Language. Journal of Object Technology 3(11): 97-116 (2004) Personal motivation for membership of the WG: Evolving a major industrial programming language requires broad input from language users as well as designers. This working group facilitates interaction with some of the foremost language designers in the world, and helps cross-pollinate between deep research and industrial innovation in the space.

David Ungar

IBM Research David Ungar is an out-of-the-box thinker who enjoys the challenge of building a computer software system that works like magic and fits a user's mind like a glove. His experience lies in the design and construction of virtual machines for object-oriented languages, the design of dynamic object-oriented languages, object-oriented programming, the design of programming environments, and prototype-based languages. Now, he is investigating nondeterministic programming paradigms for harnessing the massive parallelism of manycore processors. His inventions have contributed materially to the field of object-oriented language, virtual machines, programming environments, and user interfaces. Three of his papers have been honored by the Association for Computing Machinery for lasting impact over ten to twenty-four years. He received the 2009 Dahl-Nygaard award for outstanding career contributions in the field of object-orientation and is an ACM Fellow. Three Relevant Publications: Generation Scavenging: A Non-Disruptive High Performance Storage Reclamation Algorithm, ACM SIGSOFT/SIGPLAN Software Engineering Symposium on Practical Software Development Environments, 1984. ACM SIG-SOFT Retrospective Impact Paper Award, 2008. Reconciling Responsiveness with Performance in Pure Object-Oriented Languages, with U. Hölzle. TOPLAS 18, 4 (July 1996). SELF: The Power of Simplicity, with R. B. Smith. OOPSLA’87. A Most Influential Paper Award, ACM OOPSLA 1986-1996.

Tom Van Cutsem Vrije Universiteit Brussel Tom Van Cutsem is assistant professor and post-doctoral researcher at the Software Languages Lab of the Vrije Universiteit Brussel (VUB), Belgium. He received his PhD in 2008 from the same University on the topic of ambient-oriented programming, a concurrent and distributed programming paradigm for mobile ad hoc networks. He is one of the lead designers of the AmbientTalk programming language. His broad research interests include concurrent and distributed models and languages, parallel programming, computational reflection, metaprogramming and object composition abstractions. In 2010, Tom spent six months at Google in Mountain View, USA as a Visiting Faculty member, where he collaborated closely with Dr. Mark S. Miller on novel features for the Javascript language, such as a new meta-programming API and a trait composition library. Tom currently

serves on the ECMA standardization committee for ECMAScript and is actively involved in the formation of the next edition of the language. Relevant key publications: Tom Van Cutsem, Mark S. Miller. Proxies: Design Principles for Robust Object-oriented Intercession APIs. In proceedings of the ACM SIGPLAN Dynamic Languages Symposium (DLS 2010) (Reno, Nevada, USA, Oct. 2010), Will Clinger (Ed.), pp. 59-72, ACM, NY. Acceptance rate: 28%. Tom Van Cutsem, Alexandre Bergel, Stéphane Ducasse, Wolfgang De Meuter. Adding State and Visibility Control to Traits using Lexical Nesting. In proceedings of the 23rd European Conference on Object-oriented Programming (ECOOP), (Genova, Italy, July 2009). Sophia Drossopoulou (Ed.), LNCS Vol. 5653, pp. 220-243, Springer-Verlag. Acceptance rate: 21%. Jessie Dedecker, Tom Van Cutsem, Stijn Mostinckx, Theo D'Hondt, Wolfgang De Meuter. Ambient-oriented Programming in AmbientTalk. In proceedings of the 20th European Conference on Object-Oriented Programming (ECOOP), (Nantes, France, July 2006). Dave Thomas (Ed.), LNCS Vol. 4067, pp. 230-254, Springer-Verlag. Acceptance rate: 13%. Motivation for membership: As a programming language designer I feel strongly about active participation in this Working Group. The group is composed of experts with a heterogeneous and complementary background. Each member has first-hand experience in designing and/or implementing a programming language, and as such is very much aware of both the formal foundations as well as the human aspects involved in this activity. I feel this group is unique in that it approaches programming languages as interfaces designed for humans rather than exclusively concentrating on the mathematical foundations (which is not to say that the latter are in any way unimportant). Finally, a large portion of the Working Group has expertise in language design for concurrent, parallel and distributed programming, an area that has arguably gained in importance during the last decade, and also an area where I believe radical new ideas and design thinking are required to make progress on a number of hard challenges.

Eelco Visser Associate Professor Delft University of Technology Eelco Visser is Associate Professor at Delft University of Technology. He received a masters and doctorate in computer science from the University of Amsterdam in 1993 and 1997, respectively. Previously he served as postdoc at the Oregon Graduate Institute, and as Assistant Professor at Utrecht University. He is member of the ACM (SIGPLAN) and the IEEE Computer Society.

His research interests include software language engineering, domain-specific languages, model-driven engineering, program transformation, software deployment, interaction design, and digital libraries. With his students he has designed and implemented the Spoofax language workbench, as well as many domain-specific languages, including DSLs for syntax definition (SDF), program transformation (Stratego), software deployment (Nix), web application development (WebDSL), and mobile phone applications (mobl). He is the main developer of the researchr bibliography management system. Relevant Key Publications: Lennart C. L. Kats, Eelco Visser. The Spoofax language workbench: rules for declarative specification of languages and IDEs. In William R. Cook, Siobhán Clarke,Martin C. Rinard, editors, Proceedings of the 25th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2010, October 17-21, 2010, Reno/Tahoe, Nevada, USA. pages 444-463, ACM, Reno/Tahoe, Nevada, 2010. Eelco Visser. WebDSL: A Case Study in Domain-Specific Language Engineering. In Ralf Lämmel, Joost Visser, João Saraiva, editors, Generative and Transformational Techniques in Software Engineering II, International Summer School, GTTSE 2007.Volume 5235 of Lecture Notes in Computer Science, pages 291-373, Springer, Braga, Portugal, 2007. Martin Bravenboer, Eelco Visser. Concrete syntax for objects: domain-specific language embedding and assimilation without restrictions. In John M. Vlissides,Douglas C. Schmidt, editors, Proceedings of the 19th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2004. pages 365-383, ACM, Vancouver, BC, Canada, 2004. Motivation for membership: Most of my research career I have worked on tools for language design and implementation with the aim to support high-level declarative definition of languages and derivation of efficient implementations from such definitions. The main result is the Spoofax language workbench, which supports implementation of languages and their IDEs. An important part of this work has involved the design of languages for language definition (SDF, Stratego). More recently I have become interested in applying these language and tools to the design of `end-developer’ domain-specific languages. As a case study I have investigated linguistic abstractions for the domain of web programming, resulting in the WebDSL and mobl languages. The larger mission is to develop a systematic approach to the development of domain-specific languages. This working group is the ideal forum for this investigation; I see many opportunities for collaboration.

Alessandro Warth Viewpoints Research Institute Alessandro (Alex) Warth is a researcher at the Viewpoints Research Institute, where he is one of the key contributors to the NSF-funded "Steps Toward the Reinvention of Programming" project, led by Alan Kay. He is the creator of OMeta, a language that makes it easier for researchers to prototype new programming languages and extensions to existing languages. Alex earned his Ph.D. in computer science from UCLA in 2008. Three key publications relevant to the WG: Worlds: Controlling the Scope of Side Effects. Alessandro Warth, Yoshiki Ohshima, Ted Kaehler, and Alan Kay. In Proceedings of the European Conference on Object Oriented Programming (ECOOP), 2011. OMeta: an Object-Oriented Language for Pattern-Matching. Alessandro Warth and Ian Piumarta. In the Dynamic Languages Symposium (DLS), 2007. Statically Scoped Object Adaptation with Expanders. Alessandro Warth, Milan Stanojevic, and Todd Millstein. In Proceedings of the Object-Oriented Conference on Programming Languages and Systems (OOPSLA), 2006. Personal motivation for membership: Programming language-related conferences have become too conservative -- the rigorous evaluation they require means that there is often a substantial lag between the conception of an idea and its presentation / publication. As a result, conferences have become rather journal-like, and are no longer a place to discuss and get feedback on truly cutting-edge ideas. I am excited to be part of a group that encourages the presentation and in-depth discussions of novel (and often unconventional) ideas in programming language design, and hope to use this as an opportunity to start collaborations with my esteemed colleagues.

Suggest Documents