Posts: 5,362
Threads: 2,998
Joined: Feb 2011
[attachment=11526]
INTRODUCTION
Curl is a new language for creating web documents with almost any sort of content, from simple formatted to text to complex interactive applets.
• Text formatting. Curl provides a rich set of formatting operations similar to those implemented by HTML tags. Unlike HTML, the Curl formatter can be extended by users to provide additional functionality, from simple macros (e.g., to provide a convenient way to switch to a particular font, size and color) to direct control over the positioning of subcomponents (e.g., as in a TeX-like equation formatter). Several packages of useful formatting extensions are currently under development.
• Scripting simple interactions. Using a TK-like interface toolkit of interactive components, Curl makes it easy to build simple interactive web pages. One can view interactive objects like buttons or edit-able fields as extensions to the basic formatting operations provided above -- one uses the same easy-to-learn syntax to create interactive documents as to create regular text documents. There's no need to learn a separate scripting language!
• Programming complex operations. components can also be developed using Curl since, at its heart, Curl is really an object-oriented programming language. Curl expressions, class definitions and procedure definitions embedded in the web document are securely compiled to native code by the built-in on-the-fly compiler and then executed without the need for any sort of interpreter. Curl provides many of the features of a modern object-oriented programming language: multiple inheritance, extensible syntax, a strong type system that includes a dynamic "any" type, safe execution through encapsulation of user code and extensive checking performed both at compile and run time. Almost all of the Curl system and compiler are written in Curl.
HISTORY
The other key deliverable from the 1995 MIT project was the invention of a new computing language called Curl. This was designed from the ground up to be able to handle all the different application requirements found on the Internet. It can be used to create simple text formatting or markup documents at one end of the application scale, and highly interactive, rich–interface, complex enterprise applications at the other.
In 1998, many of the key members of the MIT project realized that they had created a language that really could revolutionize the way Internet applications were developed. The group decided to make the language commercially available, and Curl Corporation was formed in 1998.
Curl Corporation shipped the first version of the language and toolset, collectively known as Curl, in 2001.Curl Corporation, based in Cambridge, Massachusetts, continues to enhance and improve on the baseline work done during the MIT DARPA project.
They have made available a number of incremental releases of the Curl language, the runtime engine, and the integrate development environment (IDE) tools. It offers a technology to the enterprise that addresses a number of key In-ternet application concerns:
• Run over small bandwidth (sometime as low as 14KB)
• Provide a rich graphical user interface (GUI)
• Integrate with existing Web standards
• Create applications that are written in one language and are easy to maintain
• Be easy to learn
• Enable quick application development
• Utilize a user's PC processing power
What Is Curl?
Curl was conceived to provide a full-featured and robust technology beyond HTML and JavaScript, enabling the development of very rich Web client applications. The Curl platform is designed around the Curl content language, which features a unified notation for information, style, and behavior, enabling its use to implement a broad range of descriptive and active elements ranging from HTML-like text formats to high-performance 3D graphics.
By covering this whole spectrum of capabilities, the Curl content language provides "one-stop shopping" where the whole range of content and behavior requirements of Web applications can be satisfied within one framework. If not using Curl, a developer would have to integrate multiple technologies to achieve similar results, for example by embedding applets in HTML pages, but getting such multiple technologies to work with each other is inherently complicated, increasing application development costs and reducing maintainability.
Furthermore, the Curl content language is designed from the ground up for the purpose of building user interfaces and presenting information to people. Curl's unique and powerful layout and styling capabilities help you build sophisticated user interfaces quickly and express them in compact, concise code.
Curl applications do not require changes in the back-end infrastructure used today for Web-based enterprise applications, mostly built upon J2EE or Microsoft's .Net. Curl provides a new client-side technology fully complementary to these server-side alternatives, able to connect to any server product irrespective of operating system or manufacturer, and thus making efficient use of your existing data and system assets.
The full Curl platform consists of three components:
1. An extensible programming language (the Curl content language) designed to create interactive Web content.
2. A runtime engine (the Curl RTE) that executes Curl programs and renders the resulting content.
3. An IDE (integrated development environment) to construct rich Internet client-side applications.
WORKING OF CURL APPLICATIONS
An application programmed in the Curl language is placed on a Web server as source code or in a compressed "pcurl" format that is not human-readable. When requested by a client machine's Web browser, the Web server sends the application file or files to the client, where a just-in-time compiler compiles the application into native code that runs with the full performance of the client processor. From that point, the full power of the application is literally in the hands of the user because the application runs on the user's machine, not on the server. When the application needs additional data from the server, it can request just the needed data. Typically, this data is much more compact than the successive HTML page loads that characterize the typical path through the screens of a first-generation Web application.
The server is freed from much of the processing it typically does because all of the presentation work, as well as appropriate business logic tasks, are offloaded to the client. The network is freed from constant back-and-forth requests and downloading of fresh web pages. Huge savings in server load and network bandwidth result, making Curl-based applications highly scalable.
Since Curl applications can run autonomously on the client side, they can even keep running when there is no network connectivity. Thus, Curl can be used to build "occasionally connected" applications that cache data on the client machine while connected to the network, and can then use the cached data to continue working even when out of range of a network connection.
CURL OVERVIEW
The name Curl derives from the principal syntactic feature of the language: Curl source files are arbitrary text, punctuated by expressions enclosed by curly brackets. Like HTML, plain text is valid source; unlike HTML, the escapes extend to a real programming language. For example:
Curl source What user sees
The following characters are displayed using a {bold bold-faced font}. There are {+ 10 4} bold characters altogether. The following characters are displayed using a bold-faced font. There are 14 bold characters altogether.
Interpreting the Curl source above requires definitions for the bold and + operators. In Curl, the meaning of {operator ...} is determined by first locating a definition for operator in the current environment and then calling upon that function to parse and interpret the remaining text "..." of the expression. Note that this mechanism allows the "..." text to have any desired structure since the parsing rules are dynamically defined. In this example, the bold operator treats its arguments as a sequence of Graphic objects (in this case simple characters) to be displayed with the 'bold property set to true, while the + operator parses the remaining text as a sequence of subexpressions to be evaluated and then summed. Every Curl object can be converted to a Graphic object (the conversion process is controlled by a method defined by the object's type) which in turn can be assembled into a formatted display by the Curl browser. An interesting side-effect of being able to view all Curl objects is that we can use the browser metaphor to good effect when building debuggers, inspectors, etc.
Curl comes with a large (and growing) repertoire of predefined operators which provide formatting operations and a TK-like toolkit of user-interface components. The widespread adoption of TCL/TK and, to a lesser extent, JavaScript/HTML, demonstrates that simple applications of these operators are often sufficient to fulfill many, if not most, of the needs of interactive documents. The following example assembles a few of these components into a simple order form:
Since the values for color and quantity are Dynamic objects, the last line of the display changes automatically as the user manipulates the color and quantity controls. A Dynamic object incorporates a simple mechanism for propagating changes in its value to other dynamic objects that depend on first object's value. More sophisticated propagation rules could be supplied by the user by creating a new class of objects derived from Dynamic objects that have a different "propagate" method.
The screen shot above reflects the fact the user has selected something besides the default color (red) and quantity (0). Note that the "text-as-program paradigm" means that the value operator must be wrapped around variable names inside of paragraphs. Otherwise, the name of the variable as a text string will be displayed instead of its value. This example illustrates several Curl features:
• Formatting model. A TeX-like hierarchical "box-and-glue" formatting model that makes it easy to construct layouts.
• Naming environment. A lexically-scoped naming environment which allows one to construct modular documents with interchangeable components. Languages with "flat" name spaces, like TCL, can make it difficult to reuse components since naming conflicts need to be resolved as code fragments are moved from document to document.
• Object-oriented programming. The use of objected-oriented programming to extend the behavior of the Curl system in an easily-accessible way. In this example the creator of the Dynamic class has encapsulated the knowledge of how a change in the value of a Dynamic object results ultimately in the updating of the display. Of course the current user doesn't have to understand how the underlying mechanism works in order to put it to effective use. This sort of extensibility is beyond the ken of most simple scripting languages.
CURL AS A PROGRAMMING LANGUAGE
Curl is both a language and an authoring environment where the authoring environment was as implemented as user extensions to Curl. The language can be used as an HTML replacement for the presentation of formatted text, but whose capabilities include those of scripting languages as well as to compiled, strongly-typed, object-oriented system programming.
Obvious influences on Curl's design include LISP[4,13,14,15], C++, Tcl/Tk[5], TeX[9] and HTML. Language design decisions directly reflect the goal of reconciling its simple accessibility to naive users with the power and efficiency demanded by sophisticated programming tasks. Salient features of Curl include
Programs as documents
Execution of every Curl program results in a document containing a set of objects that may be displayed or otherwise manipulated. Curl includes an extensible GUI which provides for simple, structured arrangement of displayable objects. The debugging and development environment is integrated and accessible. Curl objects, along with the type information which describes them, may be browsed along with other Web content. Objects seen on the screen may be identified and inspected.
Syntax and Semantics
• Extensibility
• Strong typing
• Ambiguous types
• Lexically-scoped environment. Curl provides a structured name space whose bindings include variables, constants, types, and compilation hooks for arbitrary syntactic forms. The name space is instantiated as an environment which spans compile and run times, and which completely dictates the semantics which will be associated with source code during compilation
• Procedural semantics. Procedures are first-class data, implemented using closures as necessary. Positional and keyword arguments are supported.
