Allegro CL 9.0

Persistency built in, not a database add-on

Allegro CL&reg is the most powerful dynamic
object-oriented development system available today, and is especially suited to
enterprise-wide, complex application development. Complex
applications with billions of objects are now made easy with
Allegro CL 9.0. 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 9.0
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.

Franz's ACL 9.0 release is a major advance. It brings true SMP to one
of the best programming environments available. All our existing
multithreaded applications "just work" and run much faster than before
on the same hardware.

Enhancements

Major update to AllegroServe. Automatic compression and inflation
of files, chunking support, and new choices for security, including
the TLS v1.0 (also called SSL v3.1) protocol for secure
communications. See aserve.html

Overview

Powered by Common Lisp, Allegro CL's true dynamic object technology
allows developers to generate leading edge, mission-critical
applications that are robust, extensible, and easy to evolve and
deploy.

AllegroCache
-- The enabling technology behind Allegro CL 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

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 263 - 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 263 - 1)

The Allegro CL Source Stepper

The new Allegro CL Source Stepper is an offering unique to existing
Lisp debuggers, and in fact probably unique to source-level
debuggers provided by other languages. The new Allegro Source Stepper
provides the following:

Debug/stepping info can be loaded on demand, without recompiling
the function under debug.

Assembler instructions can be displayed and stepped.

Macros are rendered transparent, allowing macro forms as well
as all levels of their expansions to fully participate in the
debug process.

Language personalities can be defined and loaded, which customize
the debugger behavior for domain specific languages implemented in
Common Lisp.

The source stepper displays source code while stepping
through a form. When using it with
the IDE, (not
available on Sparc or AIX platforms) the source stepper is associated
with the
new Stepper
Dialog. The Stepper Dialog allows carefully testing compiled code
by interrupting execution at selected forms in the original source
code and at macroexpansions of the code, allowing state to be examined
at each stop point.

The dialog displays the original lisp source code for a function or
method that is being stepped through, highlighting the form at which
the stepper is stopped. Button widgets allow proceding in various
ways each time execution has been interrupted. The dialog also
displays macroexpanded forms and the values of arguments and local
variables, updated after each step. The IDE's code editor can be
invoked at any time on the code being stepped through.

Stepper Dialog Example (click on picture to enlarge)

The Definition Pane

The Definition Pane (at the top of the dialog) shows the
source code for the function or method that's currently being stepped
through. This is a copy of the real source code text, complete with
comments and original line breaks. The form at which the stepper is
currently stopped will be highlighted with a different background
color. Red parentheses are drawn around any breakpointed forms. The
breakpointable form under the mouse (if any) in the Definition Pane
will have a blue border drawn around it.

The form in the Definition Pane where the stepper is stopped is
drawn with a background color that can have different meanings. An
explanatory note will appear in the dialog the first three times each
highlighting color is used. The default color is blue. When green,
source-level debugging information is available for the function that
the highlighted form will call. This is a "green light"
that pressing the Step Into button will continue doing source-level
stepping. When orange, you are stopped at a macro form. When gray, it
means that no source code range is known for the current step
point.

The Form Pane

The Form Pane (second from the top) shows just the form at
which the stepper is currently stopped. This form would be executed
by a subsequent Step Next. Sometimes this is a form in the original
source code, and is the same as the highlighted form in the Definition
Pane, and at other times it is all or part of a macroexpansion.

The Stack Pane

The Stack Pane (third from the top) lists the arguments
and local variables of the function that is being stepped through,
followed by the arguments to the function that called the function
being stepped, and then by the arguments to to the next calling
function.

Assembly-Language Stepping in the Stepper Dialog

If breakpoints are added to functions for which
source-level debugging information is not available, the Stepper
Dialog will still display some information and allow stepping to be
done.

Documentation

Please refer to the Stepper
Dialog documentation
for the full details.

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