Cincom released VisualWorks 7 in July, 2002 as part of the Cincom Smalltalk product suite. There are a number of new features in the release, as well as continued work on existing components (Web Toolkit, Net Clients, Opentalk). Cincom has addressed the growing demand for better tools by working with Refactory, Inc. to deliver the Refactoring Browser in this release - and we have also addressed the need for better debugging tools by working with Crafted Smalltalk to deliver the PDP in this release.
VisualWorks supports x86 Windows (98, ME, NT4, 2000, XP), Macintosh (OS 9 and OS/X), Solaris, HPUX (10.x, 11.x), AIX 4.x, SGI Irix, COMPAQ True64 Unix (Alpha), and x86 Linux.
For any questions about this white paper or about Cincom Smalltalk, please contact James Robertson, the Product Manager. Particularly of interest will be our support for Web Services and SNMP.
VW 7 represents a dramatic new direction for Smalltalk. In the past, Smalltalk was seen as a monolithic, hard to integrate toolset - productive in and of itself, but often difficult to bring into existing projects.
This release changes all of that. VisualWorks now has support for all major internet protocols - including SOAP and WSDL. Additionally, VisualWorks now supports interoperability standards such as SNMP and ASN1, allowing Smalltalk applications to seamlessly plug into an enterprise infrastructure - an important feature for IS shops that need to integrate multiple applications from multiple sources.
LevelSecurity.com
This generation of Smalltalk also stands as the best way to interoperate with the existing and competing standards of .NET and J2EE. These competing systems are not easy to integrate; the competing vendors would rather fight. VisualWorks stands as a bridge between them - with CORBA support for J2EE, Web Services support for .NET, and COM support for legacy applications, VisualWorks is uniquely suited as an integration platform.
Take a look at the first two major bullet items below - the web toolkit (introduced in VisualWorks 5i.4), Web Services (introduced with VW 7), and SNMP (introduced in VW 7). These new toolsets represent a philosophical break with past do it all in the image approaches.
DigiFinancials.com
The web toolkit takes advantage of and leverages the expertise of web developers and designers who do not know Smalltalk - the web pages that are powered by the web toolkit can be built by people who do not know Smalltalk, but do know and understand web technologies.
Web Services offers a clean way to interoperate transparently with remote services, or to transparently make Smalltalk services available to others.
SNMP server support allows developers to insert management hooks into their applications, enabling management by standard network console tools. Instead of handing the IT group a special, non-conforming management interface, this release allows Smalltalk developers to have their apps fit in better with IT expectations.
Unparalleled productivity, the best tools for supporting emergent methodologies like XP, and worldwide support from Cincom - you simply can't go wrong by choosing Cincom Smalltalk. Still not sure? Visit our download site and see for yourself!
Summary of Enhancements and New Features in VisualWorks 7 - VisualWave and Web Toolkit
- Caching of WindowSpecs to improve performance
- VisualWave now has caching behavior for WindowSpecs. This makes loading of previously accessed web GUIs significantly faster
- Dynamic Page Generation and Responder framework
- Templated HTML pages can have tags for dynamically generated pieces.
- Smalltalk Server Page Support
- Cincom has added major functionality to VisualWave in order to support ASP and JSP style Smalltalk Server pages, as well as Smalltalk Servlets.
- ASP style Smalltalk Server Pages
- Custom Tag Support
- Smalltalk Servlets
- Support for both stateful and stateless dynamic page serving
- Support for web based server management
- Support for initialization file driven server management -- oriented towards the way Unix system admins normally manage servers.
- More Web Server Integration choices
- ISAPI (support for IIS)
- NSAPI (support for iPlanet)
- CGI (generic support)
- FastCGI (support for Apache)
- SNMP Server Framework
- Export of image level configuration information for adjustment through standard network console tools, allowing developers to support common standards for deployment. We will release the SNMP server framework at the beta level with caveats about our support for inter-agent APIs and some versions of the SNMP protocol.
- Base VisualWorks
- Refactoring Browser
- The baseline browser for VisualWorks is now the RB. The existing browser set will remain in the product for this release, but will be deprecated in the next one.
- The Professional Debug Package (PDP)
- VisualWorks 7 ships with the PDP as a loadable option. We will have it embedded into VisualWorks 7.1 as the default debugger. The PDP has support for all of the features developers need - breakpoints, watchpoints, and more. visit the Crafted Smalltalk site for more details.
- Updated UI and UIPainter Tools
- The UI painting tools show continued improvement. Hotkey support has been added for all UI components, definable from the painting tools.
- The Dataset widget has been overhauled with improvements from the Aragon toolset.
- The trigger Event system is now fully implemented for the widget subsystem, improving performance for cascading UI updates
- TreeView improvements
- Optional full line selection (like the Hierarchical List).
- Optional Opened, Closed and Leaf item text emphasis selectors (exceeding capability of Hierarchical List)
- Support for the Wheel mouse in all scrolling views
- Window opening options expanded - on a per window basis one can choose from the following placement types:
- Cascade, Window Center, Mouse Center, Specified Position. Also, save size and save position support, automatic or via API.
- Base system support for XBM, JPEG, and GIF image formats. Loadable (parcel) support for PNG format.
- The UI toolset will have a beta shipment of a complete overhaul that removes wrappers from the system in order to improve performance and approachability. We expect to ship this as release level in the follow-on release
- Tools - there are a number of tool improvements that will come in the 7 release
- New Parcel Loader. Tool level support for determining which components to load into the system
- New File Browser. A replacement for the aging FileBrowser tool
- Internet Connectivity Framework
- VisualWorks now has an extensive library of Internet connectivity tools. Much of this list was implemented in 5i.3 and 5i.4 - see below for the new stuff.
- MIME Framework
- Parsing of HTTP and mail messages
- FTP Client Framework
- Standard FTP client services
- HTTP and HTTPS client services
- VisualWorks now ships with complete client level support for both Http and Https.
- URI handling Framework
- Handle remote resources for FTP, HTTP, etc. as files
- IMAP Client Framework
- Standard IMAP mail client access
- POP3 Framework
- SMTP Framework
- Standard SMTP mail server access, allowing mail transmission programmatically
- SNMP Client Framework
- Standard access to SNMP services on a platform neutral basis. We will release the SNMP client framework at the beta level with caveats about our support for some versions of the SNMP protocol.
- XML Support
- XSL
- XSchema
- XPath
- XML To Object framework
- Security - SSL
- RSA, DES, and DSA (Digital Signature) support
- VisualWorks now supports fully secure communications
- StORE
- StORE is the version control system of choice for VisualWorks. It has been improved in many ways since the 5i.4 release. For a technical overview, get the StORE White Paper here.
- Cleaner, clearer support for multiple repositories
- A tool interface for defining and changing package/bundle properties, including pre-requisites
- Much improved database access speed
- Enhanced usability when extending/overriding classes from other packages.
- Ability to manipulate Bundles within the repository without loading them.
- StORE allows developers to work whether the repository is available or not. Work can proceed separately from the repository, and be synched up once the repository is available again
- StORE allows for complex versioning of Smalltalk artifacts. Methods, class definitions, shared variable definitions, and Namespaces definitions may all be overridden and versioned separately from their owning package. Unlike ENVY, this allows developers to version their own code without re-baselining the core system.
- StORE allows for incremental versioning (source) or full (binary) versioning. Incremental versioning is much faster than binary, allowing StORE developers to version as frequently as they like
- StORE enables distributed development with the merge tool. As projects fork, developers can easily resynchronize with the merging tool.
- StORE enables developers to connect to multiple repositories (using different database back ends) and keep work synchronized amongst them. Developers can use a variety of best-of-breed RDBMS back ends. The StORE API is extensible, allowing for ports to other systems easily. The VisualWorks Non-Commercial community has done PostgreSQL and DB/2 ports already!
- StORE has a solution for every client operating system supported by VisualWorks. Unlike ENVY for VisualWorks, developers can work from any system on which VisualWorks runs.
- The StORE development environment is not different from the standard VisualWorks environment. Packages are versioned parcels, so developers can easily move from development to deployment without mentally switching gears.
- Performance enhancements. All queries, publishing, and loading have optimized in this release
- Wider database support
- StORE fully supports Oracle 7.x and Oracle 8i as repository back ends
- StORE fully supports MS SQL Server 7.x as a repository back end
- PostgreSQL is now supported as a back end for StORE. The PostgreSQL interface uses sockets rather than C libraries. This allows client usage of PostgreSQL from any supported VisualWorks platform.
- Supra SQL support for StORE and VisualWorks is planned, pending some current interfacing issues. If we can resolve these issues, we will be shipping SupraSQL as a default repository back end for VisualWorks. Supra SQL is a mature, scalable Cincom database.
- DB2/UDB has community StORE support. See DB2/UDB StORE at UIUC for details
- Interbase has community StORE support. See Interbase Support at UIUC
- Distributed Smalltalk
- Interoperability updates
- Distributed Smalltalk has been updated to allow for clean interoperation with the latest Iona and Visigenic Orb products
- Opentalk
- Opentalk is the new Smalltalk to Smalltalk distribution framework. In this release, the Opentalk core (the base distribution tools) has moved into product status. The Opentalk tools (browsers, etc.) are still under development. Other priorities (Web Services, SNMP) have delayed tool level development
- Opentalk Base
- Abstract frameworks and components used to implement communication protocols
- Concrete implementations of protocols for smalltalk-to-smalltalk unicast, multicast and broadcast
- Base services immediately required to make those protocols usable, namely simple unicast and multicast event multiplexing services and a lightweight naming service
- Service Layer
- The Opentalk Service Layer in intended to consist of service implementations, useful to constructing applications, and usable with one or several protocols.
- Support for UDDI and SOAP built in to allow for SOAP web services to be built in VW and advertised from VW
- Object Engine/Virtual Machine
- Signal Handling Under Unix
- VisualWorks 7 can handle Unix signals in a way that is far easier to deal with than was previously true. In ObjectMemory, have a look at the following methods:
ObjectMemory class -- registerObject: anObject withEngineFor: purposeString
ObjectMemory class -- registrationNames
ObjectMemory class -- objectRegisteredWithEngineFor: purposeString
- Immutable Object Support.
- Immutability is implemented as a per-object "is immutable" bit that the Smalltalk compiler sets for CompiledMethods and literals there-in, and that persistence managers (an OODBMS or O/R framework) set on database proxies. When an attempt is made to assign to an instance variable of an immutable object the object gets sent attemptToAssign: aValue toIndex: theIndex. When a primitive such as at:put: or become: attempts to modify an immutable object the primitive fails. At the image level a NoModificationError is raised. In persistence context the NoModificationError then attempts to find a manager for the object refusing to be modified before delivering the error if no manager steps up to the plate. Thus persistence managers can implement facilities like transparently writing through changes to the database without modifying the code base in any way.
- Powerful New Garbage Collection and Weakness Facilities
- Ephemerons are a replacement for the current weak references semantics that solve the isolated key garbage collection problem and provide instance-based initialization. Ephemerons are "smart" weak references. They're associations whose key weakly refers to some object and whose remaining field(s) don't get traversed in order to find out if the key is reachable until the key is found to be reachable from other objects. So for example if one uses Ephemerons to attach dependents to an object the object will be an Ephemeron's key and the dependents will be stored in a collection in the Ephemeron's value. Since the Ephemeron's value isn't traversed until the key is found to be reachable elsewhere references back to the key from the dependents *don't* prevent the garbage collector from finding that the key is not referenced from elsewhere and *only* referenced from the dependents. Once the garbage collector finds that an object is only reference from ephemeron keys it scheduled any ephemerons with that key for finalization and traverses the ephemeron's referents to ensure they're not collected. To do instance based finalization simply attach an ephemeron to an object via the ephemeron's key and put the ephemeron in a set. To add dependents to an object without using an instance variable and without creating the circular reference problem in the existing DependentsFields and EventHandlers implementation simply use an EphemeronDictionary.
- Arbitrary classes of Weak collection can be created, not just WeakArray as before.
- Improved Garbage Collection Performance (introduced in 5i.4)
- The incremental collector is much improved in VisualWorks 7. It no longer flushes the VM's execution caches (the stack and nmethod zones) at the end of each incremental mark phase. The VM and current MemoryPolicy now communicate to allow the mark rate to depend on processor performance rather than hard-coded limits that were far too low This allows the incremental collector to actually work on large heaps.
- The full Garbage Collector's marking algorithm now handles mark stack overflow, meaning that full GCs no longer fail.
- The scavenger now restricts remembered table growth. This eliminates crashes due to remembered table overflow.
- The allocator now has multiple free lists for different sized free chunks. Freeing large quantities of small objects no longer brings the system to its knees.
- Polymorphic Inline Cache (introduced in 5i.3)
- The engine now uses Polymorphic Inline Caches at polymorphic send sites. The VisualWorks implementation of PICs also provides much improved doesNotUnderstand: performance, eliminating message lookups in the common case. Because PICs reduce the number of send site relinks by over an order of magnitude the engine has been able to afford to use "dirty sends", which are actually direct machine code calls, rather than "clean sends" (indirect calls) previously used on platforms with high instruction cache flush costs (e.g., those using PowerPC and AXP processors). The result is a substantial increase in Smalltalk computing performance. The subset of the standard macro benchmarks that do not perform I/O are sped up by about 25% across all processors. The Richards benchmark, which has a particularly high number of polymorphic sends, is now about 50% faster.
- Deployment Packaging (introduced in 5i.3)
- The Windows engine now supports packaging the system as a single .exe file. The Virtual Image and Splash Screen Bitmap can be added to the engine executable as resources. The image can be compressed to save space. Building the single .exe is done using a freeware resource editor ResHacker by Angus Johnson. You'll need the 3.1 release of ResHacker. (Latest and new URL is 3.4.0)