Hubbry Logo
VisualAgeVisualAgeMain
Open search
VisualAge
Community hub
VisualAge
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
VisualAge
VisualAge
VisualAge
View on Wikipedia
from Wikipedia
VisualAge
DevelopersIBM and Taligent
Initial releaseOctober 12, 1993; 32 years ago (1993-10-12)
Final release
6.0 / April 30, 2007; 18 years ago (2007-04-30)
Written inSmalltalk (original)
Java (later)
Operating systemCross-platform
Available inMultilingual
TypeSoftware development
LicenseProprietary
Websitewww-01.ibm.com/software/awdtools/vacpp

VisualAge is a family of computer integrated development environments from IBM, which supports multiple programming languages. VisualAge was first released in October 1993. It was discontinued on April 30, 2007, and its web page was removed in September 2011.[1][2] VisualAge was also marketed as VisualAge Smalltalk, and in 2005, Instantiations, Inc. acquired the worldwide rights to this product. IBM has stated that XL C/C++ is the followup product to VisualAge.[3]

Early history

[edit]

VisualAge was created in the IBM development lab in Research Triangle Park, North Carolina, which was established in 1984 and had responsibility for application development tools. The EZ-VU dialog manager product, a personal computer derivative of the user interface elements of the ISPF 327x product was one of the first products in this family. The lab also had a group which was one of the early adopters of object-oriented programming technologies within IBM using an internally developed language called ClassC to develop applications with more sophisticated graphical user interfaces which were just starting to be widely available.

Eventually, the availability of usable implementations of Smalltalk for IBM PC-AT class machines allowed IBM advanced technology projects to experiment with Smalltalk. At about the same time, visual interface construction tools were coming up on the radar screens. Smalltalk research projects such as InterCons by David N. Smith of IBM, and Fabrik by a team at Apple led by Dan Ingalls were building interactive graphical applications built from composition of graphical primitives. Higher level construction of user interfaces was evidenced by other tools such as Jean-Marie Hullot's interface builder first done in Lisp and then evolved to become the Interface Builder tool in NeXTStep and Mac OS X. Such tools allow for building user interfaces by WYSIWYG composition of UI widgets which can be "wired" to each other and to application logic written in the system's native object oriented language, or possibly with no coding at all.

The original prototype which led to VisualAge was an attempt "to make something like the NeXT interface builder"[4] within the Smalltalk/V development environment. By the time VisualAge was released as a product, much more emphasis was placed on visual construction of application logic as well as of the user interface. This emphasis was in part due to the "positioning" for "strategic" reasons of Smalltalk as a generator rather than a language within IBM's Systems Application Architecture.

VisualAge

[edit]

The name "VisualAge" is the result of a contest between the members of the development team. After the initial release of VisualAge/Smalltalk the name VisualAge became a brand of its own and VisualAges were produced for several different combinations of languages and platforms.

This is the eventual total of supported languages, variously available depending on the platform: BASIC, COBOL, C, C++, EGL, Fortran, Java, Pacbase, PL/I, IBM RPG, and Smalltalk.

This is the eventual total of supported platforms, each of which support different languages: AIX, OS/2, i5/OS (formerly named OS/400), Linux, Mac OS X, Microsoft Windows, TPF, z/VM, z/OS (formerly named OS/390, MVS), and z/VSE.

In 1992, Apple and IBM cofounded Taligent, based upon Pink, an operating system with a mass of sophisticated object-oriented compiler and application framework technology from Apple. Pink became CommonPoint, the partnership was dissolved, and CommonPoint was absorbed into VisualAge starting with the Compound Document Framework to handle OLE objects in VisualAge C++ 3.5 for Windows. In February 1997, the first mass release of Taligent technology came in the form of the Open Class within VisualAge C++ 4.0. This bundled SDK adaptation includes CommonPoint's frameworks for desktop (infrastructure for building unified OCX or OpenDoc components), web (called WebRunner, for making drag-and-drop compound documents for the web, and server CGIs), graphics for 2D GUI, international text for Unicode, filesystems, printing, and unit tests. PC Magazine said "Now, the best of the CommonPoint technology is being channeled into Open Class for VisualAge. ... For sheer breadth of features, the Taligent frameworks are unmatched. An all-encompassing OOP framework has always proved a difficult ideal to realize, but VisualAge's Open Class Technology Preview is by far the most credible attempt we've seen.".[5]

Most of the members of the VisualAge family were written in Smalltalk no matter which language they supported for development. The IBM implementation of Smalltalk was produced by Object Technology International which was acquired by IBM and run as a wholly owned subsidiary for several years before being absorbed into the overall IBM organization.

VisualAge for Java is based on an extended Smalltalk virtual machine which executes both Smalltalk and Java byte codes. Java natives were actually implemented in Smalltalk.[6]

VisualAge Micro Edition, which supports development of embedded Java applications and cross system development, is a reimplementation of the IDE in Java. This version of VisualAge morphed into the Eclipse Framework.

Various members of the family have been replaced by products in the WebSphere Studio family of products. By 2005, Smalltalk specialist Instantiations, Inc. had assumed technical support responsibilities and been granted global rights to the IBM VisualAge Smalltalk product line and technology base.[7] Instantiations continues to offer the “enhanced product” named VA Smalltalk (VAST Platform).[8][9] The C, C++ and Fortran compiler on AIX, Linux and z/OS are renamed as XL C/C++ series.

Releases

[edit]

Applications designed with VisualAge C++ may be portable between target platforms without any code changes needed if VisualAge guidelines were followed. IBM also included additional tools and libraries in instances where portability was not possible without code changes.[10]

OS/2 and Windows

[edit]
  • VisualAge C++ 3.0 (OS/2 and Windows)
  • VisualAge C++ 3.5 (Windows 95/NT only)
  • C and C++ Compilers for OS/2, AIX and Windows NT Version 3.6
  • VisualAge C++ Professional 4.0 (OS/2 and Windows)
  • VisualAge Generator Developer V3.1 for OS/2
  • VisualAge Generator Server V3.1 for OS/2[11]
  • VisualAge for OS/2 1.0 (1993-10-12)[1]
  • VisualAge COBOL for OS/2 1.0 (1994-03-29)[12]
  • VisualAge for COBOL for OS/2 1.1
  • VisualAge for COBOL for OS/2 1.2
  • VisualAge for COBOL for OS/2, Version 1 Release 2
  • VisualAge COBOL for OS/2 2.0
  • VisualAge for COBOL Version 2.1
  • VisualAge COBOL 2.2
  • VisualAge COBOL Enterprise 3.07 (Windows only)

OS/400

[edit]
  • VisualAge C++ for AS/400 V3R6
  • VisualAge C++ for AS/400 V3R7
  • VisualAge C++ for AS/400 V4R4

AIX

[edit]
  • VisualAge C++ Professional for AIX
  • VisualAge C++ Professional for AIX, V5.0
  • VisualAge C++ Professional for AIX, V6.0

POWER Linux

[edit]
  • VisualAge C++ V6.0 for Linux
  • VisualAge C++ V6.0 for Linux refresh

POWER MacOS X

[edit]
  • VisualAge XL C++ V6.0 for Power MacOS X (10.2, 10.3)
  • VisualAge XL C++ V6.0 for Power MacOS X (10.2, 10.3)
  • VisualAge XL Fortran V8.1 for Power MacOS X (10.2, 10.3)

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

VisualAge

View on Grokipedia
from Grokipedia
VisualAge is a family of object-oriented integrated development environments (IDEs) developed by , designed to support application development in multiple programming languages including Smalltalk, C++, , , and fourth-generation languages (4GLs). Introduced in 1993, the suite originated with VisualAge for Smalltalk and expanded in the 1990s to include tools like VisualAge for C++, VisualAge for COBOL, VisualAge for PacBase, and VisualAge for Java, enabling developers to build cross-platform applications with visual programming interfaces and reusable components. The VisualAge products targeted a range of platforms, initially focusing on and later extending to Windows, AIX, , Mac OS X, AS/400, /ESA, and mainframe environments, which facilitated multiplatform development for . Notable for their emphasis on productivity through graphical tools, team collaboration features, and integration with IBM's database and technologies, the suite was widely adopted in the for creating robust business applications. For instance, VisualAge Generator, a key component, evolved from IBM's 1981 Cross System Product (CSP)—a COBOL-like 4GL for mainframe development—and was rebranded under the VisualAge umbrella in 1996, supporting code generation in , C++, or across over 20 platforms. By the early 2000s, many VisualAge tools transitioned into IBM's broader ecosystem, with VisualAge for Java merging into WebSphere Studio in late 2001 to incorporate advanced web and enterprise (EJB) support, marking the evolution toward modern IDEs like Eclipse-based successors; the suite was officially discontinued by on April 30, 2007. This shift reflected IBM's strategic focus on web-enabled development, though legacy VisualAge installations continued in specialized environments for mission-critical systems, and components such as VA Smalltalk remain supported by third parties as of 2025.

Introduction

Overview

VisualAge is a family of integrated development environments (IDEs) developed by , designed to support visual programming paradigms and multiple programming languages for building enterprise-level applications. The suite emphasized (RAD) by integrating tools such as graphical editors, debuggers, browsers, and code generators, allowing developers to compose applications visually while generating underlying code automatically. At its core, VisualAge's architecture was rooted in object-oriented principles, drawing significant influence from the Smalltalk to enable dynamic, repository-based development environments that facilitated seamless integration of components across distributed systems. This approach supported the creation of scalable, mission-critical applications through visual composition and automated code production, streamlining workflows for engineering. IBM first announced VisualAge in October 1993, with the initial releases focusing on object-oriented tools for platforms like and Windows. Various editions reached their final major versions in the mid-2000s, with end-of-support for most declared on April 30, 2007, after which ceased official maintenance for the suite. The product's web page was removed in September 2011, signifying the complete termination of 's official support. VisualAge supported languages including BASIC, COBOL, C, C++, EGL, Java, PL/I, RPG, and Smalltalk, and ran on platforms such as AIX, OS/2, i5/OS, Linux, Mac OS X, Windows, and z/OS.

Key Features

VisualAge provided an integrated visual composition editor that enabled developers to assemble user interfaces and components through drag-and-drop operations, facilitating rapid prototyping of graphical applications without extensive manual coding. This editor supported the connection of visual parts via palettes, allowing for intuitive GUI design and event handling across the suite's products. Central to the suite was its built-in repository system, which managed , enabled team collaboration, and promoted the reuse of development parts, such as Encina components for support. The repository, often implemented via technology, stored objects in a centralized or distributed manner, ensuring consistency and for large-scale projects. Debugging capabilities included step-through execution, breakpoints, and real-time object inspection, allowing developers to trace program flow and examine variables during runtime. These tools extended to distributed environments, supporting remote across platforms like Windows, AIX, and OS/390. The suite excelled in code generation from high-level models, automating the transition from prototypes to deployable production code for various targets, including enterprise systems. This feature streamlined development by producing optimized output in languages like , , and C++. Extensibility was achieved through plugin architectures and seamless integration with 's , such as DB2 for database access and WebSphere for deployment. Developers could incorporate third-party tools via APIs, enhancing workflow customization. A multi-language support framework underpinned the suite, permitting mixed-language projects within a unified workspace and fostering among components developed in different languages. This allowed for hybrid applications combining, for instance, Smalltalk and elements.

Historical Development

Origins and Early Innovations

The origins of VisualAge trace back to 's strategic push in the early to advance application development tools for enterprise environments. In , IBM launched the Cross System Product (CSP), a mainframe-oriented application generator that employed a COBOL-like fourth-generation language (4GL) scripting system to abstract platform complexities and facilitate database-integrated development. This innovation allowed data processing professionals to build systems more efficiently, initially supporting file systems like VSAM and later extending to relational databases such as DB2 by the mid-1980s. CSP's focus on and code generation for business applications provided a foundational paradigm for subsequent visual tools, emphasizing productivity gains in complex, data-driven software creation. Central to these efforts was the establishment of 's development laboratory in , in , which became the primary hub for innovating object-oriented development environments. The lab, located in , was initially staffed by IBM engineers transferred from various divisions across the company, pooling expertise in systems software, user interfaces, and database technologies to tackle emerging challenges in personal computing and client-server architectures. Early work at the facility shifted toward object-oriented principles, drawing on internal experiments with languages like Smalltalk on IBM PC-AT hardware and tools such as the EZ-VU dialog manager—a PC adaptation of the ISPF interface for 3270 terminals—to prototype graphical application builders. These initiatives aimed to evolve beyond CSP's text-based scripting by incorporating visual metaphors for software construction, aligning with IBM's broader Systems Application Architecture (SAA) standards for consistent user experiences across platforms. In the late , the Cary lab produced internal prototypes that pioneered visual programming paradigms, integrating graphical user interfaces tailored for IBM's operating system and influenced by contemporary GUI standards from systems like the Macintosh and emerging Windows environments. These prototypes sought to simplify the development of enterprise applications by enabling drag-and-drop construction of user interfaces and logic flows, reducing reliance on verbose coding and allowing non-specialist developers to handle intricate database interactions and event-driven behaviors. For instance, the Italian healthcare system SISL, an obsolete mainframe-based designed to support decentralized healthcare , highlighted the need for such visual extensions to manage operations more intuitively, as it was later replaced by a VisualAge-based solution. This pre-release experimentation at the lab laid the groundwork for a unified IDE family, culminating in the 1993 product launch without delving into specific post-release details.

Major Milestones and Collaborations

VisualAge marked IBM's entry into the visual (IDE) market with the release of VisualAge for version 1.0 on October 12, 1993. This launch represented a significant shift toward object-oriented, graphical programming tools, building on IBM's earlier internal developments to compete with emerging visual tools from competitors. In 1997, VisualAge C++ version 4.0 integrated Taligent's Open Class libraries, derived from the CommonPoint framework, which enhanced cross-platform (GUI) development capabilities. This integration stemmed from IBM's absorption of Taligent, a originally formed in 1992 with Apple and to advance object-oriented technologies, allowing VisualAge to incorporate sophisticated C++ class libraries for portable application building. Over its lifecycle, VisualAge evolved from a standalone IDE suite to one tightly integrated with IBM's WebSphere platform, particularly through versions like VisualAge for , which embedded the WebSphere Test Environment for servlet and Enterprise JavaBean development starting around 1998. This progression facilitated enterprise application development, achieving peak adoption in sectors such as banking for mission-critical systems requiring robust object-oriented tools. Key collaborations included the Taligent partnership, which infused advanced object technologies into VisualAge products, and later influences from the , as VisualAge's architecture inspired Eclipse's design when IBM open-sourced it in 2001 to address limitations in collaborative development. In 2005, IBM transferred worldwide rights to VisualAge Smalltalk to Instantiations, Inc., as part of a transition strategy emphasizing Java-focused tools. Following the transfer, Instantiations rebranded it as VA Smalltalk and has continued its development and support, with the latest versions available as of 2025. VisualAge reached its final milestone with discontinuation on April 30, 2007, after which directed users toward successor products like Rational and WebSphere Studio.

Product Line

VisualAge Smalltalk

VisualAge Smalltalk is an industrial-strength, multi-platform development system for the Smalltalk programming language, originally developed by and first released in 1993. It provides a comprehensive (IDE) centered on Smalltalk's pure object-oriented paradigm, enabling developers to build robust applications through dynamic, . As a core component of the VisualAge family, it emphasizes exploratory development and runtime extensibility, distinguishing it from more static language environments. Central to its workflow are specialized tools that leverage Smalltalk's interactive nature, including a pure object browser for inspecting and navigating classes, methods, and hierarchies in real-time. Developers use a workspace for , where expressions can be evaluated directly within the running system to test and refine code incrementally. Image-based persistence forms the foundation of its , allowing the entire runtime environment—including objects, code, and modifications—to be saved as a snapshot file for resumption, , or distribution. These features support a seamless blend of , , and execution, fostering and maintenance in object-oriented designs. The product's release history began with the initial version in 1993, which established its multi-platform capabilities across desktop and server environments. Over the following decade, it evolved under to incorporate support for , including enhancements for remote and networked applications. In 2005, development rights transferred to Instantiations, which released VA Smalltalk 7.0.0 in August as a fully compatible successor to IBM's VisualAge Smalltalk 6.0.2, maintaining while introducing ongoing updates such as 64-bit support in 7.5.2 (2007) and integration in later versions, with the latest being 14.1.0 released in August 2025. Post-transfer, the platform has continued to receive enhancements, including compilers and web technology integrations, ensuring its relevance for modern enterprise needs. VisualAge Smalltalk found primary use in enterprise applications demanding dynamic and runtime reflection, such as complex systems where iterative development accelerates adaptation to changing requirements. Later versions integrated built-in support for CORBA to enable communication and Java bridging libraries for interoperability with JVM-based ecosystems. These capabilities allowed deployment to diverse environments like servers and infrastructures, powering scalable solutions in sectors requiring high reliability and flexibility.

VisualAge for Java

VisualAge for Java was launched in the late 1990s as IBM's flagship (IDE) for , with an initial beta version available earlier in 1997 and version 1.0 released in July 1997. It was built on the Smalltalk heritage to enable of applications, adapting object-oriented principles from earlier VisualAge tools. Key features included a visual composition editor for assembling through drag-and-drop interfaces, which simplified the creation of graphical user interfaces and component-based applications. The IDE also provided Team Connection for collaborative development via shared repositories and , allowing multiple developers to manage projects efficiently. Built-in support for J2EE technologies, including integration with WebSphere , enabled the development of enterprise-level servlets, applets, and distributed components. The release timeline progressed with version 3.0 in 2000, which introduced enhanced tools for and server-side development, along with improved and features for data access. By version 4.0 in 2001, it offered seamless integration with WebSphere Studio, facilitating the exchange of Java classes and components between the tools for hybrid workflows. These updates emphasized visual assembly to reduce , allowing developers to focus on rather than low-level implementation details. As part of IBM's strategic push toward in the late , VisualAge for Java played a central role in the "Java everywhere" initiative, promoting Java as a platform-agnostic language for web and enterprise applications across IBM's ecosystem. It was widely adopted for building scalable e-business solutions, including multi-tier applications that leveraged and J2EE for rapid deployment on servers like WebSphere.

VisualAge for C++

VisualAge for C++ evolved from 's earlier C Set++, a 32-bit C and C++ development system introduced in 1992 alongside Version 2.0. In 1995, with the release of version 3.0, rebranded it as VisualAge C++, positioning it as the first product in the VisualAge family to bear that name and offering it as a free upgrade to existing C Set++ 2.1 users. This transition integrated the VisualAge (IDE), originally developed for Smalltalk, with the C Set++ compiler and tools, enabling a more unified workflow for C++ development on platforms like . The product emphasized low-level development with key features including a graphical class browser for navigating and editing C++ code structures within the IDE, an optimizing compiler tailored for AIX and that generated efficient through techniques like and , and integration with the Open Class library for building graphical user interfaces (GUIs). The Open Class library, derived from Taligent's object-oriented frameworks, provided cross-platform GUI components such as windows, menus, and event handlers, allowing developers to create portable applications without direct reliance on platform-specific APIs. Notable releases included version 4.0 in December 1998, which expanded support to AIX and enhanced ANSI/ISO C++ compliance with improved template handling and incremental compilation for faster build times. Version 5.0, released in March 2000, introduced a makefile-based alongside the visual IDE and provided a complete implementation of the ANSI (STL), enabling better adherence to the C++ standard for container and algorithm usage. VisualAge for C++ targeted system-level programming, where its supported low-level hardware interactions on systems like AIX, as well as performance-critical software requiring efficient code generation for resource-constrained environments. It was particularly suited for developing embedded applications and high-performance utilities on and AIX, leveraging the IDE's browser and for complex codebases. Following the discontinuation of VisualAge branding in the mid-2000s, transitioned to the XL C/C++ compiler family as its successor, rebranding VisualAge C++ Professional for AIX version 7.0 directly into XL C/C++ to maintain continuity in optimization and standards support.

VisualAge Generator

VisualAge Generator originated from 's Cross System Product (CSP), a mainframe application development tool introduced in 1981 that utilized a COBOL-like fourth-generation language (4GL) for creating online transaction systems. It also drew on the scripting capabilities of the SISL (Sistema Informativo Sanitario Locale) system, a mainframe-based healthcare application from the , enabling reuse of existing logic through CSP-compatible scripts. Renamed and rebranded as VisualAge Generator in 1996, it shifted focus toward visual modeling to support client/server architectures and . The core functionality of VisualAge Generator centered on a drag-and-drop modeler that allowed developers to create applications visually, generating code in , C++, or from UML-like diagrams and database schemas. This model-driven approach automated the creation of multi-tier applications, including graphical user interfaces (GUIs) and server-side logic, while supporting integration with relational databases such as DB2 for mapping relational data to object-oriented structures. Key features included templates for database-driven applications, reusable components for common tasks like , and built-in rules to ensure model consistency before code generation. Version 3.0, released in , introduced web support to extend traditional enterprise applications to browser-based interfaces, alongside enhanced DB2 integration for stored procedures and relational-to-object mapping. Subsequent updates, such as Version 3.1, added Gateway and ODBC connectivity to broaden platform compatibility. VisualAge Generator found primary use in rapid legacy modernization, where it facilitated the migration of mainframe applications to modern client/server or web environments, as seen in projects like the SISL2000 healthcare system overhaul and Texaco Brasil's enterprise updates. It also excelled in developing applications for platforms like and IMS, enabling scalable, mission-critical systems with minimal custom development. Among its strengths, VisualAge Generator reduced manual coding efforts by 70-80% through automated generation from models, reusable parts for common functionalities, and validation rules that enforced design integrity across the development lifecycle. This efficiency stemmed from its platform-neutral 4GL and template-based workflows, allowing developers to focus on rather than . It maintained general compatibility with other VisualAge IDEs for seamless deployment in mixed-language environments.

Other Language Editions

VisualAge for BASIC was an integrated development environment tailored for creating event-driven applications on and Windows platforms, featuring a visual form that enabled developers to build graphical user interfaces and server procedures using reusable objects. Released in version 1.0 in 1996, it supported DB2 database integration and focused on rapid development of client-server applications without requiring extensive coding. VisualAge for provided tools for modernizing legacy mainframe applications, including an enhanced screen painter for designing user interfaces and seamless DB2 integration to facilitate migration to distributed environments. Version 3.0, released in 1998, introduced object-oriented extensions and Direct-to-SOM support for and Windows, allowing developers to create graphical applications with visual builders. The VisualAge edition targeted legacy system maintenance and development, offering a workstation-based environment for editing, compiling, and debugging code on and Windows. As a follow-on to for version 1.2, version 2.0 included standard and enterprise editions with features like a language-sensitive editor, remote compilation tools, and integration with host systems for PDS/PDSE dataset management. VisualAge for RPG supported client-server application development for the (AS/400) platform, enabling RPG programmers to create graphical interfaces on Windows clients. Introduced in the mid-1990s, it provided visual design tools for screens and reports, along with and compilation features integrated with the AS/400 backend, emphasizing productivity for business applications. VisualAge Pacbase served as a structured tool for development on mainframes, generating code from high-level specifications to support enterprise applications. Acquired by from CGI in 1993 and renamed in 1997, it operated on and non-IBM mainframes, integrating with tools like WebSphere Studio for client-side extensions. These editions shared visual programming tools adapted from the core VisualAge framework, prioritizing productivity enhancements for procedural languages over object-oriented paradigms, and were typically bundled in late-1990s enterprise development suites before support tapered off.

Platform Adaptations

OS/2 and Windows Versions

VisualAge for was initially released as version 1.0 in October 1993, providing an primarily for with Smalltalk, and it leveraged the Workplace Shell for seamless native integration with the OS/2 . This version emphasized support for OS/2's Presentation Manager (PM) widgets, enabling developers to create applications that directly utilized PM's components for windowed interactions and resource management. The environment was designed for client-server application development, with tools for visual composition and tailored to OS/2's multitasking capabilities. The Windows port of VisualAge followed in 1994 with , expanding the product line to support Win32 visuals for building native Windows applications, including integration with the and 95 platforms. By version 3.5 in 1997, enhancements supported interoperability with technologies. Version 4.5, released in 1998, introduced unified repository sharing across and Windows, enabling cross-platform code management and deployment for editions like Smalltalk. The final major release, version 6.0 around 2002, supported platforms including . VisualAge's adaptations for and Windows were particularly dominant in early enterprise migrations from mainframe systems to desktop environments, where tools like VisualAge Generator enabled the modernization of legacy and CSP applications to client-server architectures on these platforms.

AIX and Unix-like Systems

VisualAge C++ debuted on AIX in 1995 as part of the VisualAge family, specifically tailored for the RS/6000 hardware platform running AIX 3.0, enabling developers to leverage the system's RISC-based POWER architecture for high-performance computing tasks. This adaptation emphasized server-oriented development, providing tools for building robust, scalable applications in enterprise environments. Optimized for AIX's kernel and hardware features, it supported multi-user scenarios common in Unix systems, facilitating collaborative development across networked workstations. Key Unix features integrated into VisualAge for AIX included X11 and Motif for graphical user interfaces, allowing developers to design and debug applications with a consistent windowing environment suitable for remote access over networks. (NFS) support enabled distributed team workflows by sharing project files across Unix machines, while full compliance ensured portability and adherence to Unix standards for threading, signals, and file operations. These elements made VisualAge particularly effective for server-side programming on AIX, where reliability and interoperability were paramount. Subsequent releases enhanced AIX-specific capabilities; for instance, version 4.0, released in 1998, introduced advanced support for AIX's threading model, improving concurrency in multi-threaded applications. In 2003, VisualAge C++ version 6.0 was ported to on POWER systems, aligning with open-source initiatives and extending development to environments while maintaining compatibility with POWER hardware. Porting VisualAge's object-oriented models to Unix kernels presented challenges, particularly in managing dynamic linking and runtime behaviors across diverse Unix variants. These were addressed through the use of shared libraries, which allowed modular loading of components without recompiling the entire IDE, ensuring stability on AIX and other Unix-like systems.

IBM i, Mainframes, and Other Platforms

VisualAge for RPG, a key component of the product line, was adapted for the AS/400 platform running OS/400, with initial support introduced in 1996 as part of the Application Development ToolSet Client/Server for AS/400. This adaptation enabled developers to create graphical user interface (GUI) applications using RPG IV on client platforms such as Windows 95, Windows NT, OS/2, and Windows 3.1, while leveraging server-side access to AS/400 databases via DB2/400. The tool integrated RPG IV operation codes like CHAIN, READ, and WRITE for database interactions, along with enhancements such as prototyping (D-specs and P-specs), event-driven subroutines (BEGACT/ENDACT), and transaction control (COMMIT/SHARE(*YES) for shared open data paths). It supported client/server architectures through features like the GUI Designer for drag-and-drop interface building, remote file overrides (OVRDBF), and calls to AS/400 programs via QCMDEXC APIs, facilitating reuse of existing OS/400 display files and local PC file operations. Compatibility extended to OS/400 V3R1 and later releases up to V3R7M0, with PTFs like SF32580 enabling shared ODP support for efficient data access. As OS/400 evolved into i5/OS with the i5 server line in 2004, VisualAge for RPG continued to support enterprise-scale development, though it was gradually integrated into successor tools like Development Studio Client for iSeries by version 6.0 around 2004. This version emphasized visual development, code generation without runtime licenses, and integration with CODE/400 for editing, compiling, and debugging, allowing seamless enhancement of applications with custom parts and components. The focus remained on batch and interactive processing for enterprise environments, prioritizing RPG IV's strengths in over exhaustive GUI features. For mainframes, VisualAge adaptations targeted and environments starting in the late 1990s, with VisualAge PL/I for serving as a replacement for earlier PL/I compilers like PL/I for MVS & VM. This edition supported and for batch job development, enabling compilation and execution on platforms with integration into the Language Environment for runtime services. VisualAge TPF, a specialized toolkit released in 1997, addressed high-volume on Transaction Processing Facility (TPF) systems, supporting assembler, , and C++ programs for real-time environments like reservations. Its successor, the TPF Toolkit version 2.0, was released in March 2004 and included features like remote compile/assemble via Remote System Explorer, synchronous BBSTAPI modes with timeouts, and build tools (e.g., MakeTPF) for scalable, 24/7 operations handling continuous transaction loads. Unique to these mainframe adaptations was deep integration with transaction monitors such as and IMS for enterprise reliability. VisualAge Generator, for instance, produced COBOL code deployable to and IMS TM, supporting pseudoconversational modes, temporary storage queues, SYNCPOINT commits, and DL/I database calls with rollback recovery. It handled resource tables (PPT, PCT, FCT), error diagnostics (e.g., ELAZ transaction for tracing), and via tools like CICSPARS/VSE, ensuring high-throughput processing in locked, multi-user environments. Support extended to smaller mainframe systems via z/VSE, where VisualAge Generator enabled COBOL application generation for VSE/ESA 1.3.2 and later, including 24-bit and 31-bit addressing modes. It integrated with CICS/VSE 2.3+, Language Environment for VSE 1.4+, and IBM COBOL for VSE 1.1+, supporting VSAM files, DB2/VSE (with precompiling), and DL/I DOS/VS for hierarchical data access in batch and CICS contexts. Features included map segmentation, DBCS terminal compatibility, and runtime JCL/REXX execs for VM CMS, with storage allocations like 6KB per segmented application in CICS temporary storage. Limited adaptations appeared for Linux on z, primarily through VisualAge PL/I extensions, but these were not as extensively documented for production-scale use. Most VisualAge variants for these platforms were discontinued by April 30, 2007, aligning with IBM's broader phase-out of the product family, though specific editions like VisualAge Smalltalk Server for z/OS lingered until April 2010. Earlier components, such as VisualAge Generator Developer for OS/2 tied to i5/OS workflows, ended support by May 31, 2000, prompting migrations to WebSphere Studio and Rational tools for ongoing mainframe and IBM i development.

Legacy and Discontinuation

End of Support and Transition

officially discontinued support for most VisualAge editions, including VisualAge C++ Professional V6.0 and C for AIX V6.0, effective April 30, 2007, marking version 6.0 as the final release for these products. This withdrawal applied across key platforms such as AIX, with no further updates or fixes provided after that date. For VisualAge Smalltalk Enterprise V6, service discontinuance occurred earlier on April 30, 2006. Support phases varied by edition and platform. In 2005, Instantiations, Inc. acquired worldwide rights to VisualAge Smalltalk from , assuming responsibility for its development and maintenance under the name VA Smalltalk, which enabled continued enhancements beyond 's involvement. Extended maintenance for VisualAge Smalltalk Server on and lasted until April 2010, after which Instantiations also ended support for related products. To facilitate the transition, released migration guides directing users toward Eclipse-based development tools. For instance, documentation outlined processes for porting VisualAge for Java projects to the Eclipse Visual Editor, including repository exports and compatibility adjustments. Similarly, VisualAge Generator users were guided to Enterprise Generation Language (EGL) tools within Rational Business Developer, with step-by-step instructions for code conversion and integration. Key assets, such as Smalltalk intellectual property, were transferred to Instantiations to support ongoing user needs. The end of support posed challenges for users reliant on VisualAge, particularly in mainframe environments where legacy applications required sustained without vendor backing. Organizations often encountered difficulties in sourcing compatible updates or skilled developers familiar with VisualAge repositories and components, prompting many to undertake custom migrations to modern IDEs. This shift highlighted the broader issues of in discontinued enterprise tools.

Successors and Lasting Impact

Following the discontinuation of VisualAge products in the mid-2000s, transitioned its development tools to newer platforms, with direct successors emerging for key language editions. For VisualAge for , replaced it in late 2001 with WebSphere Studio Application Developer (WSAD), version 4.0, which integrated many of its visual composition and features while shifting toward Eclipse-based architecture. This evolved further after 's 2003 acquisition of , with WSAD being rebranded and enhanced as Rational Application Developer (RAD) starting with version 6.0 in 2004, providing comprehensive support for J2EE and WebSphere applications. For VisualAge for C++, rebranded and continued the product line as XL C/C++ around 2004, positioning it as the direct follow-on with improved optimization and cross-platform portability for AIX and other systems; support for XL C/C++, now including the Open XL C/C++ variant, continues as of 2025 with releases such as version 2.2 for in October 2025. A notable legacy product is VA Smalltalk, developed by Instantiations, Inc., which acquired rights from in 2005 to maintain and evolve VisualAge Smalltalk as a commercial . This platform remains fully compatible with original VisualAge Smalltalk applications, supporting modern operating systems like Windows, , and AIX while adding security enhancements and deployment options for multi-tier business applications. As of August 2025, Instantiations released VAST Platform 14.1.0, continuing active support and enhancements for modern platforms. VisualAge's broader influence lies in its pioneering of visual integrated development environments (IDEs), particularly through drag-and-drop composition of and Smalltalk components, which facilitated and influenced the design of subsequent tools emphasizing visual programming. Its model-driven concepts, including early support for UML-like diagramming and component-based assembly, contributed to the evolution of model-driven development in later UML tools. IBM's donation of much of VisualAge's workbench codebase to the in 2001 marked a pivotal shift from proprietary tools to open-source ecosystems, enabling to become a foundational IDE for and beyond by the mid-2000s. In terms of lasting impact, VisualAge significantly shaped IBM's enterprise adoption of , with its Enterprise Edition providing tools for integrating Java applications with mainframe systems via Enterprise Application Beans, accelerating Java's use in large-scale business environments during the late . Additionally, dissemination of technologies from Taligent—the joint venture behind VisualAge's UI framework—through IBM's contributions to helped propagate advanced object-oriented development practices into open-source communities. By the mid-2000s, this transition positioned IBM firmly within the Eclipse ecosystem, influencing widespread adoption of extensible, plugin-based IDEs in development.

References

  1. https://www.pcmag.com/encyclopedia/term/visualage
  2. https://www.instantiations.com/vast-platform/
  3. https://www.edm2.com/index.php/VisualAge_Smalltalk
  4. https://public.dhe.ibm.com/software/websphere/awdtools/visgen/visgenfuture.pdf
  5. https://www.instantiations.com/visualage-to-vast/
  6. https://www.edm2.com/index.php/IBM_VisualAge_for_OS/2
  7. https://www.edm2.com/index.php/VisualAge_for_Java
  8. https://public.dhe.ibm.com/software/websphere/awdtools/visgen/library/vagen45.pdf
  9. https://support.sdsusa.com/support/dictionary/v/
  10. https://www.ibm.com/support/pages/visualage-c-v60-and-c-aix-v60-have-prerequisites-aix-bosadt-filesets
  11. https://www.instantiations.com/company/history/ibm-transition/
  12. https://public.dhe.ibm.com/software/partners/pdf/java_ws.pdf
  13. https://public.dhe.ibm.com/software/websphere/awdtools/visgen/library/vagv5n1.pdf
  14. https://encyclopedia.pub/entry/33588
  15. https://public.dhe.ibm.com/software/websphere/awdtools/visgen/library/vagv4n1.pdf
  16. https://www.hackinghat.com/wp-content/uploads/2006/12/mvp.pdf
  17. https://www.techmonitor.ai/technology/ibm_finally_absorbs_taligent_firing_190_apple_and_hewlett_keep_rights_to_technology_stockpile/
  18. https://ftpmirror.your.org/pub/misc/ftp.software.ibm.com/software/cn/websphere/products/download/whitepapers/g3255352.pdf
  19. https://www.infoq.com/news/2011/11/eclipse-10/
  20. https://www.instantiations.com/wp-content/uploads/2022/04/ENUS905-093.pdf
  21. https://www.instantiations.com/company/history/
  22. https://www.instantiations.com/vast-platform/version-history/
  23. https://www.tug.ca/articles/Volume13/V13N1/V13N1_Jenkins_VisualAge-for-Java.html
  24. https://ecsoft2.org/ibm-visualage-java
  25. https://www.edm2.com/index.php/VisualAge_for_Java_Professional
  26. https://ftpmirror.your.org/pub/misc/ftp.software.ibm.com/software/cn/websphere/products/download/whitepapers/vaj2_whatsnewss.pdf
  27. https://ftpmirror.your.org/pub/misc/ftp.software.ibm.com/software/cn/websphere/products/download/whitepapers/sws3939i.pdf
  28. http://sunsite.uakom.sk/sunworldonline/swol-12-1997/swol-12-visualage.html
  29. https://adtmag.com/articles/2001/01/01/legacy-systems-back-in-the-limelight.aspx
  30. https://www.edm2.com/index.php/IBM_C_Set/2
  31. https://winworldpc.com/product/ibm-visualage-cpp/3x
  32. https://www.edm2.com/0704/vacpp4/vacpp4.html
  33. https://support.bull.com/ols/product/system/aix/proglang/C/VisualAgeCplusplus6.0.pdf
  34. http://ps-2.kev009.com/rs6000/docs/visualage/ioc_intro.pdf
  35. https://www.wildcrest.com/Potel/Portfolio/mvp.pdf
  36. https://www.edm2.com/index.php/VisualAge_C%252B%252B
  37. https://support.bull.com/ols/product/system/aix/proglang/C/files/doc/OLDVERSIONS/csb.vacpp5.0/index.html
  38. https://www.ibm.com/support/pages/system/files/support/swg/swgdocs.nsf/0/f16338532189441685256f010023b200/%24FILE/getstart.pdf
  39. https://ecsoft2.org/ibm-visualage-basic
  40. https://archive.org/details/VABasic
  41. https://public.dhe.ibm.com/ps/products/cobol/fixes/cob305/english/updates.htm
  42. https://public.dhe.ibm.com/software/websphere/awdtools/pli/PLIGSWIN.PDF
  43. https://www.ibm.com/docs/en/workload-automation/10.2.3?topic=seqqsamp-using-visual-age-compiler
  44. https://public.dhe.ibm.com/systems/power/docs/systemi/v5r3/en_US/sc092449.pdf
  45. https://public.dhe.ibm.com/as400/products/ad/varpg/wwreadme.html
  46. https://lookupmainframesoftware.com/soft_detail/dispsoft/2039
  47. https://public.dhe.ibm.com/software/vapacbase/pdf_e/poc251pa.pdf
  48. https://www.ibm.com/docs/en/zos/3.1.0?topic=descriptions-language-environment
  49. http://bitsavers.org/pdf/ibm/pc/os2/OS2_3.x/G25H-7103-00_OS2_WARP_V3_Presentation_Manager_Programming_Guide_The_Basics_Oct94.pdf
  50. https://public.dhe.ibm.com/ps/products/visualage/fixes/v6.0/readme604.htm
  51. https://public.dhe.ibm.com/software/websphere/awdtools/visgen/library/vagv4n2.pdf
  52. https://support.bull.com/ols/product/system/aix/proglang/C/files/doc/OLDVERSIONS/csb.vacpp6.0/index.html
  53. https://www.edm2.com/index.php/VisualAge_C%2B%2B
  54. https://www.redbooks.ibm.com/redbooks/pdfs/sg245674.pdf
  55. https://www.edm2.com/index.php/VisualAge_for_RPG
  56. https://sysadminmosaic.ru/_media/as_400/redbooks/sg242222.pdf
  57. https://public.dhe.ibm.com/systems/power/docs/systemi/v5r4/en_US/sc092449.pdf
  58. http://ftpmirror.your.org/pub/misc/ftp.software.ibm.com/as400/products/ad/wdt400/presentations/VARPG_base_13TA.pdf
  59. https://kmlinux.fjfi.cvut.cz/~oberhtom/mainframe/redbooks/le_pg.pdf
  60. https://public.dhe.ibm.com/software/htp/tpf/tpfug/tgs04/tgs04e.pdf
  61. https://public.dhe.ibm.com/software/websphere/awdtools/visgen/library/hpthse31.pdf
  62. https://www.ibm.com/support/pages/apar/II09547
  63. https://www.ibm.com/support/pages/april-2007-c-aix-v60-ptf
  64. https://comp.lang.smalltalk.narkive.com/8A1rMmrs/ann-instantiations-to-take-lead-on-va-smalltalk.2
  65. https://www.eclipse.org/forums/index.php/t/13704/
  66. https://public.dhe.ibm.com/software/dw/rational/pdf/vagenmig_6011ifix3.pdf
  67. https://stackoverflow.com/questions/9935871/migrating-from-visualage-for-java-to-eclipse
  68. https://encyclopedia.pub/entry/30169
  69. https://community.ibm.com/community/user/blogs/jc-yao/2025/10/30/open-xl-cpp-22-for-zos
  70. https://www.edm2.com/index.php/IBM_VisualAge_Smalltalk_Enterprise_6.0
  71. https://ftpmirror.your.org/pub/misc/ftp.software.ibm.com/software/lotus/pub/lotusweb/product/devtools/redbook/SG242232.pdf
Add your contribution
Related Hubs
User Avatar
No comments yet.