Allegro CL^? 8.1

Persistency built in, not a database add-on

Complex applications with billions of objects are now made easy with Allegro CL 8.1

The complexity of today's software applications and the explosion of data size are pervasive in all fields ranging from Life Sciences to Manufacturing to Financial Analytics. Allegro CL 8.1, with Persistent AI Built-In, All the Way Down^TM, is the most effective system for developing and deploying applications to solve these complex problems in the real world. For more information, contact info@franz.com.

Allegro CL 8.1 is the culmination of feedback from customers and users. There are a number of new features and enhancements that we hope will improve your experience and success with Allegro CL. While the release increment indicates a minor update from 8.0, we believe the performance enhancements and product updates will make an impact on your application as though it were a major release.

Enhancements

See the Release Notes for a complete description of new features and enhancements.

Performance Enhancements. For this release of Allegro CL we have focused our effort on several performance metrics. For example, with 8.1 we have recorded more than a 3x speedup on the mandelbrot/dfloat test, as well as more than 2x speedups on 1d-arrays and sum-permutations, and 20% or more speedups on 10 other benchmarks. Also, opening a file has doubled in speed over 8.0. We intend to further enhance the performance profile for 8.1 and beyond, based on user feedback as well as our own development plans.

• New optimized variants of read-line: faster with less consing in most cases.
• New command-line argument +P: controlling whether the console is displayed
• Various RPC updates
• SOAP changes: make-client-interface, make-server-interface have new keyword arguments; extended definition of wsdl-generate-code to allow generated comments; define-soap-element and define-soap-type allow attributes to be defined in argument list; various other changes and new functionality.
• jLinker changes to jlinker-listen and jlinker-init
• double-sided option for pop-up-printer-job-dialog
• The Common Graphics text-editing widget uses a newer version of Microsoft's RichEdit control
• Faster mouse wheel scrolling in the text-editing widget in Common Graphics
• New Common Graphics functions return the available coordinate space across multiple monitors
• A child window on MS Windows may now have a menu-bar
• Numerous grid-widget enhancements

New Features

Base Lisp

• Daylight saving time: Allegro CL now queries the Operating System about whether DST is or is not in effect, rather than using internal US schedules
• New :anynl value for eol-convention for input-streams allows files using any EOL convention (the UNIX, Windows and Mac conventions are different) to be read correctly
• excl:with-underlying-simple-vector exported: allows access to the underlying data vector associated with an array
• New ISO 8601 date/time module: provides support for ISO 8601 specifications of dates and times
• PAM support on some platforms
• New support for pipe streams
• New function base64-encode-stream
• New ability to invoke Lisp within a bat file on Windows
• New get-semaphore and put-semaphore functions

Common Graphics and the IDE

• Common Graphics Chart Widget. A new widget which draws charts is now available on platforms that support Common Graphics (Windows and some Linux platforms). See cg-chart-widget.htm
• Common Graphics Class-grid Widget. A new subclass of grid-widget which creates a grid with class slots as column heads and instances as rows. See class-grid
• New object-editor dialog class
• New function pop-up-menus-for-many-sorted-choices takes a potentially huge list of pre-sorted choices and presents them to the user as a series of pop-up menus
• New scrolling-static-text widget

Other new features

• New support for X.509 certificates in SSL (Secure Socket Layer) support
• New net.mail package and interface for parsing and validating email addresses
• New support for constructing MIME messages

New Products

• AllegroCache v2.0. Building on the successful introduction of AllegroCache with the release of 8.0, Franz continues to add customer driven features to ensure their commercial advantage. The new bulk loading mode allows users to add objects to the database very quickly. Improvements to the back end Btrees provides better performance and efficiency.
• Allegro Btrees. The same btree module that AllegroCache has been using to implement object persistence is now available for programmers to use directly. Btrees are useful for applications where you need a simple and efficient way of storing on disk and retrieving vast amounts of data and where you don't want to pay the overhead of transactions and CLOS.
• AllegroGraph. For customers interested in Semantic Web technologies, Franz has developed a new persistent, scalable triple-store database product. This product is available separately from the Allegro CL release process and pricing. In conjunction with the ACL 8.1 release, Franz has introduced the Free Lisp Edition of AllegroGraph that has a maximum limitation of RDF triples on appropriately configured hardware. The AllegroGraph Free Lisp Edition is available to all ACL customers as well as ACL Express Edition users.

Allegro CL 8.1

Maximize your development efforts

Control the Data:

• AllegroCache -- The enabling technology behind Allegro CL 8.1 persistent objects is a high-performance, scalable, dynamic object-caching database. It allows programmers to work directly with objects as if they were in memory while in fact the object data is always stored on disk. It supports fully ACID-compliant transaction mode with both long and short transactions. It automatically maintains referential integrity of complex object networks. AllegroCache provides 64-bit real-time data caching on the application memory to achieve very high data access throughput over as large a data set as required. AllegroCache features include:
• Persistent CLOS Objects in Allegro Common Lisp -- Class definitions are stored as first class objects in the database
• Dynamic Schema Evolution -- Redefine classes on the fly, persistent objects are lazily updated when accessed
• Standalone & Client Server -- Single user on local disk or multiple clients talking to single server over sockets
• Bulk Loading -- Improved performance adding objects to the database
• Transaction Logging -- Restore databases after power failure or disk crash
• Expression Cursors -- Iterate over a set of instances that satisfy a predicate over multiple slots of an instance
• Range Queries -- Retrieve objects with slots that match a range of values
• Native lisp btrees -- Comparable in speed with BerkeleyDB, with more control
• Transactional model -- All ACID features, commit/rollback, and optimistic concurrency
• Supports databases with billions of objects (and Terabytes of Data)
• Convenient macros to loop over classes, maps and sets
• Indexed slots -- A mapping from slot-values to objects, retrieve objects and object ids (oid)
• Maps -- Transactionally safe persistent hashtables
• Sets -- Persistent large collections of objects
• Supports most common datatypes -- Including unsigned-byte 8 arrays, maps and sets
• Object ID's unique for the lifetime of the database -- User accessible
• Dump the database into XML files
• Restore database from the XML dump
• User controlled caching -- For the size of the btrees and the total number of objects stored in the cache

Control the Internet:

• SAX/DOM XML Parsers: Validating XML parsers, successfully tested against all major test suites. Analyze and process enterprise XML data extremely fast
• SOAP API: Enables Allegro CL applications to communicate with new and legacy applications over the internet via the SOAP protocol, and to access web services over the internet
• WSDL Compiler: Automatically generates client SOAP templates from WSDL files and server WSDL files from Lisp expressions
• Allegro Webactions: A Web Application Framework for building dynamic web pages that can be easily maintained and updated
• AllegroServe: A dynamic, high-performance Lisp-based web server that also interoperates with other web/application servers
• HTML Parser: Process and analyze web page data
• SSL Socket Streams: Secure internet transactions
• XML RPC (Remote Procedure Call): Allows Lisp applications to communicate via XML
• Lisp RPC (Remote Procedure Call): Allows two Lisp applications to more easily communicate
• IPv6 -- Internet Protocol version 6 socket support

Control Development:

• Allegro Prolog: A classic AI programming language in Allegro CL for Logic Programming, with an execution speed in excess of 1 Mlips and running essentially cons free
• Pcache -- An update to Allegro Prolog, an implementation of Prolog within Allegro CL. It allows Allegro Prolog to be used as a query language for AllegroCache
• Regular Expressions: A fast, Perl-compatible Regular Expression matcher
• Allegro Runtime Analyzer: Profiles function calling patterns and analyzes their space and time utilization for code optimization, an important tool for tuning application performance
• Very large array-total-size-limit (2²⁹ for 32-bit, 2⁶⁰ for 64-bit)
• Operating System Interface: Built-in interface for direct interaction between Allegro CL and the OS, without the need to write foreign code
• Shell Module: Provides access to the Unix/Linux/Mac commands at the application code level, enhancing performance, portability and consistency across platforms
• asdf System Definition Facility (see www.cliki.net/asdf for info on asdf)
• OpenGL Interface on platforms with available OpenGL libraries (see www.opengl.org for more information)
• IDE and Common Graphics for greater usability and navigation
• HTML Widget in Common Graphics -- Used by the IDE help facility for better integration
• Large file support -- On 32-bit platforms this greatly increases the size of files that can be reliably handled. (Functions which may not have worked before but now do include file-position and file-length, and the OS Interface functions stat, os-truncate, and os-ftruncate). The new limit is 2⁶³ - 1 in size. This is about nine billion times larger that the old limit, which was 4 Gigabytes. (On 64-bit platforms, the maximum allowable size has always been 2⁶³ - 1)
• Cryptography: SHA1, HMAC and RC4 support
• Localization support for Unicode international character sets, local time, currency, etc.
• Graphical profiling and debugging tools for multiple threads
• Interact with GNU Emacs with the Franz Inc. Emacs-Lisp interface or SLIME

Control Interoperability:

• Allegro Oracle Direct Connect: High-performance direct access to Oracle databases
• Allegro MySQL Direct Connect: High-performance direct access to MySQL databases
• NDBM Database Interface: Interface to NDBM functionality on Unix/Linux/Mac
• SWIG interface to C++: Generate Allegro CL foreign function interfaces to C libraries automatically, using the open source tool SWIG (see www.swig.org for more information)
• Message Digest Functions: SHA1 message digest support (in addition to existing MD5 support). HMAC-MD5 and HMAC-SHA1 support. Also support for RC4 encoding
• FTP Client: The Allegro FTP client makes it very easy to manage files, and connects seamlessly to any FTP server, including Allegro FTP
• Java Tool Suite: Package applications as Java Beans or Servlets, directly call Java methods from Lisp methods and vice versa, and dynamically generate Java byte codes to run on JVMs. With jLinker, application programmers can choose the socket interface or native JNI interface on most platforms
• Complete access to relational databases via Allegro ODBC
• Portable Object Adapter (POA) for Allegro ORBLink (a CORBA-Compliant ORB)
• Comprehensive Foreign Function Interface
• OLE/COM Support: A high-level OLE/OCX interface to complement the existing low-level interface that has been available for some time. The core of the high-level interface is automatically reading typelibs and automatically creating the interface on the Lisp side. Common Graphics widgets can be defined for arbitrary OCX controls
• NT Service module: The NT Service module was previously available as opensource, and it is now included in the product, with some minor enhancements and fixes

Control Runtime:

• Change class definitions and methods on the fly, and automatically propagate changes to existing object instances
• Built-in memory management and garbage collection
• Application delivery as a DLL or stand alone image
• Robust, flexible and efficient multiprocessing for Unix/Linux/Mac and Windows -- OS Threads for Windows: One Lisp thread and unlimited non-Lisp threads can run on different processors
• Linux Version Compatibility: Allegro CL runs on all Linux distributions that use Glibc 2.2 on x86, and Glibc 2.3 on x86-64 and PPC, and is well protected against future Glibc changes
• Environments Access: Environments are now first-class data objects that are easily accessible and augmentable. Helps code compilation, code walking and domain-specific language development