DOCSLIB.ORG

Venue Medley for the Novice

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Venue Medley for the Novice Venue Medley for the Novice Release 2.0 February, 1992 Address comments to: Venue User Documentation 1549 Industrial Road San Carlos, CA 94070 415-508-9672 Medley for the Novice Release 2.0 February 1992 Copyright 1992 by Venue. All rights reserved. Medley is a trademark of Venue. Xerox is a registered trademark and InterPress is a trademark of Xerox Corporation. UNIX is a registered trademark of UNIX System Laboratories. PostScript is a registered trademark of Adobe Systems Inc. Copyright protection includes material generated from the software programs displayed on the screen, such as icons, screen display looks, and the like. The information in this document is subject to change without notice and should not be construed as a commitment by Venue. While every effort has been made to ensure the accuracy of this document, Venue assumes no responsibility for any errors that may appear. Text was written and produced with Venue text formatting tools; Xerox printers were used to produce text masters. The typeface is Classic. PREFACE It was dawn and the local told him it was down the road a piece, left at the first fishing bridge in the country, right at the appletree stump, and onto the dirt road just before the hill. At midnight he knew he was lost. -Anonymous Welcome to the Medley Lisp Development Environment, a collection of powerful tools for assisting you in programming in Lisp, developing sophisticated user interfaces, and creating prototypes of your ideas in a quick and easy manner. Unfortunately, along with the power comes mind-numbing complexity. The Medley documentation set describes all the tools in detail, but it would be unreasonable for us to expect a new user to wade through all of it, so this primer is intended as an introduction, to give you a taste of some of the features. We developed this primer to provide a starting point for new Medley users, to enhance your excitement and challenge you with the potential before you. We’re going to make some assumptions about you. For starters, we’re going to assume that you’re sitting at a workstation that can run Medley. All of the examples in the book figure that you’re going to want to try things out. We’re also going to assume that you’ve had some exposure to Lisp, hopefully Common Lisp. Medley actually consists of two complete Lisp implementations, Common Lisp and InterLisp. All the screen I/O and some of the system functions are in InterLisp. However, thanks to the package system, you can call back and forth between the two languages by simply including a package delimiter in front of a symbol name. This sounds complicated, but it will become clearer once we do some examples. Throughout we make reference to the lnterlisp-D Reference Manual by section and page number. The material in the primer is just an introduction. When you need more depth, use the detailed treatment provided in the manual. While only you can plot your ultimate destination, you will flnd this primer indispensable for clearly defining and guiding you to the first landmarks on your way. Acknowledgements The early inspiration and model for this primer came from the Intelligent Tutoring Systems group and the Learning Research and Development Center at the University of Pittsburgh. We gratefully acknowledge their pioneering contribution to more effective artificial intelligence. This primer was originally developed by Computer Possibilities, a company committed to making Al technology available. Primary development and writing was done by Cynthia Cosic, with technical writing support provided by Sam Zordich. It has been re- done by Venue staff to reflect changes in the environment since the original publication. At Xerox Artificial Intelligence Systems, John Vittal managed and directed the project. Substantial assistance was provided by many members of the AlS staff who provided both editorial and systems support. Medley for the Novice, Release 2.0 vii PREFACE [This page intentionally left blank] viii Medley for the Novice, Release 2.0 TABLE of CONTENTS Preface.................................................................................................................................................... vii 1. Brief Glossary ......................................................................................................................... 1-1 2. Typing Shortcuts Programmer’s Assistant............................................................................................................. 2-1 If You Make a Mistake .............................................................................................................. 2-2 3. Using Menus Making a Selection from a Menu .............................................................................................. 3-1 Explanations of Menu Items ..................................................................................................... 3-2 Submenus ................................................................................................................................. 3-2 Summary ................................................................................................................................... 3-3 4. How to Use Files Types of Files .......................................................................................................................... 4-1 Directories ................................................................................................................................. 4-1 Directory Options ...................................................................................................................... 4-2 Subdirectories ........................................................................................................................... 4-2 To See What Files Are Loaded ................................................................................................. 4-3 Simple Commands for Manipulating Files ................................................................................. 4-3 Connecting to a Directory .......................................................................................................... 4-3 File Version Numbers ................................................................................................................ 4-4 5. FileBrowser Calling the FileBrowser ............................................................................................................. 5-1 FileBrowser Commands ........................................................................................................... 5-3 6. Those Wondertul Windows! Windows Provided by Medley................................................................................................... 6-1 Creating a Window .................................................................................................................. 6-2 Right Button Default Window Menu .......................................................................................... 6-2 Explanation of Each Menu Item ................................................................................................ 6-3 Scrollable Windows .................................................................................................................. 6-4 Other Window Functions .......................................................................................................... 6-5 PROMPTPRlNT ............................................................................................................... 6-5 WHlCHW .......................................................................................................................... 6-6 Medley for the Novice, Release 2.0 iii TABLE OF CONTENTS 7. Editing and Saving Defining Functions .................................................................................................................... 7-1 Simple Editing in the Executive Window ................................................................................... 7-2 Using the List Structure Editor ................................................................................................... 7-3 Commenting Functions.............................................................................................................. 7-4 File Functions and Variables: How to See and Save Them ...................................................... 7-5 File Variables ............................................................................................................................. 7-5 Saving Interlisp-D on Files......................................................................................................... 7-5 8. Your Init File Using the USERGREETFILES Variable ................................................................................... 8-1 Making an Init File ..................................................................................................................... 8-1 9. Medley Forgiveness: DWIM ............................................................................................. 9-1 10. Break Package Break Windows ....................................................................................................................... 10-1 Break Package Examples ....................................................................................................... 10-1 Ways to Stop Execution from the Keyboard (Breaking Lisp) .................................................. 10-3 Break Menu ...........................................................................................................................
Load more

Recommended publications
  • 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]
  • 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]
  • Final Shift for Call/Cc: Direct Implementation of Shift and Reset
    Final Shift for Call/cc: Direct Implementation of Shift and Reset Martin Gasbichler Michael Sperber Universitat¨ Tubingen¨ fgasbichl,[email protected] Abstract JxKρ = λk:(k (ρ x)) 0 0 We present a direct implementation of the shift and reset con- Jλx:MKρ = λk:k (λv:λk :(JMK)(ρ[x 7! v]) k ) trol operators in the Scheme 48 system. The new implementation JE1 E2Kρ = λk:JE1Kρ (λ f :JE2Kρ (λa: f a k) improves upon the traditional technique of simulating shift and reset via call/cc. Typical applications of these operators exhibit Figure 1. Continuation semantics space savings and a significant overall performance gain. Our tech- nique is based upon the popular incremental stack/heap strategy for representing continuations. We present implementation details as well as some benchmark measurements for typical applications. this transformation has a direct counterpart as a semantic specifica- tion of the λ calculus; Figure 1 shows such a semantic specification for the bare λ calculus: each ρ is an environment mapping variables Categories and Subject Descriptors to values, and each k is a continuation—a function from values to values. An abstraction denotes a function from an environment to a D.3.3 [Programming Languages]: Language Constructs and Fea- function accepting an argument and a continuation. tures—Control structures In the context of the semantics, the rule for call/cc is this: General Terms Jcall=cc EKρ = λk:JEKρ (λ f : f (λv:λk0:k v) k) Languages, Performance Call=cc E evaluates E and calls the result f ; it then applies f to an Keywords escape function which discards the continuation k0 passed to it and replaces it by the continuation k of the call=cc expression.
    [Show full text]
  • Practical Ruby Projects: Practical Ruby Projects Ideas for the Eclectic Programmer
    CYAN YELLOW MAGENTA BLACK PANTONE 123 C BOOKS FOR PROFESSIONALS BY PROFESSIONALS® THE EXPERT’S VOICE® IN OPEN SOURCE Companion eBook Available Practical Ruby Projects: Projects Ruby Practical Ideas for the Eclectic Programmer Dear Reader, You’ve learned the basics of Ruby, and you’re ready to move on to the next level— trying out advanced techniques, mastering best practices, and exploring Ruby’s full potential. With this book you’ll learn by experience while you tackle an exciting series of varied but always practical programming projects. What is an eclectic programmer, you ask? He or she is an inquisitive thinker Practical who likes to play around with new concepts, a person who is project-oriented and enjoys coding, a person who doesn’t mind some technical depth folded in with creative excursions, and a person who is always looking for fresh ideas. This book is a little different from other computer books. It is meant to be entertaining, exciting, and intellectually challenging. Inside you’ll find a collec- tion of diverse projects, ranging from the creative to the practical, written as a nod to all the great Rubyists I’ve been privileged to know. Each chapter dives into Ruby Projects new topics and approaches meant to exercise your programming muscles. You’ll start by building a cross-platform music environment, progress to drawing animations using scalable vector graphics, and then move on to prac- tical problem solving using simulation. In addition, you’ll implement your own turn-based strategy game and build a Mac-native RubyCocoa interface to it.
    [Show full text]
  • The Racket Manifesto∗
    The Racket Manifesto∗ Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi Eli Barzilay, Jay McCarthy, Sam Tobin-Hochstadt Abstract The creation of a programming language calls for guiding principles that point the developers to goals. This article spells out the three basic principles behind the 20-year development of Racket. First, programming is about stating and solving problems, and this activity normally takes place in a context with its own language of discourse; good programmers ought to for- mulate this language as a programming language. Hence, Racket is a programming language for creating new programming languages. Second, by following this language-oriented approach to programming, systems become multi-lingual collections of interconnected components. Each language and component must be able to protect its specific invariants. In support, Racket offers protection mechanisms to implement a full language spectrum, from C-level bit manipulation to soundly typed extensions. Third, because Racket considers programming as problem solving in the correct language, Racket also turns extra-linguistic mechanisms into linguistic constructs, especially mechanisms for managing resources and projects. The paper explains these principles and how Racket lives up to them, presents the evaluation framework behind the design process, and concludes with a sketch of Racket’s imperfections and opportunities for future improvements. 1998 ACM Subject Classification D.3.3 Language Constructs and Features Keywords and phrases design
    [Show full text]
  • An Overview of the Mjølner BETA System∗
    An overview of the Mjølner BETA System∗ Lars Bak,†Jørgen Lindskov Knudsen,‡ Ole Lehrmann Madsen†‡, Claus Nørgaard†, Elmer Sandvad† April 1991 ∗Presented at: Conference on Software Engineering Environments, 25-27 March 1991, Aberystwyth, Wales, Great Britain. †Mjølner Informatics ApS, Sience Park Aarhus, Gustav Wiedsvej 10, DK-8000 Arhus˚ C, Denmark, Phone: +45 86 20 20 00, Fax: +45 86 20 12 22, E-mail: [email protected], [email protected], [email protected] ‡Computer Science Department, Aarhus University, Ny Munkegade 116, DK-8000 Arhus˚ C, Denmark, Phone: +45 86 12 71 88, Fax: + 45 86 13 57 25, E-mail: jlknud- [email protected], [email protected] 1 Abstract The Mjøner BETA System is an integrated and interactive program- ming environment with support for industrial object oriented programming. The Mjølner BETA System is a result of the Scandinavian research project Mjølner. The integration of the various tools in the Mjølner BETA System is es- tablished by insisting that all tools in the system utilizes one single represen- tation of the program. This representation is abstract syntax trees (ASTs). All manipulations of the ASTs by the various tools are done, utilizing the metaprogramming system, which defines an interface to the AST, and ways to manipulate the AST. The Mjølner BETA System includes an implementation of the BETA programming language. In addition it includes a set of grammar-based tools, which can be used for any formal language that is defined by a context- free grammar. The grammar-based tools include a hyper structure editor, a metaprogramming system, and a fragment system.
    [Show full text]
  • Matthias Felleisen, Plt, Nuprl the Beginning (1992/95)
    DEVELOPING DEVELOPERS MATTHIAS FELLEISEN, PLT, NUPRL THE BEGINNING (1992/95) C++ SiCP CS I C, AP, high schools Pascal, Ratfor, the “better math” Fortran “computational” physics economics “come alive” THE BEGINNING (1992/95) ‣ Robby Findler Dist Sys Dev ‣ Kathi Fisler Sw Dev ~ just ‣ Matthew Flatt before students ‣ Shriram Krishnamurthi C++ study Sw Eng SiCP C++ ‣ Emmanuel Schanzer CS II: if CS I is about “Scheme”, what roles CS I does CS it serve? C, TeachScheme! Pascal, Ratfor, ‣ Robert Cartwright (Rice) Fortran Program By Design ‣ Robby Findler Bootstrap ‣ Peter Druschel (MPI-SWS) ‣ Mike Ernst (UW) THE BEGINNING (1992/95) Dist Sys Dev Sw Dev ~ just before students C++ study Sw Eng SiCP C++ CS II: if CS I is about “Scheme”, what roles CS I does CS it serve? C, Pascal, Ratfor, Fortran WHERE I AM TODAY TODAY’S WORLD @ NU CCIS: TECHNICAL SKILLS & COMMUNICATION SKILLS Sw Dev CO OP communication technical skills: skills: conversing systematic about code creation of code OOD CS II LiCS CS I TODAY’S WORLD @ NU CCIS: TECHNICAL SKILLS & COMMUNICATION SKILLS pair programming, scale problem panel/peer review, Sw Dev complexity and memos on code size; consolidate 6-month job-like setting, code in CO OP “the real world” pair programming, scale it up in Java, code review logic in interface OOD proving theorems about systematic design, CS II LiCS (functional) code, dual to typed & OOPL (Java) systematic design pair programming, pair programming code review CS I functional pair programming programming for systematic design TODAY’S WORLD @ NU CCIS: TECHNICAL
    [Show full text]
  • Category D: Published Publications on Lisp/Common Lisp (Duplication
    Category D: Published Publications on Lisp/Common Lisp (duplication checked) Category D-1) Lisp and Common Lisp Books ANSI Common Lisp Paul Graham Prentice Hall 1996 A Programmer’s Guide to Common Lisp Deborah G.Tatar Digital Press 1987 Common Lisp The Reference Franz Inc. Addison-Wesley 1988 Common Lisp Guy L.Steele Jr. (in Japanese) Tr. by Eiichi Goto and Masayuki Ida Kyoritsu Pub. 1984 Common Lisp Second Edition Guy L.Steele Jr. (in Japanese) Tr.by Masayuki Ida, Kyoritsu Pub. 1990 Lisp 3rd Edition Patrick Henry Winston/Berthold Klaus Paul Horn Addison-Wesley 1989 Lisp Patrick Henry Winston/Berthold Klaus Paul Horn (in Japanese) Baihuukan1982 Lisp(1) Third Edition Patrick Henry Winston/Berthold Klaus Paul Horn(in Japanese) Baihuukan1991 Lisp(2) Third Edition Patrick Henry Winston/Berthold Klaus Paul Horn(in Japanese) Baihuukan1991 Lisp Style & Design Molly M.Miller/Eric Benson Digital Press 1990 The Common Lisp Companion Timothy D.Koschmann John Wiley & Sons 1990 The Little LISPer Trade Edition Daniel P.Friedman/Matthias Felleisen MIT Press 1987 The T Programming Language-A Dialect of Lisp- Stephen Slade Prentice Hall 1987 Common Lisp Interface Manager, Release 1 Specification, December 12, 1990 Category D-2) Related Languages and Documents BCPL – the language and its compiler, by M. Richards and C Whitby-Strevens, Cambridge U Press, 1980 B Reference Manual, U Waterloo, 1977 Scheme: Past, Present and Future, by Guy Steele and Masayuki Ida, CSRL Technical Report 95-009, Aoyama Gakuin University, 1995 Programming Languages, ed.by F. Genuys, NATO advanced study institute, Academic Press, 1968 (including “Co-operating Sequential Processes” by E.W.Dijkstra and others) Some Philosophical Problems from the Standpoint of Artificial Intelligence, by J.
    [Show full text]
  • Learning to Program in a Constructionist Way Mattia Monga, Michael Lodi, Dario Malchiodi, Anna Morpurgo, Bernadette Spieler
    Learning to program in a constructionist way Mattia Monga, Michael Lodi, Dario Malchiodi, Anna Morpurgo, Bernadette Spieler To cite this version: Mattia Monga, Michael Lodi, Dario Malchiodi, Anna Morpurgo, Bernadette Spieler. Learning to program in a constructionist way. Proceedings of Constructionism 2018, Aug 2018, Vilnius, Lithuania. hal-01913065 HAL Id: hal-01913065 https://hal.inria.fr/hal-01913065 Submitted on 6 Nov 2018 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. Learning to program in a constructionist way Constructionism Working Group 6 Michael Lodi∗ Dario Malchiodi Bernadette Spieler Alma Mater Studiorum - Mattia Monga Technische Universität Graz Università di Bologna Anna Morpurgo Austria Italy [email protected] [email protected] [email protected] [email protected] [email protected] Università degli Studi di Milano Italy ABSTRACT skills, as is recognizing how a relatively low number of abstract Although programming is often seen as a key element of construc- patterns can be applied to a potentially infinite spectrum of specific tionist approaches, the research on learning to program through situations.Programming languages and environments can either a constructionist strategy is somewhat limited, mostly focusing help or distract novices, thus the choice is not neutral and their on how to bring the abstract and formal nature of programming characteristics should be analyzed carefully to foster a good learn- languages into “concrete” or even tangible objects, graspable even ing context.
    [Show full text]
  • Matthias FELLEISEN, Daniel P. FRIEDMAN, El:Gene KOHLBECKER and Bruce DUBA “The Lambda Calculus Is a Type-Free Theory About
    Theoretical Computer Science 52 (1987) 205-237 205 North-Holland Matthias FELLEISEN, Daniel P. FRIEDMAN, El:gene KOHLBECKER and Bruce DUBA Computer Science Department, Lindley Hall 101, Indiana Vniuersity, Bloomington, IN 47405, U.S.A. Communicated by R. Milner Received April 1986 Revised February 1987 Abstract. Sequential control operators like J and call/cc are often found in implementations of the h-calculus as a programming language. Their semantics is always defined by the evaluation function of an abstract machine. We show that, given such a machine semantics, one can derive an algebraic extension of the AU-calculus. The extended calculus satisfies the diamond property and contains a Church-Rosser subcalculus. This underscores that the interpretation of control operators is to a certain degree independent of a specific evaluation strategy. We also prove a standardization theorem and use it to investigate the correspondence between the machine and the calculus. Together, the calculus and the rewriting machine form a syntactic theory of control, which provides a natural basis for reasoning about programs with nonfunctional control operators. 1. Deficiencies of the A-calculus as a programming language “The lambda calculus is a type-free theory about functions as rules, rather than graphs. ‘Functions as rules’ . refers to the process of going from argument to value, . .” [I, p. 31 No other words can better express why computer scientists have been intrigued with the A-calculus. The rule character of function evaluation comes close to a programmer’s operational understanding of computer programs and, at the same time, the calculus provides an algebraic framework for reasoning about functions.
    [Show full text]
  • Contracts for First-Class Classes
    Contracts for First-Class Classes T. Stephen Strickland Matthias Felleisen PLT @ Northeastern University fsstrickl,[email protected] Abstract from a superclass and combines it with traits via glue code First-class classes add expressive power to class-based that manages name clashes or other small mismatches. Both object-oriented languages. Most importantly, programmers Scala [40] and Fortress [2] support traits. can abstract over common scenarios with first-class classes. Smalltalk [20], OCaml [32, 43], and Racket [18], for- When it comes to behavioral software contracts, however, merly known as PLT Scheme, take the final step and turn first-class classes pose significant challenges. In this paper, classes into first-class values. In such a world, the evaluation we present the first contract system for a programming lan- of an expression may produce a class. Methods and functions guage with first-class classes. The design has been imple- may consume and produce classes. Objects may store classes mented for Racket, which supports first-class classes and in fields. And most importantly, the super-class designator in which implements mixins and traits as syntactic sugar. We a class is just an expression, meaning the super-class is com- expect that our experience also applies to languages with puted at run-time. Equipped with this power, a programmer native mixins and/or traits. can add mixins and traits as “syntactic sugar” [16] but even better, a programmer can explore entirely new ways of orga- Categories and Subject Descriptors D[2]: 3 Object- nizing class-based programs. oriented programming; D [2]: 4 Programming by contract Racket, like Eiffel [38] and many other object-oriented languages [5, 8, 22, 24, 26, 27, 29, 34, 38, 42], also comes General Terms Reliability with a contract system.
    [Show full text]
  • Web Programming with Continuations
    Web Programming with Continuations William E. Byrd∗ November 20, 2002 Contents 1 The Big Idea 2 2 The Problem 2 3 Using Continuations to Add State to the Web 3 4 Issues to Consider 3 4.1 Saving the continuation . 3 4.1.1 Save it on the Server . 3 4.1.2 Save it on the Client . 4 4.1.3 Hybrid Approach . 4 4.2 Simulating Continuations in Other Languages . 4 5 Advantages 5 6 Limitations 5 7 Some Systems in Use 6 8 Open Problems 6 9 A Modest Proposal 7 ∗Author’s e-mail address: emacs [email protected] 1 1 THE BIG IDEA 2 10 Further Reading 7 10.1 Continuations . 7 10.2 Web Programming with Continuations . 8 1 The Big Idea Scheme supports first-class continuations, which can be resumed an arbitrary number of times. These continuations can be used to make HTTP behave like a stateful protocol, and can even eliminate the need for session time-outs. Although continuation-based approaches to Web programming looks promis- ing, several important issues related to the use of continuations still need to be addressed before these techniques will gain commercial acceptance. 2 The Problem Since HTTP is a stateless protocol, Web applications themselves must main- tain conversational state with each client. The usual approach is to break the application into a number of small pieces (JSP’s, Java Servlets, CGI scripts, etc.), each of which is capable of handling a small number of requests. This approach suffers from several problems: • legacy applications not written in this style are difficult to adapt to the Web • breaking the application into pieces may make
    [Show full text]