Hubbry Logo
WebObjectsWebObjectsMain
Open search
WebObjects
Community hub
WebObjects
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
WebObjects
WebObjects
WebObjects
View on Wikipedia
from Wikipedia

WebObjects
Original authorNeXT Software Inc.
DeveloperApple Inc.
Initial releaseMarch 28, 1996; 29 years ago (1996-03-28)
Final release
5.4.3 / September 15, 2008; 17 years ago (2008-09-15)
Written inJava
Operating systemOS X
SuccessorProject Wonder
TypeWeb application server
LicenseProprietary
Websitewww.apple.com/webobjects/ Edit this on Wikidata
Project Wonder
DeveloperWebObjects Community Association
Repositorygithub.com/wocommunity
PlatformLinux, macOS, Windows, and possibly others
Available inJava
LicenseBSD-like
Websitewiki.wocommunity.org/xwiki/bin/view/WEB/Home/

WebObjects is a discontinued Java web application server and a server-based web application framework originally developed by NeXT Software, Inc.

WebObject's hallmark features are its object-orientation, database connectivity, and prototyping tools. Applications created with WebObjects can be deployed as web sites, Java WebStart desktop applications, and/or standards-based web services.

The deployment runtime is pure Java, allowing developers to deploy WebObjects applications on platforms that support Java. One can use the included WebObjects Java SE application server or deploy on third-party Java EE application servers such as JBoss, Apache Tomcat, WebLogic Server or IBM WebSphere.

WebObjects was maintained by Apple for quite a while. However, because Apple has stopped maintaining the software, it now is instead maintained by an online community of volunteers. This community calls it "Project Wonder".

History

[edit]

NeXT creates WebObjects

[edit]

WebObjects was created by NeXT Software, Inc., first publicly demonstrated at the Object World conference in 1995 and released to the public in March 1996. The time and cost benefits of rapid, object-oriented development attracted major corporations to WebObjects in the early days of e-commerce, with clients including BBC News, Dell Computer, Disney, DreamWorks SKG, Fannie Mae, GE Capital, Merrill Lynch, and Motorola.

Apple acquires NeXT, and continues to maintain the software

[edit]

Following NeXT's merger into Apple Inc. in 1997, WebObjects' public profile languished. Many early adopters later switched to alternative technologies, including Apple which had been the last remaining large client for the software, relying on it to power parts of its online Apple Store and the iTunes Store – which was WebObjects' highest-profile implementation at the time.

WebObjects was part of Apple's strategy of using software to drive hardware sales, and in 2000 the price was lowered from $50,000 (for the full deployment license) to $699. From May 2001, WebObjects was included with Mac OS X Server, and no longer required a license key for development or deployment.

WebObjects transitioned from a stand-alone product to be a part of Mac OS X with the release of version 5.3 in June 2005. The developer tools and frameworks, which previously sold for US$699, were bundled with Apple's Xcode IDE. Support for other platforms, such as Windows, was then discontinued. Apple said that it would further integrate WebObjects development tools with Xcode in future releases. This included a new EOModeler Plugin for Xcode. This strategy, however, was not pursued further.

In 2006, Apple announced the deprecation of Mac OS X's Cocoa-Java bridge with the release of Xcode 2.4 at the August 2006 Worldwide Developers Conference, and with it all dependent features, including the entire suite of WebObjects developer applications: EOModeler, EOModeler Plugin, WebObjects Builder, WebServices Assistant, RuleEditor and WOALauncher. Apple had decided to concentrate its engineering resources on the runtime engine of WebObjects, leaving the future responsibility for developer applications with the open-source community. The main open-source alternative – the Eclipse IDE with the WOLips suite of plugins – had matured to such an extent that its capabilities had, in many areas, surpassed those of Apple's own tools, which had not seen significant updates for a number of years.

Apple promised to provide assistance to the community in its efforts to extend such tools and develop new ones. In a posting to the webobjects-dev mailing list,[1] Daryl Lee from Apple's WebObjects team publicly disclosed the company's new strategy for WebObjects. It promised to "make WebObjects the best server-side runtime environment" by:

  • Improving performance, manageability, and standards compliance
  • Making WebObjects work well with Ant and the most popular IDEs, including Xcode and Eclipse
  • Opening and making public all standards and formats that WebObjects depends upon

WebObjects 5.4, which shipped with Mac OS X Leopard in October 2007, removed the license key requirement for both development and deployment of WebObjects applications on all platforms. All methods for checking license limitations were then deprecated.

The end of WebObjects, and the beginning of Project Wonder

[edit]

In 2009, Apple stopped issuing new releases of WebObjects outside Apple. The community decided to continue development with Project Wonder, an open-source framework which is built on top of the core WebObjects frameworks and which extends them. For example, Project Wonder has updated development tools and provides a REST framework that was not part of the original WebObjects package.

Though once included in the default installation of Mac OS X Server, WebObjects was no longer installed by default starting with Mac OS X Snow Leopard Server and shortly after, Apple ceased promoting or selling WebObjects. As of 2016, WebObjects is actively supported by its developer community, the "WOCommunity Association", by extending the core frameworks and providing fixes with Project Wonder. The organization last held a Worldwide WebObjects Developer Conference, WOWODC, in 2013.[2][3]

In May 2016, Apple confirmed that WebObjects had been discontinued.[4]

Tools

[edit]

As of 2016 most WebObjects architects and engineers are using the tools being developed by the WebObjects community. These tools run within the Eclipse IDE and are open-source. The WebObjects plug-ins for Eclipse are known as WOLips.

Building WebObjects frameworks and applications for deployment is typically achieved using the WOProject set of tools for Apache Ant or Apache Maven. These tools are distributed with WOLips.

Core frameworks

[edit]

A WebObjects application is essentially a server-side executable, created by combining prebuilt application framework objects with the developer's own custom code. WebObjects' frameworks can be broken down into three core parts:

  • The WebObjects Framework (WOF) is at the highest level of the system. It is responsible for the application's user interface and state management. It uses a template-based approach to take that object graph and turn it into HTML, or other tag-based information display standards, such as XML or SMIL. It provides an environment where you can use and create reusable components. Components are chunks of presentation (HTML) and functionality (Java code) often with a parameter list to enhance reusability. WebObjects Builder is used to create the HTML-templates and creates the .wod-file linking, for instance, a Java String object to interface objects like an input field in a web form.
  • The Enterprise Objects Framework (EOF) is, perhaps, the hallmark feature of WebObjects. EOF communicates with relational databases and turns database rows into an object graph. Using EOModeler the developer can create an abstraction of the database in the forms of Java objects. In order to access or insert information into the database the developer simply accesses the Java Enterprise Objects (EOs) from their business logic. After that EOF manages the Enterprise Objects and automatically creates the required SQL-code to commit the changes to the database.
  • Java Foundation. Both Enterprise Objects and WebObjects rest on the aptly named Java Foundation classes. This framework contains the fundamental data structure implementations and utilities used throughout the rest of WebObjects. Examples include basic value and collection classes, such as arrays, dictionaries (objects that contain key-value pairs) and formatting classes. Java Foundation is similar to the Foundation framework contained in Apple's Cocoa API for macOS desktop applications, however Java Foundation is written in Pure Java as opposed to Cocoa's Objective-C (with its Java bridge runtime wrapper). Foundation classes are prefixed with the letters "NS" (a reference to their NeXTSTEP OS heritage). Since the transition of WebObjects to Java in 2000, the functionality of many of Apple's Java Foundation classes is replicated in Sun's own JDK. However, they persist largely for reasons of backwards-compatibility and developers are free to use whichever frameworks they prefer.

Rules-Based Rapid Application Development (RBRAD)

[edit]

WebObjects features a set of rapid development technologies that can automatically create a Web application without the need to write any Java code. Given a model file for a database, WebObjects will create an interface supporting nine common database tasks, including querying, editing and listing. Such applications are useful for prototyping or administering a database, perhaps to check relationships or to seed the database with data.

The user interface is generated dynamically, on-the-fly at runtime using a rules-based system – no code is generated. Consequently, one can modify an application's configuration at runtime (using an assistant program) without recompiling or relaunching the application.

Developers can utilize one of three different technologies, depending upon the type of interface they wish to employ:

  • Direct To Web (D2W) allows developers to rapidly create an HTML-based Web application that accesses a database.
  • Direct To Java Client allows developers to rapidly create a client desktop application using the Java Swing toolkit. An advantage of Java Client applications is that they can take advantage of the processing power of the client computer to perform operations such as sorting a list of items received from the server.
  • Direct To Web Services allows developers to rapidly develop Web service-based applications that provide access to a data store.

Advantages of RBRAD

[edit]
  • Vastly decreased development and debugging time;
  • Increased stability through the use of highly exercised code;
  • By using the information contained in the data model file, applications will not violate database integrity. Normally you would have to write code to avoid such situations and handle errors generated by bad data;
  • Fully utilizes the validation services provided by WebObjects and Enterprise Objects.

Java compatibility

[edit]

WebObjects is a 100% Java product with the following Java-based features:

  • Deployment: Applications can be deployed on any operating system that has Java 1.3 or later. Many developers have successfully deployed on Windows and various Linux systems such as Red Hat Linux, Debian and SUSE. Applications can also be hosted on any Java EE compatible application server such as JBoss.
  • Java EE integration: WebObjects applications can be packaged in a single directory (an exploded .war file) that make it easier to deploy to a Java EE servlet container.
  • JDBC: Since WebObjects uses JDBC for database connectivity any DBMS that has a JDBC-driver can be used within WebObjects.
  • Swing interface: WebObjects applications can be delivered to the user as a "Java Client application" or as a Java applet.

Version history

[edit]

WebObjects was originally released by NeXT Computer in March 1996, but was acquired by Apple Inc. with their acquisition of NeXT in December of that year.

1.0 – March 28, 1996
  • Debut release.
2.0 – June 25, 1996
  • Pre-release version of WebObjects Builder application.
3.0 – November 1996
3.1
  • Supports a subset of the Java APIs (NT only).
3.5 – December 1997
  • Enhanced Java support (NT only): all objects and components can be worked on as a set of Java APIs based on a complete implementation of the JDK 1.1.3.
4.0 – September 1998
  • First version of WebObjects to run on the Mac platform – specifically Mac OS X Server 1.0 (a public release of the beta OS formerly code-named 'Rhapsody').
  • OPENSTEP 4.2 OS no longer supported; Windows NT now uses a new version of the OpenStep base of libraries and binary support called Yellow Box.
  • Direct actions introduced whereby actions can be sent directly to an object that can handle it, allowing for simpler, static URLs.
  • Direct to Web code-free development assistant introduced.
  • WebObjects and Enterprise Objects Framework provide thread-safe APIs. This means that you can write a multithreaded WebObjects application where you couldn't before. This enables applications that can provide user feedback for long-running requests.
  • Better tools for managing, configuring and testing the scalability of applications.
  • Java capabilities are greatly improved over previous version, however compiled Objective-C is still two to three times faster;
  • Possible to build a fully capable Java client either as a stand-alone app or as an applet with the Interface Builder - all sorts of Swing and Java Bean components are sitting on IB palettes for wiring up.
  • Developers can now debug applications on a machine that doesn't have a web server present.
  • EOF 3.0 adds support for a new database, OpenBase Lite, which ships with EOF 3.0 as an unsupported demo.
  • EOF 3.0 introduces new API, mainly in EOUtilities, to facilitate common programming tasks.
  • EOModeler adds support for prototype attributes and the ability to create and store complex queries (or EOFetchSpecifications).
4.5 – March 2000
  • Integrated XML support using IBM's alphaWorks parser.
  • New WebObjects Builder interface, specifically in the main window toolbar, the user interface for binding keys, and the table editing user interface. A path view, an API editor, and component validation have been added.
  • Application profiling tools.
  • EOF 4.5 comes with a new sample adaptor: the LDAP adaptor.
  • Direct to Web now allows you to create your own visual style and exposes a great deal of new API.
  • Java Client extended considerably, including a new user interface generation layer, Direct to Java Client.
4.5.1
  • First version to support Mac OS X 10.x and Windows 2000.
  • Last version to support HP-UX and Mac OS X Server 1.0.
  • Last version that supported the Objective-C API.
5.0[5] – May 2001
5.1[6] – January 10, 2002
  • Create and deploy Enterprise JavaBeans using the built-in container based on OpenEJB.
  • Deploy WebObjects applications as JSPs or Servlets on top of third-party application servers.
  • Access and manipulate data stored in JNDI or LDAP directory services.
  • Automatically generate desktop Java client applications with rich, interactive user interfaces.
  • Utilize the WebObjects template engine and object-relational mapping for seamless XML messaging.
5.1.2[7] – May 7, 2002
  • Contains general bug fixes for WebObjects 5.1 on all platforms.
5.1.3[8] – June 7, 2002
  • Contains targeted bug fixes for WebObjects 5.1 on all platforms.
5.1.4[9] – August 22, 2002
  • Compatibility with Mac OS X 10.2.
5.2[10] – November 12, 2002
  • Web Services support.
  • Improvements to Java EE integration
  • Java Web Start support.
  • Improvements to robustness and stability of Enterprise Objects.
  • Major bug fixes led many developers to hail this as the first stable 5.x release of WebObjects.
5.2.1[11] – March 21, 2003
  • Resolved some incompatibilities with the latest Java 1.4.1 implementation for Mac OS X.
5.2.2[12] – October 22, 2003
  • Compatibility with Mac OS X 10.3 Panther and the Xcode IDE.
  • JBoss on Panther Server qualification.
  • Qualified for Java 1.4.1.
  • Fixes for EOF runtime and WOFileUpload.
5.2.3[13] – March 16, 2004
  • Performance and stability update addressing issues with CLOSE_WAIT states in deployment using JavaMonitor and wotaskd and issues related to EOF under high load.
  • Qualified for Java 1.4.2.
5.2.4[14] – May 2, 2005
5.3 (developer) for Mac OS X 10.4[15] – June 6, 2005
  • WebObjects developer tools included free with the Xcode IDE (v2.1).
  • Development and deployment on platforms other than Mac OS X no longer supported by Apple.
  • EOModels can be created and edited within Xcode with a new EOModeler plugin that integrates with the CoreData modeling tools.
  • WebObjects Builder has UI enhancements and generates HTML 4.0.1 code.
  • WebObjects runtime now supports HTML 4.0.1.
  • NSArray, NSDictionary and NSSet now implement the java.util.Collection interfaces.
  • Axis 1.1 integrated with the Direct To WebServices feature.
  • WebObjects is qualified against Oracle 10g using the 10.1.0.2 JDBC drivers; Microsoft SQL Server 2000 8.00.194; MySQL 4.1.10a; OpenBase 8.0; Oracle 9i Enterprise Edition Sybase ASE 12.5
5.3 (deployment) for Mac OS X Server 10.4 – June 23, 2005
  • Installer updates the Application Server components in Mac OS X Server 10.4 to WebObjects 5.3.
5.3.1[16] – November 10, 2005
  • Addresses incompatibilities with Xcode 2.2 Developer tools on Mac OS X 10.4.
  • Adds a modified Developer tools license that allows WebObjects applications developed with Xcode 2.2 to be deployed on any compatible platform. The license is available at /System/Library/Frameworks/JavaWebObjects.framework/Resources/License.key after installation.
  • Adds better SQL Generation in the EOModeler Plug-in design tool in Xcode.
  • Improved FetchSpecification building in the EOModeler Plugin design tool in Xcode.
  • Adds a "components and elements" window for improved workflow in WebObjects Builder.
  • Bug fixes.
5.3.2[17] – August 7, 2006
  • Addresses incompatibilities with Xcode 2.4 Developer tools on Mac OS X 10.4.
  • Security improvements.
  • Other improvements.
  • As part of the simultaneous release of Xcode 2.4, the Cocoa Java bridge is deprecated along with the following WebObjects applications: EOModeler, EOModeler Plugin, WebObjects Builder, WebServices Assistant, RuleEditor and WOALauncher.
5.3.3[18] – February 15, 2007
  • "WebObjects DST Update": Updates WebObjects 5.3 systems to observe the Daylight Saving Time (DST) changes due to come into effect in March 2007 in many countries, including the United States and Canada. Uses the latest DST and time zone information available as of January 8, 2007.
5.4[19] – October 26, 2007
  • License key no longer required or supported
  • Deprecations: Java Client Nib based applications, Direct to JavaClient based applications, EOCocoaClient based applications, OpenBase no longer example database, Tools (EOModeler, WebObjects Builder, Rule editor)
  • Combined Component Template Parser that reduces .wo components to single .html files
  • Generation of XHTML compliant pages
  • AJAX request handler for enhanced page caching
  • Added support for secure URL generation
  • JMX monitoring support
  • Entity index management in the model
  • Improved the synchronization with the database
  • Added support for index generation
  • Support for enum in attribute conversion
  • Improved support for vendor specific prototypes (EOJDBCOraclePrototype, EOJDBCFrontBasePrototype, etc.)
  • Derby support (Embedded database)
  • Support for Generics
  • WebServices update (Axis 1.4)
  • Full support for Apple XML plist (Read and Write)
  • Ant build support
  • Open Specifications
5.4.1[20] – February 11, 2008
  • "WebObjects 5.4.1 is an update release for the version of WebObjects included in the Mac OS X Leopard tools. This release fixes several bugs in areas such as web services serialization, deployment tools, and database compatibility, among others. This update can be installed on Mac OS X 10.5 Leopard."
  • Fixed bugs in web services serialization, deployment, databases.
5.4.2[21] – July 11, 2008
  • Addresses WOComponent parser issues
  • Includes WebServices data types and API changes
  • Includes EOF SQL Generation fixes
  • Resolves additional issues
5.4.3[22] – September 15, 2008
  • EOF Database snapshot not updating
  • Webassistant not available for D2W apps
  • Exceptions when using WOTextField with formatters
  • Duplicate primary keys generated by FrontBase JDBC Adaptor under load
  • Additional issue fixes

WOWODC

[edit]

Since 2007, the community has held an annual conference for WebObjects developers, WOWODC. In 2007 and 2008, the conference was held the weekend before WWDC, and in 2009, the community promoted two conferences: WOWODC West in San Francisco on June 6 and 7, immediately before WWDC, and WOWODC East in Montreal on August 29 and 30. WOWODC 2010 was held in Montreal on August 27, 28 and 29, 2010. WOWODC 2011 was held in Montreal on July 1, 2 and 3 in 2011. WOWODC 2012 was held in Montreal on June 30, July 1 and 2, 2012. WOWODC 2013 was held in Montreal. WOWODC 2014 was held in Montreal (April 12, 13 and 14). WOWODC 2015 was held in Hamburg on April 25, 26 and 27. WOWODC 2016 was held in Montréal on June 24, 25 and 26

Open-source alternatives

[edit]

Interest in OpenSource alternatives to WebObjects that use the Objective-C language grew with WebObjects' move from Objective-C (last version WO 4.5.1) to Java (first version WO 5.0). The two frameworks available are SOPE,[23] which has been used as the basis of the OpenGroupware.org groupware server for about eight years, and GNUstepWeb, which is part of the GNUstep project. Open-source rewrites of the EOF frameworks also exist (AJRDatabase, GDL2).[24][25]

There are also Java-based alternatives:

  • Wotonomy is a project, hosted on SourceForge, that implements a clean-room, open-source version of the WebObjects 5.x system.[26] It provides a near-complete implementation of the MVC web-framework, as well as partial implementations of Foundation, Control, and Data layers, and other features. It is sufficiently functional for low-transaction volume, single-source database applications. While the project's structure was re-organized in 2006 around an Apache Maven build infrastructure[27] and migrated to the Subversion revision control system,[28] there has not been any substantial update to the codebase since 2003.[29]
  • GETobjects is another framework[31] with an API similar to WebObjects 5.x that is related to SOPE.[23]

An attempt to do a Swift version based on SOPE / GETobjects is available as SwiftObjects.[32] The implementation for Swift 4 is limited due to the reflection capabilities of that Swift version.

See also

[edit]

References

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

WebObjects

View on Grokipedia
from Grokipedia
WebObjects is a server and framework, originally developed in and later ported to , designed for developing and deploying scalable, enterprise-level network applications across the internet, intranets, extranets, and platforms. Originally developed by NeXT Software, Inc., it was first released in 1996 as an object-oriented solution built on technologies like Enterprise Objects Framework (EOF), enabling rapid creation of dynamic web applications with features such as integrated database connectivity. Following Apple's acquisition of NeXT in 1997, WebObjects evolved to support multiple platforms including , , Solaris, and , with enhancements like Direct to Java Client for rich client interfaces, LDAP integration for authentication, and XML support. Known for its standards-compliant architecture and productivity tools like WebObjects Builder, it facilitated object-oriented development while emphasizing , , and ease of deployment for business-critical applications. Apple officially discontinued WebObjects in May 2016, marking the end of active support, though legacy deployments persist in specialized environments.

History

Origins at NeXT

Development of WebObjects began in 1995 at NeXT Software, Inc., under the leadership of , who served as CEO and envisioned it as a revolutionary web application framework to enable the rapid creation of dynamic, scalable websites amid the burgeoning . WebObjects was first publicly demonstrated at the Object World conference in 1995. NeXT, having pivoted from hardware to software solutions, aimed to address the limitations of static web content by providing tools for building enterprise-grade applications that could handle complex interactions and data-driven experiences. This initiative built on NeXT's existing object-oriented ecosystem, positioning WebObjects as a bridge between traditional software development and the emerging demands of online commerce and information delivery. The framework saw its first public release as WebObjects 1.0 in March 1996, coinciding with the commercial maturation of NeXT's software offerings and bundled with the operating system to facilitate seamless integration for developers targeting enterprise environments. From inception, WebObjects emphasized an object-oriented approach to , allowing developers to assemble reusable components—much like building blocks—for generating personalized, database-backed content without the inefficiencies of procedural scripting common at the time. A of this innovation was its tight integration with the Enterprise Objects Framework (EOF), NeXT's established technology for abstracting database operations into persistent business objects, enabling seamless handling of relational data while maintaining platform independence. Initially targeted at enterprise applications requiring robust and customization, WebObjects quickly found adoption among major organizations seeking to pioneer dynamic web presences. One notable early adopter was , which used the framework to power its online store. Technically, WebObjects was constructed using , NeXT's preferred language for its dynamic runtime and object messaging, and adhered to a tailored Model-View-Controller (MVC) optimized for web contexts—where models represented data via EOF, views rendered , and controllers orchestrated request-response cycles to ensure stateless yet efficient application behavior. This architecture not only accelerated development cycles but also laid foundational principles for modern web frameworks by prioritizing modularity and .

Acquisition by Apple and Continued Development

In February 1997, Apple completed its acquisition of NeXT Software, Inc., which it had announced on December 20, 1996, for $400 million in cash plus 1.5 million shares of Apple stock, valuing the deal at approximately $429 million overall. This transaction brought WebObjects, NeXT's flagship server and development framework, into Apple's product lineup, enabling the company to leverage its advanced object-oriented technologies for future software initiatives. The acquisition not only integrated NeXT's engineering talent but also positioned WebObjects as a key asset in Apple's efforts to revitalize its software ecosystem amid financial challenges. Under Apple's stewardship, WebObjects was rebranded and deeply integrated with the emerging Mac OS X operating system, with version 4.0 released in 1999 to coincide with the launch of 1.0. This release expanded platform support beyond NeXT's original environments to include , Sun Solaris, and , allowing developers to deploy applications across heterogeneous enterprise infrastructures while benefiting from Mac OS X's Unix-based stability. Apple emphasized WebObjects' role in accelerating the creation of dynamic, database-driven web applications, marketing it as an ideal solution for building scalable sites and enterprise intranets during the dot-com boom. Internally, Apple utilized WebObjects to power the backend of its online store, which launched in November 2000, demonstrating the framework's capability to handle real-time transactions and inventory management for high-volume retail operations. Subsequent enhancements focused on bolstering to support high-traffic environments, including optimizations for load balancing and session management that enabled WebObjects to process thousands of concurrent users without degradation. These improvements proved instrumental in Apple's adoption of the framework for the iTunes Store backend, launched in , where it managed digital media distribution, user authentication, and payment processing at global scale. In 2001, Apple released WebObjects 5.0, a major milestone that fully transitioned the framework to pure , introducing Enterprise Objects Framework (EOF) 4.0 for enhanced object-relational mapping and database independence, alongside improved tools for cross-platform Java development. This version solidified WebObjects' reputation as a robust platform for enterprise-grade web services, with Apple continuing active development through the mid-2000s to align it with evolving Java standards and server technologies.

Discontinuation and Community Transition

Following the release of WebObjects 5.4.3 in September 2008, Apple significantly reduced development efforts, with no further public updates or enhancements provided to external developers. By 2011, official Apple documentation began marking WebObjects components as deprecated, signaling a gradual withdrawal of support. This trend culminated in Apple's formal announcement on May 3, 2016, stating that "WebObjects is a discontinued product and will never be upgraded." Apple's decision to discontinue WebObjects aligned with a broader strategic pivot toward contemporary development frameworks such as Cocoa and an intensified emphasis on and macOS ecosystems, which better suited the company's evolving priorities in consumer and mobile applications. Despite the discontinuation, WebObjects powered critical internal services like the Apple Online Store and for several years post-announcement, with migrations to newer technologies occurring gradually to minimize disruption. The discontinuation had notable repercussions for enterprise users reliant on WebObjects for robust, scalable web applications, as Apple ceased issuing security patches, bug fixes, or documentation updates, leaving systems vulnerable to unaddressed issues without official recourse. In response, the WebObjects community initiated a transition to independent maintenance, with Project Wonder emerging as a prominent open-source fork that preserves core compatibility while incorporating enhancements such as support for containerized deployments. As of 2023, Project Wonder continued to evolve, with the latest release in May 2023, enabling modern integration practices like Docker-based orchestration for legacy WebObjects applications. By 2025, WebObjects receives no official support from Apple, yet it remains viable in niche enterprise and legacy contexts through ongoing open-source community efforts, including active discussions and updates via Project Wonder.

Technical Architecture

Core Frameworks

The core frameworks of WebObjects provide the foundational libraries for building dynamic web applications, enabling object-oriented interactions with databases, session handling, and UI rendering while leveraging utilities for common programming tasks. These frameworks—Foundation, Enterprise Objects Framework (EOF), and WebObjects—interoperate to support a model-view-controller (MVC) architecture, where data persistence and are separated from presentation and user interactions. The Foundation Framework supplies essential utilities for data manipulation and system interactions, including classes for strings (NSString), collections (NSArray, NSDictionary), and date handling (NSDate). Derived from the NeXTSTEP operating system's foundational libraries, it serves as the base for all WebObjects components, providing memory management, notifications, and encoding mechanisms like NSCoding for object serialization. This framework ensures consistent handling of basic data types across applications, forming the root class hierarchy with NSObject. The Enterprise Objects Framework (EOF) implements object-relational mapping (ORM) to bridge relational databases and object-oriented code, allowing developers to interact with database rows as persistent objects. Key features include editing contexts (EOEditingContext), which manage in-memory object graphs, track changes for operations, and synchronize updates across nested configurations in a . Fetches use EOFetchSpecification to retrieve data efficiently, supporting limits, prefetching, and faulting to load related objects on demand, such as querying overdue items in a rental system. Validation rules enforce through methods like validateForSave, validateValueForKey, and validateForDelete, invoked before persistence operations to prevent invalid states. EOF maps database tables to entity classes, columns to properties, and relationships to keys, accommodating complex attributes like images or rich text while supporting inheritance and uniqueness constraints. The WebObjects Framework forms the core web layer, orchestrating the request-response cycle, session management, and component-based user interfaces for server-side dynamic content generation. It processes HTTP requests via WORequest, which encapsulates headers, form values, and browser data, and generates responses through WOResponse, handling status codes, headers, and content streaming. Session management relies on WOSession to maintain state across cycles, using session IDs (stored in URLs or cookies) with configurable timeouts and termination methods to dedicate resources per user. The WOApplication oversees the overall lifecycle, creating sessions and routing requests, while WOContext provides access to the current transaction's elements. Component-based UI rendering uses WOComponent for modular pages, which handle logic and dynamic HTML generation through methods like appendToResponse:inContext:, supporting page caching for performance. These frameworks integrate via the MVC pattern, with EOF supplying the model for data persistence and relationships, Foundation offering utility support for all layers (e.g., collections in fetches or strings in responses), and the WebObjects Framework managing the view and controller for web interactions. For instance, WODisplayGroup in the WebObjects Framework binds to EOF's editing contexts for seamless database-driven UI updates. A key concept is Direct-to-Web components, which enable rapid prototyping by automatically generating reusable pages (e.g., for querying, listing, editing, or inspecting entities) from an EOF model without custom code, using templates and rules configurable at runtime via the WebAssistant. This approach supports nine standard page types and property-specific elements like D2WDisplayNumber, allowing quick iteration on database applications while integrating with the broader framework ecosystem.

Development Tools

WebObjects provided a suite of integrated development tools designed to streamline the creation, testing, and deployment of web applications leveraging its core frameworks. These tools emphasized visual design, management, and scalable deployment, enabling developers to build reusable components and manage enterprise-level interactions efficiently. WebObjects Builder served as the primary visual design tool for constructing reusable and user interfaces. It featured a graphical editor with a component window, toolbar for inserting and dynamic elements (such as WOImage or WOActiveImage), and an panel for configuring attributes and bindings to variables or methods. Developers could drag elements onto pages, bind them to application logic at runtime, and switch to source view for direct editing, facilitating of dynamic web pages. Reusable components created in WebObjects Builder could be packaged into frameworks or projects for broader reuse. Project Builder functioned as the integrated development environment (IDE) for coding, debugging, and in WebObjects applications. It included a project browser for organizing , components, and resources; a code editor for or ; and built-in support for building, compiling, and launching applications. Assistants within Project Builder automated the creation of WebObjects-specific structures, such as subclasses of WODirectAction, while integrating with WebObjects Builder for seamless component editing. In later iterations, Project Builder evolved into components of , with WebObjects-specific plugins enhancing IDE functionality for model editing and deployment preparation. The EOF Modeler offered a graphical interface for designing database models and entity-relationship diagrams within the Enterprise Objects Framework (EOF). It allowed developers to define entities, attributes, and relationships by reading database schemas or data dictionaries, generate code for enterprise objects, and synchronize models with underlying databases. This tool ensured that object-oriented mapped accurately to relational data stores, supporting features like display groups for data presentation in . In subsequent versions, an EOModeler plugin integrated EOF modeling directly into , aligning with tools for enhanced compatibility. Deployment tools in WebObjects focused on server integration and scalability, including the WOAdaptor and wotaskd daemon. The WOAdaptor bridged web servers (such as via mod_WebObjects, or others using CGI, NSAPI, or ISAPI) to WebObjects application instances, handling request routing and state discovery through (default IP 239.128.14.2, port 1085), host lists, or configuration files like WOConfig.xml. It supported load balancing algorithms including Round-Robin, Random, and Load Average to distribute traffic across multiple instances. Meanwhile, wotaskd managed application instances on a host, launching them on demand, monitoring via periodic lifebeats (every 30 seconds), and restarting failed instances automatically; it operated on port 1085 by default and could be configured as a system service. Additional monitoring utilities, such as the web-based Monitor tool, provided administrative interfaces for site configuration, performance tracking, password protection, and alerts, accessible on ports like 56789. The typical workflow for WebObjects development began with prototyping interfaces and components in WebObjects Builder, followed by in EOF Modeler to define entity relationships. Developers then used Project Builder (or ) to integrate code, bind components to core frameworks like WebObjects and EOF, and build the application. For deployment, applications were packaged with split installations—web resources under the server document root and binaries elsewhere—installed via the Deployment package, configured through Monitor or command-line, and launched by wotaskd with WOAdaptor handling incoming requests for scalable, load-balanced operation on servers like Apache or the built-in WebObjects server.

Development Approach

Rules-Based Rapid Application Development (RBRAD)

Rules-Based (RBRAD) in WebObjects refers to a declarative methodology that leverages predefined rules, templates, and reusable components to streamline the creation of web applications, particularly for standard operations such as (CRUD) tasks, minimizing the need for manual coding. This approach, embodied in the Direct to Web (D2W) framework, allows developers to generate functional web interfaces dynamically from database models without writing extensive procedural code. Central to RBRAD are key elements like Direct-to-Component actions, which handle navigation and tasks such as querying or editing entities through methods like queryAction in generated components. Bindings facilitate data flow by linking UI elements to data sources via a context object (D2WContext), resolving values from state dictionaries or rules. Rule-based validation enforces behaviors without procedural logic, using prioritized rules (e.g., framework rules at priority 0-10) to define page configurations, component selection, and property displays. The implementation of RBRAD integrates the Enterprise Objects Framework (EOF) for data rules, where EOModeler creates entity-relationship models from database schemas to manage objects and relationships. WebObjects handles UI rules through templates and components, enabling the dynamic assembly of pages for tasks like listing or editing. This combination allows non-programmers to prototype applications using tools like WebAssistant, which permits rule customization—such as reordering properties or selecting display formats—without recompiling code. Introduced in early versions of WebObjects, such as 4.0, RBRAD was designed to distinguish the platform from traditional scripting languages by emphasizing model-driven generation over line-by-line programming. A representative example is the auto-generation of list pages from database s: given an EOF model for an entity like "Movie," D2W rules produce a query page, a list component displaying properties (e.g., title, year), and edit interfaces, all derived declaratively from the .

Advantages of RBRAD

The rules-based rapid application development (RBRAD) approach in WebObjects, exemplified by DirectToWeb, significantly accelerates the creation of database-driven web applications by automatically generating user interfaces, pages, and components from a simple entity-relationship model, often requiring minimal custom coding for standard CRUD operations. This automation streamlines prototyping and internal tool development, allowing teams to focus on rather than boilerplate UI and data-binding tasks. Maintainability is enhanced through the declarative rules system, where modifications to rules—such as display properties or validation logic—propagate automatically to all affected components without necessitating widespread code rewrites or recompilation. Developers can adjust behaviors at runtime using tools like the WebAssistant, reducing the risk of inconsistencies that arise in hard-coded implementations and simplifying long-term updates to evolving data models. For scalability, RBRAD leverages WebObjects' built-in support for distributed deployments, including load balancing across multiple application instances and clustering, enabling applications to handle enterprise-level traffic volumes for data-intensive tasks like user queries and edits. However, in highly customized scenarios, overriding default rules can introduce complexity, potentially requiring manual interventions that diminish some automation benefits. While RBRAD offers substantial efficiency for standard applications, it presents trade-offs in flexibility for intricate , where rule evaluation may incur minor performance overhead compared to fully optimized, hand-crafted code; additionally, dynamic generation suits prototyping but often necessitates "freezing" components into static forms for production to optimize response times. In practice, RBRAD facilitated rapid deployment of platforms, powering key components of Apple's online store during the and enabling quick iterations for high-traffic retail features like shopping carts and product catalogs.

Language and Platform Support

Objective-C Integration

WebObjects was originally designed with Objective-C as its primary programming language, leveraging the Objective-C runtime and building upon the Foundation framework, where core classes like WOApplication and WOSession inherit from NSObject. This native integration optimized APIs for Objective-C's dynamic features, including categories for extending classes such as WORequest and protocols for defining interfaces in dynamic elements like WOAssociation, which uses key-value coding to bind attributes via methods like associationWithKeyPath:. Key components in WebObjects extend the WOComponent class, a subclass of WOElement that manages the request-response cycle through methods such as takeValuesFromRequest:inContext:, invokeActionForRequest:inContext:, and appendToResponse:inContext:. Similarly, the Enterprise Objects Framework (EOF) maps database entities to objects using EOEditingContext for state management and WODisplayGroup for handling fetches, queries, and edits, enabling seamless persistence and display of data as native objects. Development workflows involve coding business logic in Objective-C files within .woa application bundles, which package executables, components in .wo subdirectories, and resources for deployment, often stored in paths like NeXT_ROOT/NextLibrary/WOApps. This approach draws on the and heritage, incorporating Cocoa foundations like NSArray, NSDictionary, and NSArchiver for data handling and state , allowing reuse of desktop application code in web contexts. Objective-C remained the core language for WebObjects until the introduction of Java support in later versions, facilitating high-profile applications such as the original Apple Store, which relied on WebObjects to manage multiple online presences and significant revenue streams.

Java Compatibility and Migration

WebObjects introduced Java support with version 4.5 in early 2000, enabling developers to build applications using alongside the existing Objective-C foundation. This addition included features like Direct to Java Client for generating client-side applications dynamically from models and support for Java applications on platforms such as , , and Solaris using JDK 1.1.x. By version , released in May , WebObjects transitioned to a fully Java-based architecture utilizing Java 2 Standard Edition v1.3, providing complete interoperability with Java APIs and JDBC 2.0 for database connectivity. Version 5.1, released in 2002, further refined this parity through community-driven enhancements in Project Wonder, which extended Java capabilities for broader framework compatibility. The implementation featured a dual runtime environment that permitted the use of either or code within the same application, bridged through Apple's . Core components like the Enterprise Objects Framework (EOF) and WebObjects APIs were translated into Java equivalents, with classes such as NSArray and NSDictionary mapped to Java collections like ArrayList and HashMap, while maintaining the original object-oriented model. This translation ensured that EOF's object-relational mapping and persistence features worked seamlessly in Java, rooted in the java.lang.Object hierarchy, and supported deployment on any J2SE or J2EE-compliant server. Migration from to relied on automated tools like the Java Converter introduced in WebObjects 4.5, which handled approximately 80% of the conversion automatically by processing project files, replacing syntax with equivalents, and managing categories as static inner classes. Developers could apply the tool project-wide or file-by-file, often in a two-step process: first to Bridge Java (a transitional hybrid) and then to pure , with custom scripts for handling macros, exceptions, and enumerations. Challenges arose from differences in typing—'s dynamic nature versus 's static typing—requiring manual adjustments for low-level C calls, PoseAs messaging, and certain behaviors not directly translatable, potentially increasing development time for complex legacy codebases. Java compatibility facilitated cross-platform deployment on Windows, , and Unix systems without recompilation, leveraging the JVM's portability and integrating with enterprise standards like Enterprise JavaBeans (EJB) for distributed components. This drove adoption among enterprises seeking to incorporate WebObjects into broader Java ecosystems, with migrations enabling scalable web applications for and , as seen in high-profile deployments by organizations valuing JDBC universality and XML . Following Apple's discontinuation of official support in 2016, the WebObjects community maintained Java compatibility through Project Wonder, an open-source framework that provides ongoing enhancements, bug fixes, and tools for deploying and updating Java-based applications on JVMs such as 8 (as of the last release in 2023). Project Wonder extends EOF and WebObjects APIs with reusable components for services, database adaptors, and deployment in containerized environments, ensuring long-term viability for legacy Java migrations without reliance on proprietary updates.

Version History

Major Releases and Evolution

WebObjects was initially released as version 1.0 in March 1996 by NeXT Software for the operating system, marking the debut of its object-oriented web application framework designed for rapid development of dynamic web sites. This version focused on integration with Enterprise Objects Framework (EOF) for database connectivity and was limited to NeXT's proprietary Unix-based platform. Version 2.0 followed in June 1996, introducing a pre-release of the WebObjects Builder application for visual development and beginning support for multi-platform deployment beyond NeXTSTEP, including early adaptations for other Unix variants. By version 3.0 in October 1996, significant enhancements to EOF were implemented, improving object-relational mapping and scalability for enterprise applications, with version 3.5 arriving in December 1997 to add enhanced Java API subsets and easier installation on platforms like Solaris and HP-UX. Version 4.5, released in March 2000, was the last to include API support, adding XML capabilities, an updated WebObjects Builder, and Direct to Java Client. The acquisition of NeXT by Apple in late 1996 ushered in version 4.0, released on October 9, 1998, which previewed integration through renamed packages and thread-safe EOF 3.0 APIs, while expanding compatibility to alongside Unix systems. Full support arrived with version 5.0 in May 2001, enabling pure development and deployment on , with comprehensive compatibility for macOS. Subsequent releases from 5.1 in early 2002 through 5.3 in June 2005 and 5.4 in 2007 emphasized stability, performance optimizations, and integration with emerging standards; version 5.3 was bundled free with 2.1 and added support for 4.01 and Axis 1.1. For instance, version 5.2 added integrated XML support via WOXMLCoder and WOXMLDecoder for encoding/decoding objects. Version 5.4 introduced precursors to AJAX functionality, including an AJAX request handler for enhanced page caching and secure generation, alongside JMX monitoring. Platform support evolved from initial Unix restrictions to include by version 4.0 and full macOS compatibility by 5.0, reflecting a shift from NeXT's proprietary ecosystem to open standards like and XML. The final official update, 5.4.3, was a patch released on September 15, 2008, addressing minor stability issues.

End of Official Support

In May 2016, Apple notified developers via email that WebObjects would receive no further updates, sales, or licensing, effectively ending official support for the framework. This confirmation came in response to inquiries from Java developer Hugi Thordarson, who quoted Apple stating, "WebObjects is a discontinued product and will never be upgraded." The announcement marked the closure of the product's active lifecycle, with version 5.4.3 serving as the final update from 2008. All versions of WebObjects were deprecated following the announcement, including key components such as the Enterprise Objects Framework (EOF) for object-relational mapping and WebObjects Builder for application development. Apple removed WebObjects documentation and downloads from its main developer site, relocating them to an archive section, which signaled the end of accessibility for new users and ongoing maintenance tools. The discontinuation posed significant challenges for existing users, who encountered difficulties migrating to contemporary web frameworks due to WebObjects' unique and tight integration with and . Post-2016, unpatched vulnerabilities became a major concern, as Apple ceased providing fixes, leaving deployed applications exposed to evolving threats without official remediation. Developers were forced to adapt to alternatives independently. Despite the end of external support, WebObjects persisted in internal use at Apple for legacy systems, including components of the backend, as of 2016.

Community and Legacy

WebObjects Worldwide Developers Conference (WOWODC)

The WebObjects Worldwide Developers Conference (WOWODC) is an annual -driven gathering for developers using the WebObjects framework, organized by the WOCommunity Association since its in 2007. The event provides a platform for sharing best practices, training on technologies like the Enterprise Objects Framework (EOF), and discussing advancements in WebObjects development. In its early years, WOWODC was held the weekend before Apple's (WWDC) in 2007 and 2008. Subsequent events expanded internationally, including WOWODC West in (June 6–7, 2009) and WOWODC East in (August 29–30, 2009), followed by annual conferences in from 2010 to 2013 (e.g., August 27–29, 2010; July 1–3, 2011). Later iterations included events in Hamburg, Germany (April 25–27, 2015) and (June 24–26, 2016). Sessions typically covered topics such as integration, scalability, and case studies from enterprise deployments, including by companies like and . The conference format included keynotes, hands-on workshops, and Birds of a Feather (BOF) sessions for peer collaboration. The last full WOWODC was held in 2013, after which WebObjects topics were occasionally integrated into broader developer events, with meetups continuing under names like WO-Day (e.g., , April 11, 2019). WOWODC has been instrumental in building the WebObjects developer community, facilitating discussions that led to open-source projects like Project Wonder. As of 2025, recordings and proceedings from past conferences are accessible through community repositories such as WOCommunity.org, preserving tutorials, keynotes, and session materials.

Project Wonder and Open-Source Alternatives

Project Wonder emerged in the early 2000s as an open-source initiative by the WebObjects developer community to extend and enhance the framework's capabilities, initially developed as add-ons during gatherings like the (WOWODC). Originating from internal tools at eResource, a dotcom specializing in commercial real estate applications built on DirectToWeb, the project was led by key contributors including Patrice Gautier, a co-author of DirectToWeb, Max Muller, Travis Cripps, and Jim Roepcke. After eResource rebranded to NetStruxr and subsequently closed, the codebase—retaining the "ER" prefix to avoid namespace conflicts—was open-sourced and hosted on under the name Project Wonder, marking its transition to a collaborative effort focused on Java-based WebObjects 4.5 before being rewritten for version 5. Following Apple's last update to WebObjects 5.4.3 in September 2008 and official discontinuation of the product in May 2016, Project Wonder evolved into a comprehensive open-source framework that builds upon, extends, and patches bugs in the core WebObjects libraries, ensuring compatibility while addressing legacy limitations. Licensed under the Apache 2.0 license, it provides reusable frameworks, applications, extensions, and command-line tools to streamline development, including object-relational mapping for JDBC databases, advanced session management with undo/redo/revert functionality, Ajax support, web services integration, and file upload/download capabilities. Notable enhancements include ERModernLook, a UI framework emphasizing tableless semantic markup for modern web interfaces using tables only for tabular data like list pages, and a complete REST implementation enabling database-backed server applications to handle XML, JSON, and plist formats for high-traffic scenarios. The project has seen ongoing community-driven updates, with its repository remaining active as of 2025, incorporating 8 compatibility, improved DirectToWeb translations, and plugin updates like H2 for database support. Post-2016 developments have focused on modern deployment practices, including community-supported Docker containerization for WebObjects applications, allowing scalable orchestration in environments like while leveraging Wonder's frameworks and extensions via WOLips. Although primarily Java-oriented, Wonder maintains backward compatibility with components and supports hybrid integrations, though full native Swift compatibility remains limited to experimental efforts like SwiftObjects for reimplementation. Adoption spans high-profile applications, such as the backend for Apple's iTunes Store, demonstrating its reliability in media and for handling large-scale, session-based web services. While Project Wonder dominates as the primary open-source continuation due to its extensive ecosystem and seamless WebObjects integration, other alternatives exist for specific needs, such as Wotonomy, a clean-room reimplementation of WebObjects 5.x hosted on that prioritizes a pure open-source stack without proprietary dependencies. A lesser-known like WOProject emphasizes Java-centric migrations but lacks Wonder's breadth and momentum. In broader comparisons, Wonder's rules-based (RBRAD) paradigm aligns with frameworks like Grails (for Groovy-based web apps) or (for Scala/Java scalability), offering similar productivity gains through component reuse and automatic code generation, but with unique strengths in enterprise object graphing and state management for finance and media sectors requiring robust data persistence.

References

  1. https://www.apple.com/newsroom/2000/03/01Apple-Delivers-WebObjects-4-5/
  2. https://www.infoq.com/news/WebObjects-Open-Sourced/
  3. https://developer.apple.com/library/archive/documentation/LegacyTechnologies/WebObjects/WebObjects_5/WebObjectsOverview/WebObjectsOverview.pdf
  4. https://www.oit.va.gov/Services/TRM/ToolPage.aspx?tid=8476
  5. https://computerhistory.org/blog/next-steve-jobs-dot-com-ipo-that-never-happened/
  6. https://www.wired.com/1996/02/jobs-2/
  7. https://www.levenez.com/NeXTSTEP/faq.html
  8. http://preserve.mactech.com/articles/mactech/Vol.13/13.05/WebObjectsOverview/index.html
  9. https://www.computinghistory.org.uk/det/927/next-computers/
  10. http://nowthis.com/oldsite/scribbles/1998/webobjects.html
  11. https://macdailynews.com/2008/09/16/apple_releases_webobjects_update_543_for_mac_os_x_105/
  12. https://discussions.apple.com/thread/3235327
  13. https://lists.apple.com/archives/webobjects-dev/2016/May/msg00005.html
  14. https://www.businessinsider.com/apple-officially-discontinues-webobjects-2016-5
  15. https://mjtsai.com/blog/2016/05/05/apple-officially-discontinues-webobjects/
  16. https://github.com/wocommunity/wonder
  17. https://github.com/wocommunity/wonder/releases
  18. https://developer.apple.com/library/archive/documentation/LegacyTechnologies/WebObjects/WebObjects_4.0/System/Library/Frameworks/WebObjects.framework/Resources/English.lproj/Documentation/Reference/ObjC_classic/WebObjectsFrameworks.ObjC.pdf
  19. https://developer.apple.com/library/archive/documentation/LegacyTechnologies/WebObjects/WebObjects_4.0/System/Documentation/Developer/EnterpriseObjects/Guide/EOFDevGuide.pdf
  20. https://developer.apple.com/library/archive/documentation/LegacyTechnologies/WebObjects/WebObjects_4.5/System/Documentation/Developer/WebObjects/DevGuide/WebObjectsDevGuide.pdf
  21. https://developer.apple.com/library/archive/documentation/LegacyTechnologies/WebObjects/WebObjects_5/DirectToWeb/DirectToWeb.pdf
  22. https://developer.apple.com/library/archive/documentation/LegacyTechnologies/WebObjects/WebObjects_3.5/PDF/ToolsAndTech.pdf
  23. https://developer.apple.com/library/archive/documentation/LegacyTechnologies/WebObjects/WebObjects_5/DeployingWebObjects/DeployingWOApps.pdf
  24. https://developer.apple.com/library/archive/documentation/LegacyTechnologies/WebObjects/WebObjects_4.0/System/Documentation/Developer/WebObjects/WOTools/WOToolsandTech.pdf
  25. https://developer.apple.com/library/archive/documentation/LegacyTechnologies/WebObjects/WebObjects_3.5/PDF/WebObjectsDevGuide.pdf
  26. https://developer.apple.com/library/archive/documentation/LegacyTechnologies/WebObjects/WebObjects_4.5/System/Library/Frameworks/WebObjects.framework/ObjC_classic/WebObjects.pdf
  27. https://nonstrict.eu/wwdcindex/wwdc2002/700/
  28. https://www.mactech.com/2000/03/01/apple-delivers-webobjects-4-5/
  29. https://developer.apple.com/library/archive/documentation/LegacyTechnologies/WebObjects/WebObjects_4.5/System/Documentation/Developer/WebObjects/DeltaDoc/NewInWebObjects.pdf
  30. https://www.apple.com/newsroom/2001/05/21Apple-Ships-Java-Based-WebObjects-5/
  31. https://groups.google.com/g/comp.lang.objective-c/c/Un_ziPxalAw/m/jT-kinJhiSgJ
  32. https://developer.apple.com/library/archive/documentation/WebObjects/JavaForWODev/JavaForWODev.pdf
  33. https://developer.apple.com/library/archive/documentation/LegacyTechnologies/WebObjects/WebObjects_5/WebObjectsRef/Java/JavaWebObjects.pdf
  34. https://nonstrict.eu/wwdcindex/wwdc2000/408/
  35. https://www.destinationcrm.com/Articles/CRM-News/CRM-Featured-Articles/WebObjects-Leads-the-Way-for-Application-Servers-46308.aspx
  36. https://wiki.wocommunity.org/xwiki/bin/view/WEB/Home/
  37. http://preserve.mactech.com/articles/mactech/Vol.16/16.05/WebObjects4Everyone/index.html
  38. https://academickids.com/encyclopedia/index.php/WebObjects
  39. https://wiki.preterhuman.net/index.php?title=NeXT_Software_Delivers_WebObjects_Enterprise_3.0_to_Power_Faster_Web_Development_-_October_22%2C_1996&wprov=rarw1
  40. https://www.zdnet.com/article/webobjects-soars-to-version-3-5/
  41. https://developer.apple.com/library/archive/documentation/LegacyTechnologies/WebObjects/WebObjects_4.0/System/Documentation/Developer/WebObjects/DeltaDoc/NewInWO4.0.pdf
  42. https://developer.apple.com/library/archive/documentation/LegacyTechnologies/WebObjects/WebObjects_5/Reference/XML/JavaXML.pdf
  43. https://leopard-adc.pepas.com/releasenotes/MacOSXServer/WO54_ReleaseNotes/WO54_ReleaseNotes.pdf
  44. https://twitter.com/wowodc
  45. https://www.wocommunity.org/wowodc08/
  46. https://wiki.wocommunity.org/xwiki/bin/view/documentation/Home/Frameworks/Project%20Wonder/Project%20WONDER-History/
  47. https://news.ycombinator.com/item?id=11691781
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.