|
Background:
 Overview
Products:
GoldWorks III
Golden Common
Lisp Developer
Golden Common
Lisp SE
Gold Connection /SQL
Gold Hill Runtime
Gold Hill Support
Features:
Why OOP, CLOS
and GoldHill?
Features and Benefits
CLOS Object System
Applications
Guest Book:
How to register
Contacts:
Who We Are
|
Why OOP, CLOS and
Gold Hill?
What is Object Oriented Programming and
why should I use it?
Object Oriented Programming (OOP) has long been
acclaimed as the most efficient methodology for
minimizing development time and maximizing code
reusability. OOP creates a modular design that is easily
modified without having to restructure the entire system.
OOP organizes objects into classes which can be cast from
a common mold, allowing classes to inherit properties
from their ancestors, and creating generic functions
which operate on multiple classes. Classes can be reused
in other projects, and generic functions and their
methods can be used again and again.
Sounds like a good idea, but which
OOP language should I choose?
CLOS, the Common LISP Object System, is a
superior OOP Language because it is a Dynamic OOP
Language.
What about C++? Isn't C++ an OOP
language?
Yes, it is, but it isn't Dynamic.
Unfortunately, many programmers wind up using C++ as
their first OOP language. Not only is C++ limited in it's
OOP abilities, but the traditional cycle of coding,
compiling, and debugging remains the same...Static.
Although OOP promotes a more modular, intuitive
architecture, it takes a considerable amount of
forethought and trial-and-error to organize data in
useful classes and to create the corresponding functions.
With C++ the only way to propagate your changes
throughout your objects is to go through the entire edit,
debug and recompile cycle every time you make a small
change in a class?
What about Smalltalk?
Smalltalk imposes restrictions that make changes
less Dynamic and decrease the
reusability of class libraries. Smalltalk's restrictive
class model does not include multiple inheritance, method
combination and mixins. This severely limits your ability
to change the system during development and at the end
user level.
Wasn't OOP supposed to reduce
development time and increase reuse of code?
Yes. That's why CLOS, the Dynamic
OOP, is the best choice. With CLOS, you can write,
evaluate, and compile code incrementally. CLOS will
propagate changes on-the-fly without any recompiling.
LISP maintains a listener with a Dynamic environment that
can be customized for individual projects. Write some
code, evaluate it immediately, try it, debug it, and then
compile it when you feel it's "right." Create
multiple classes, hundreds of instances, and then decide.
The compiled version even gets loaded into the
environment and replaces the old evaluated version. This
allows you to use a wide variety of programming styles
and get results, at any time in the development cycle.
Beyond the Dynamic nature of LISP with CLOS, there are
other benefits over C++ and Smalltalk.. CLOS supports
polymorphism (the ability to create functions which take
multiple arguments from different classes), class
conflict resolution through user-defined precedence
lists, and method-combination to determine the order of
method execution. C++ does not offer these features -
you'd have to waste hours of valuable time just to
implement these features.
OK. I know I want to program with OOP and
CLOS. Where do I start?
Gold Hill's GCLISP Developer 5.0 and
GoldWorks III ARE OOP with CLOS. Now
that you have decided to use LISP with CLOS as your
development language, you want to make sure you use the
best development tools available for your application
needs. The Gold Works III Expert System Development
Environment and GCLISP Developer are the best OOP
development environments available. Both these powerful
development tools are 32-bit suites running under Windows
3.x with WIN32S, Windows NT, Windows 95, and OS/2, the
top choices for 32-bit development and delivery today.
GCLISP and GoldWorks provide a familiar Windows interface
with pull-down menus so you'll become familiar with the
system quickly - no cryptic toolbars to learn and no
funny looking buttons. From the Listener window, you can
see your code being evaluated, compiled, traced, stepped,
timed, and debugged. From our GMACS editor, you can write
code with automatic indentation, send it to the Listener
for evaluation or compilation, cut and paste from
multiple buffers, and more. On-line help is also provided
as a reference to LISP and GMACS functions. An entire
programming project requires just two open windows on
your desktop.
Also, GCLISP and GoldWorks go beyond Common
Lisp by providing extended functionality for seamless
integration with other Windows applications. GCLISP was
the first Windows LISP to offer Dynamic Data
Exchange (DDE) which allows Windows applications to send
and receive data back and forth. Have your application's
data Dynamically sent to an Excel
spreadsheet for analysis. The productivity and
connectivity opportunities are unlimited. GCLISP was also
the first Windows LISP to offer a Foreign Function
Interface (FFI) which allows you to call functions from
other languages which have been compiled into a
Dynamic Link Library (DLL) file. Use GCLISP and
GoldWorks with your favorite TCP/IP package, or reuse a
complicated C function in your application by including
it as a DLL.
To give your application a real Windows look
and feel, GCLISP and GoldWorks include Gold Hill Windows,
Gold Hill's own LISP extension which provides access to
Windows' graphics capabilities. Create windows, pull down
menus, mouse hot-spots, bitmap graphics, scroll-bars and
more. End users will have the same familiar interface
they use with other Windows applications.
Finally, GCLISP and GoldWorks include a
32-bit compiler. Taking advantage of the advanced
platforms they operate on, these tools produce fast,
efficient, safe, compiled code. The compiler is
customizable as well, allowing the user to prioritize
speed, space, safety, and compilation time.
|
