DOCSLIB.ORG

A Programmable Programming Language

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
A Programmable Programming Language 1 A Programmable Programming Language 2 3 4 MATTHIAS FELLEISEN, ROBERT BRUCE FINDLER, MATTHEW FLATT, SHRIRAM KRISHNAMURTHI, 5 ELI BARZILAY, JAY MCCARTHY, SAM TOBIN-HOCHSTADT 6 7 In addition to libraries and packages, programmers develop and use em- eDSLs. Finally, most available IDEs do not even understand eDSLs bedded problem-specic languages as building blocks of soware systems. 8 or perceive the presence of code wrien in eDSLs. ese languages help developers state solutions for the various aspects of the 9 e goal of the Racket project is to explore this emerging idea of problem in appropriate terms. Complete soware systems compose these 10 partial solutions into a coherent whole. Sadly, this form of work is conducted language-oriented programming (LOP) 11 without real support from the underlying programming language. at two dierent levels. At the practical level, our goal is to build 12 What this emerging development method calls out for, then, are program- a programming language that enables language-oriented soware 13 ming languages that make the creation and use of embedded languages as design. is language must facilitate the easy creation of eDSLs, 14 convenient as the creation of libraries. Implementing this kind of program- the immediate development of components in these newly created ming language has been the goal of our 20-year-old Racket project. is 15 languages, and the integration of components in distinct eDSLs. paper presents the state of the project and sketches how it will proceed. 16 At the conceptual level, the case for LOP is analogous to the 17 CCS Concepts: •So ware and its engineering ! Language types; Con- ones for object-oriented programming or for concurrency-oriented 18 text specic languages; Development frameworks and environments; programming [3]. e former arose from making the creation and 19 ACM Reference format: manipulation of objects syntactically simple and dynamically cheap, 20 Mahias Felleisen, Robert Bruce Findler, Mahew Fla, Shriram Krishna- the laer from Erlang’s inexpensive process creation and message 21 murthi, Eli Barzilay, Jay McCarthy, Sam Tobin-Hochstadt. 2017. A Pro- passing. Both of these innovations enabled new ways of developing 22 grammable Programming Language. 0, 0, Article 0 ( 2017), 7 pages. soware and triggered research projects. e question is how we 23 DOI: 10.1145/nnnnnnn.nnnnnnn will realize LOP and how this will aect the world of soware. 24 e decision to develop a new language, Racket, is partly a his- 25 1 PROBLEMS VS PROGRAMMING LANGUAGES torical artifact and partly due to our desire to free ourselves from 26 any unnecessary constraints of industrial mainstream languages 27 In the ideal world, soware developers ought to analyze each prob- lem in the language of its domain and then articulate solutions while we investigate LOP. e next section spells out how Racket 28 got started, how we honed in on LOP, and what this idea implies. 29 in matching terms. ey could thus easily communicate with do- main experts and separate problem-specic ideas from the details of 30 2 THE PRINCIPLES OF RACKET 31 general-purpose languages and specic program design decisions. 32 In reality, however, programmers use a mainstream programming e Racket project dates back to January 1995, when we started 33 language that someone else picked for them. To compensate for this it as a language for experimenting with pedagogic programming 34 conict, they resort to—and on occasion build their own—domain- languages [15]. Working on these languages quickly taught us that 35 specic languages embedded within the chosen language (eDSLs). a language itself is a problem-solving tool. We then soon found 36 For example, JavaScript programmers employ jery for interacting ourselves developing dierent languages for dierent parts of the 37 with the DOM and React for dealing with events and concurrency. project: one (meta-) language for expressing many pedagogic lan- 38 As developers solve their problems in appropriate eDSLs, they com- guages; another one for specializing the DrRacket IDE [15]; and a 39 pose these solutions into one system. In short, developers eectively third for managing congurations. In the end, our soware was a 1 40 write multi-lingual soware in a common host language. multi-lingual system—just as described in the introduction. 41 Sadly, multi-lingual eDSL programming currently rests on an ad Racket’s guiding principle reects the insight we gained: 42 hoc basis and is rather cumbersome. To create and deploy a lan- Empower programmers to create new programming guage, programmers must usually step outside the chosen language 43 Draftlanguages easily and to add them with a friction-free 44 to set up conguration les, run compilation tools, and link in the process to a code base. resulting object-code les. Worse, the host languages fail to sup- 45 With “language” we mean a new syntax, a static semantics, and a port the proper and sound integration of components in dierent 46 dynamic semantics, which usually maps the new syntax to elements 47 1e numerous language-like libraries in scripting languages (JavaScript, Python, of the host language and possibly external languages via an FFI. 48 and Ruby), books such as Fowler and Parson’s [20], and web sites such as Tomass- For a concrete example, take a look at gure 1. It displays a dia- 49 ei’s [tomassetti.me/resources-create-programming-languages/, last visited May 21, 2017] are evidence for the desire of programmers to use and develop eDSLs. gram of the architecture of a recently developed pair of scripting 50 2 Permission to make digital or hard copies of all or part of this work for personal or languages for video editing [2]. eir purpose is to assist peo- 51 classroom use is granted without fee provided that copies are not made or distributed ple who turn recordings of conference presentations into YouTube 52 for prot or commercial advantage and that copies bear this notice and the full citation videos and channels. Most of their work is repetitive—adding pre- 53 on the rst page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permied. To copy otherwise, or republish, ludes and postludes, concatenating playlists, and superimposing 54 to post on servers or to redistribute to lists, requires prior specic permission and/or a 55 fee. Request permissions from [email protected]. 2e video language, including an overview of the implementation, is available as a 56 © 2017 ACM. XXXX-XX/2017/0-ART0 $15.00 DOI: 10.1145/nnnnnnn.nnnnnnn use-case artifact at ccs.neu.edu/racket/pubs/#icfp17-acf. 57 58 , Vol. 0, No. 0, Article 0. Publication date: 2017. 0:2 • Felleisen et. al. 1 extends syntax, accommodating even conventional variants such as Algol video typed/video 2 60.4 Like many languages, Racket comes with “baeries included.” 3 builds on builds on Most distinctively, Racket eliminates the hard boundary between 4 library and language, overcoming a seemingly intractable conict. video/ffi turnstile 5 In practice, this means new linguistic constructs are as seamlessly 6 builds on builds on imported as functions and classes from libraries and packages. For 7 for builds on syntax-parse builds on example, Racket’s class system and loops are imports from plain 8 libraries, yet most programmers use these constructs without ever 9 builds on noticing their nature as user-dened concepts. 10 racket Racket’s key innovation is a modular syntax system [17, 26], an 11 improvement of Scheme’s macro system [11, 24, 25], which in turn 12 improves on Lisp’s tree-transformation system. A Racket module Fig. 1. LOP, a small example 13 provides services such as functions, classes, and linguistic con- 14 structs. To implement these services, a module may require the 15 services of other modules. In this world of modules, creating a new 16 audio—and only a small number of steps demand manual interven- language simply means creating a module that provides the services 17 tion. e task calls for a domain-specic scripting language, and for a language. Such a module may subtract linguistic constructs 18 video is a declarative eDSL that meets this need. from a base language, re-interpret some others, and add a few new 19 e typed/video language adds a type system to video. Clearly, ones. A language is rarely built from scratch. 20 the domain of type systems comes with its own language of exper- Like Unix shell scripts, which specify their dialect on the rst 21 tise; typed/video’s implementation therefore uses turnstile [6], line, every Racket module species its language on the rst line, too. 22 an eDSL created for expressing type systems. Similarly, the im- is language specication refers to a le that contains a language- 23 plementation of video’s rendering facility calls for bindings to a dening module. Creating this le is all it takes to install a language. 24 multimedia framework. Ours separates the binding denitions and Practically speaking, a programmer may develop a language in one 25 the repetitive details of FFI calls into two parts: an eDSL for multime- tab of the IDE, while another tab may be a module wrien in the 26 dia FFIs, dubbed video/ffi, and a single program in it. Finally, in language of the rst. Without ever leaving the IDE to run compilers, 27 support of creating all these eDSLs, Racket comes with the syntax- linkers, or any other tools, the developer can modify the language 28 parse eDSL [7], which targets the domain of eDSL creation. implementation in the rst tab and immediately experience this 29 e LOP principle implies two subsidiary guidelines: modication in the second.
Load more

Recommended publications
  • Chapter 12 Calc Macros Automating Repetitive Tasks Copyright
    Calc Guide Chapter 12 Calc Macros Automating repetitive tasks Copyright This document is Copyright © 2019 by the LibreOffice Documentation Team. Contributors are listed below. You may distribute it and/or modify it under the terms of either the GNU General Public License (http://www.gnu.org/licenses/gpl.html), version 3 or later, or the Creative Commons Attribution License (http://creativecommons.org/licenses/by/4.0/), version 4.0 or later. All trademarks within this guide belong to their legitimate owners. Contributors This book is adapted and updated from the LibreOffice 4.1 Calc Guide. To this edition Steve Fanning Jean Hollis Weber To previous editions Andrew Pitonyak Barbara Duprey Jean Hollis Weber Simon Brydon Feedback Please direct any comments or suggestions about this document to the Documentation Team’s mailing list: [email protected]. Note Everything you send to a mailing list, including your email address and any other personal information that is written in the message, is publicly archived and cannot be deleted. Publication date and software version Published December 2019. Based on LibreOffice 6.2. Using LibreOffice on macOS Some keystrokes and menu items are different on macOS from those used in Windows and Linux. The table below gives some common substitutions for the instructions in this chapter. For a more detailed list, see the application Help. Windows or Linux macOS equivalent Effect Tools > Options menu LibreOffice > Preferences Access setup options Right-click Control + click or right-click
    [Show full text]
  • Rexx Programmer's Reference
    01_579967 ffirs.qxd 2/3/05 9:00 PM Page i Rexx Programmer’s Reference Howard Fosdick 01_579967 ffirs.qxd 2/3/05 9:00 PM Page iv 01_579967 ffirs.qxd 2/3/05 9:00 PM Page i Rexx Programmer’s Reference Howard Fosdick 01_579967 ffirs.qxd 2/3/05 9:00 PM Page ii Rexx Programmer’s Reference Published by Wiley Publishing, Inc. 10475 Crosspoint Boulevard Indianapolis, IN 46256 www.wiley.com Copyright © 2005 by Wiley Publishing, Inc., Indianapolis, Indiana Published simultaneously in Canada ISBN: 0-7645-7996-7 Manufactured in the United States of America 10 9 8 7 6 5 4 3 2 1 1MA/ST/QS/QV/IN 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, scanning or otherwise, except as permitted under Sections 107 or 108 of the 1976 United States Copyright Act, without either the prior written permission of the Publisher, or authorization through payment of the appropriate per-copy fee to the Copyright Clearance Center, 222 Rosewood Drive, Danvers, MA 01923, (978) 750-8400, fax (978) 646-8600. Requests to the Publisher for permission should be addressed to the Legal Department, Wiley Publishing, Inc., 10475 Crosspoint Blvd., Indianapolis, IN 46256, (317) 572-3447, fax (317) 572-4355, e-mail: [email protected]. LIMIT OF LIABILITY/DISCLAIMER OF WARRANTY: THE PUBLISHER AND THE AUTHOR MAKE NO REPRESENTATIONS OR WARRANTIES WITH RESPECT TO THE ACCURACY OR COM- PLETENESS OF THE CONTENTS OF THIS WORK AND SPECIFICALLY DISCLAIM ALL WAR- RANTIES, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR PURPOSE.
    [Show full text]
  • An Array-Oriented Language with Static Rank Polymorphism
    An array-oriented language with static rank polymorphism Justin Slepak, Olin Shivers, and Panagiotis Manolios Northeastern University fjrslepak,shivers,[email protected] Abstract. The array-computational model pioneered by Iverson's lan- guages APL and J offers a simple and expressive solution to the \von Neumann bottleneck." It includes a form of rank, or dimensional, poly- morphism, which renders much of a program's control structure im- plicit by lifting base operators to higher-dimensional array structures. We present the first formal semantics for this model, along with the first static type system that captures the full power of the core language. The formal dynamic semantics of our core language, Remora, illuminates several of the murkier corners of the model. This allows us to resolve some of the model's ad hoc elements in more general, regular ways. Among these, we can generalise the model from SIMD to MIMD computations, by extending the semantics to permit functions to be lifted to higher- dimensional arrays in the same way as their arguments. Our static semantics, a dependent type system of carefully restricted power, is capable of describing array computations whose dimensions cannot be determined statically. The type-checking problem is decidable and the type system is accompanied by the usual soundness theorems. Our type system's principal contribution is that it serves to extract the implicit control structure that provides so much of the language's expres- sive power, making this structure explicitly apparent at compile time. 1 The Promise of Rank Polymorphism Behind every interesting programming language is an interesting model of com- putation.
    [Show full text]
  • Smart Battery Charging Programmer Software User Manual Smart Battery Charging Programmer Software User Manual
    Smart Battery Charging Programmer Software User Manual Smart Battery Charging Programmer Software User Manual 1. Introduction ............................................................................................................... 1 ................................................................................................... 2. Prerequisites 1 .................................................................................................. 2.1 System requirements 1 .................................................................................................. 2.2 Hardware installation 1 ................................................................................................... 2.3 Software installation 2 3. User Interface ............................................................................................................ 2 .............................................................................................................. 3.1 Basic layout 2 CURVE PROFILE ......................................................................................................... 3.2 2 SETTING ...................................................................................... ............. 3.3 ................ 3 . ...................................................................................................... 4 General Operation 4 ...................................................................................................... 4.1 Connection 4 4.2 .........................................................................
    [Show full text]
  • Compiler Error Messages Considered Unhelpful: the Landscape of Text-Based Programming Error Message Research
    Working Group Report ITiCSE-WGR ’19, July 15–17, 2019, Aberdeen, Scotland Uk Compiler Error Messages Considered Unhelpful: The Landscape of Text-Based Programming Error Message Research Brett A. Becker∗ Paul Denny∗ Raymond Pettit∗ University College Dublin University of Auckland University of Virginia Dublin, Ireland Auckland, New Zealand Charlottesville, Virginia, USA [email protected] [email protected] [email protected] Durell Bouchard Dennis J. Bouvier Brian Harrington Roanoke College Southern Illinois University Edwardsville University of Toronto Scarborough Roanoke, Virgina, USA Edwardsville, Illinois, USA Scarborough, Ontario, Canada [email protected] [email protected] [email protected] Amir Kamil Amey Karkare Chris McDonald University of Michigan Indian Institute of Technology Kanpur University of Western Australia Ann Arbor, Michigan, USA Kanpur, India Perth, Australia [email protected] [email protected] [email protected] Peter-Michael Osera Janice L. Pearce James Prather Grinnell College Berea College Abilene Christian University Grinnell, Iowa, USA Berea, Kentucky, USA Abilene, Texas, USA [email protected] [email protected] [email protected] ABSTRACT of evidence supporting each one (historical, anecdotal, and empiri- Diagnostic messages generated by compilers and interpreters such cal). This work can serve as a starting point for those who wish to as syntax error messages have been researched for over half of a conduct research on compiler error messages, runtime errors, and century. Unfortunately, these messages which include error, warn- warnings. We also make the bibtex file of our 300+ reference corpus ing, and run-time messages, present substantial difficulty and could publicly available.
    [Show full text]
  • Typescript Language Specification
    TypeScript Language Specification Version 1.8 January, 2016 Microsoft is making this Specification available under the Open Web Foundation Final Specification Agreement Version 1.0 ("OWF 1.0") as of October 1, 2012. The OWF 1.0 is available at http://www.openwebfoundation.org/legal/the-owf-1-0-agreements/owfa-1-0. TypeScript is a trademark of Microsoft Corporation. Table of Contents 1 Introduction ................................................................................................................................................................................... 1 1.1 Ambient Declarations ..................................................................................................................................................... 3 1.2 Function Types .................................................................................................................................................................. 3 1.3 Object Types ...................................................................................................................................................................... 4 1.4 Structural Subtyping ....................................................................................................................................................... 6 1.5 Contextual Typing ............................................................................................................................................................ 7 1.6 Classes .................................................................................................................................................................................
    [Show full text]
  • How to Design Co-Programs
    JFP, 15 pages, 2021. c Cambridge University Press 2021 1 doi:10.1017/xxxxx EDUCATIONMATTERS How to Design Co-Programs JEREMY GIBBONS Department of Computer Science, University of Oxford e-mail: [email protected] Abstract The observation that program structure follows data structure is a key lesson in introductory pro- gramming: good hints for possible program designs can be found by considering the structure of the data concerned. In particular, this lesson is a core message of the influential textbook “How to Design Programs” by Felleisen, Findler, Flatt, and Krishnamurthi. However, that book discusses using only the structure of input data for guiding program design, typically leading towards structurally recur- sive programs. We argue that novice programmers should also be taught to consider the structure of output data, leading them also towards structurally corecursive programs. 1 Introduction Where do programs come from? This mystery can be an obstacle to novice programmers, who can become overwhelmed by the design choices presented by a blank sheet of paper, or an empty editor window— where does one start? A good place to start, we tell them, is by analyzing the structure of the data that the program is to consume. For example, if the program h is to process a list of values, one may start by analyzing the structure of that list. Either the list is empty ([]), or it is non-empty (a : x) with a head (a) and a tail (x). This provides a candidate program structure: h [ ] = ::: h (a : x) = ::: a ::: x ::: where for the empty list some result must simply be chosen, and for a non-empty list the result depends on the head a and tail x.
    [Show full text]
  • Panel: NSF-Sponsored Innovative Approaches to Undergraduate Computer Science
    Panel: NSF-Sponsored Innovative Approaches to Undergraduate Computer Science Stephen Bloch (Adelphi University) Amruth Kumar (Ramapo College) Stanislav Kurkovsky (Central CT State University) Clif Kussmaul (Muhlenberg College) Matt Dickerson (Middlebury College), moderator Project Web site(s) Intervention Delivery Supervision Program http://programbydesign.org curriculum with supporting in class; software normally active, but can be by Design http://picturingprograms.org IDE, libraries, & texts and textbook are done other ways Stephen Bloch http://www.ccs.neu.edu/home/ free downloads matthias/HtDP2e/ or web-based NSF awards 0010064 http://racket-lang.org & 0618543 http://wescheme.org Problets http://www.problets.org in- or after-class problem- applet in none - teacher not needed, Amruth Kumar solving exercises on a browser although some adopters use programming concepts it in active mode too NSF award 0817187 Mobile Game http://www.mgdcs.com/ in-class or take-home PC passive - teacher as Development programming projects facilitator to answer Qs Stan Kurkovsky NSF award DUE-0941348 POGIL http://pogil.org in-class activity paper or web passive - teacher as Clif Kussmaul http://cspogil.org facilitator to answer Qs NSF award TUES 1044679 Project Course(s) Language(s) Focus Program Middle school, Usually Scheme-like teaching problem-solving process, by pre-AP CS in HS, languages leading into Java; particularly test-driven DesignStephen CS0, CS1, CS2 has also been done in Python, development and use of data Bloch in college ML, Java, Scala, ... types to guide coding & testing Problets AP-CS, CS I, CS 2. C, C++, Java, C# code tracing, debugging, Amruth Kumar also as refresher or expression evaluation, to switch languages predicting program state in other courses Mobile Game AP-CS, CS1, CS2 Java core OO programming; DevelopmentSt intro to advanced subjects an Kurkovsky such as AI, networks, security POGILClif CS1, CS2, SE, etc.
    [Show full text]
  • Acme: a User Interface for Programmers Rob Pike [email protected]−Labs.Com
    Acme: A User Interface for Programmers Rob Pike [email protected]−labs.com ABSTRACT A hybrid of window system, shell, and editor, Acme gives text-oriented applications a clean, expressive, and consistent style of interaction. Tradi­ tional window systems support interactive client programs and offer libraries of pre-defined operations such as pop-up menus and buttons to promote a consistent user interface among the clients. Acme instead pro­ vides its clients with a fixed user interface and simple conventions to encourage its uniform use. Clients access the facilities of Acme through a file system interface; Acme is in part a file server that exports device-like files that may be manipulated to access and control the contents of its win­ dows. Written in a concurrent programming language, Acme is structured as a set of communicating processes that neatly subdivide the various aspects of its tasks: display management, input, file server, and so on. Acme attaches distinct functions to the three mouse buttons: the left selects text; the middle executes textual commands; and the right com­ bines context search and file opening functions to integrate the various applications and files in the system. Acme works well enough to have developed a community that uses it exclusively. Although Acme discourages the traditional style of interaction based on typescript windowsߞteletypesߞits users find Acmeߣs other ser­ vices render typescripts obsolete. History and motivation The usual typescript style of interaction with Unix and its relatives is an old one. The typescriptߞan intermingling of textual commands and their outputߞoriginates with the scrolls of paper on teletypes.
    [Show full text]
  • Tiny Tools Gerard J
    Tiny Tools Gerard J. Holzmann Jet Propulsion Laboratory, California Institute of Technology Many programmers like the convenience of integrated development environments (IDEs) when developing code. The best examples are Microsoft’s Visual Studio for Windows and Eclipse for Unix-like systems, which have both been around for many years. You get all the features you need to build and debug software, and lots of other things that you will probably never realize are also there. You can use all these features without having to know very much about what goes on behind the screen. And there’s the rub. If you’re like me, you want to know precisely what goes on behind the screen, and you want to be able to control every bit of it. The IDEs can sometimes feel as if they are taking over every last corner of your computer, leaving you wondering how much bigger your machine would have to be to make things run a little more smoothly. So what follows is for those of us who don’t use IDEs. It’s for the bare metal programmers, who prefer to write code using their own screen editor, and who do everything else with command-line tools. There are no real conveniences that you need to give up to work this way, but what you gain is a better understanding your development environment, and the control to change, extend, or improve it whenever you find better ways to do things. Bare Metal Programming Many developers who write embedded software work in precisely this way.
    [Show full text]
  • Typescript-Handbook.Pdf
    This copy of the TypeScript handbook was created on Monday, September 27, 2021 against commit 519269 with TypeScript 4.4. Table of Contents The TypeScript Handbook Your first step to learn TypeScript The Basics Step one in learning TypeScript: The basic types. Everyday Types The language primitives. Understand how TypeScript uses JavaScript knowledge Narrowing to reduce the amount of type syntax in your projects. More on Functions Learn about how Functions work in TypeScript. How TypeScript describes the shapes of JavaScript Object Types objects. An overview of the ways in which you can create more Creating Types from Types types from existing types. Generics Types which take parameters Keyof Type Operator Using the keyof operator in type contexts. Typeof Type Operator Using the typeof operator in type contexts. Indexed Access Types Using Type['a'] syntax to access a subset of a type. Create types which act like if statements in the type Conditional Types system. Mapped Types Generating types by re-using an existing type. Generating mapping types which change properties via Template Literal Types template literal strings. Classes How classes work in TypeScript How JavaScript handles communicating across file Modules boundaries. The TypeScript Handbook About this Handbook Over 20 years after its introduction to the programming community, JavaScript is now one of the most widespread cross-platform languages ever created. Starting as a small scripting language for adding trivial interactivity to webpages, JavaScript has grown to be a language of choice for both frontend and backend applications of every size. While the size, scope, and complexity of programs written in JavaScript has grown exponentially, the ability of the JavaScript language to express the relationships between different units of code has not.
    [Show full text]
  • Improving Learning of Programming Through E-Learning by Using Asynchronous Virtual Pair Programming
    Improving Learning of Programming Through E-Learning by Using Asynchronous Virtual Pair Programming Abdullah Mohd ZIN Department of Industrial Computing Faculty of Information Science and Technology National University of Malaysia Bangi, MALAYSIA Sufian IDRIS Department of Computer Science Faculty of Information Science and Technology National University of Malaysia Bangi, MALAYSIA Nantha Kumar SUBRAMANIAM Open University Malaysia (OUM) Faculty of Information Technology and Multimedia Communication Kuala Lumpur, MALAYSIA ABSTRACT The problem of learning programming subjects, especially through distance learning and E-Learning, has been widely reported in literatures. Many attempts have been made to solve these problems. This has led to many new approaches in the techniques of learning of programming. One of the approaches that have been proposed is the use of virtual pair programming (VPP). Most of the studies about VPP in distance learning or e-learning environment focus on the use of the synchronous mode of collaboration between learners. Not much research have been done about asynchronous VPP. This paper describes how we have implemented VPP and a research that has been carried out to study the effectiveness of asynchronous VPP for learning of programming. In particular, this research study the effectiveness of asynchronous VPP in the learning of object-oriented programming among students at Open University Malaysia (OUM). The result of the research has shown that most of the learners have given positive feedback, indicating that they are happy with the use of asynchronous VPP. At the same time, learners did recommend some extra features that could be added in making asynchronous VPP more enjoyable. Keywords: Pair-programming; Virtual Pair-programming; Object Oriented Programming INTRODUCTION Delivering program of Information Technology through distance learning or E- Learning is indeed a very challenging task.
    [Show full text]