Blog › ICP guides

Authorware developer on retainer: ADODB connection leak, Macromedia Authorware developer, Adobe Authorware developer on monthly retainer

October 9, 2026 · ~15 min read

An Authorware developer was maintaining a safety compliance training suite built in Macromedia Authorware 7 for a mid-sized manufacturing company. The courseware consisted of five safety modules used for annual OSHA compliance training; the company ran the training for 20 employees simultaneously during quarterly safety reviews. Because the company did not have an LMS, the Authorware developer had written a custom external function DLL (SafetyTrack.dll) that the courseware called at course completion via a Calculation icon: the DLL opened an ADODB.Connection to a shared Access MDB database (\\server\training\completions.mdb) using the Microsoft Jet OLEDB 4.0 provider, inserted a completion record (EmployeeID, ModuleID, CompletionDate, Score), and returned control to Authorware. The developer had tested the DLL with two simultaneous learner sessions in the development environment and confirmed it recorded completions correctly. During the company’s quarterly safety review with 20 employees on 20 workstations running concurrently, 3–5 employees per session received no confirmation that their completion had been recorded — their score screens appeared normally, but their names were missing from the completions MDB when the safety manager ran the compliance report. The ADODB error “Too many open connections” (Jet Engine error) was silently caught and discarded by the DLL’s error handler, which returned a success code to Authorware regardless of whether the database write had succeeded. Silent course completion records lost per quarterly training session: 3–5 → 0 after adding explicit connObj.Close and Set connObj = Nothing after every database write in the DLL.

The root cause was a database connection object leak: the SafetyTrack.dll external function created a new ADODB.Connection object on every call, inserted the completion record, but never closed the connection object before returning. In-process ADODB.Connection objects created with the Microsoft Jet OLEDB provider are reference-counted COM objects; they are only released when their reference count drops to zero, which requires either an explicit connObj.Close + Set connObj = Nothing call or when the COM apartment that created the object is torn down (which, in the Authorware process, only happens when the Authorware runtime exits). With 20 concurrent learner sessions each completing one module and calling the DLL once, 20 open ADODB.Connection objects accumulate in each workstation’s Authorware process. The Microsoft Jet Engine (Access MDB backend) enforces a per-database connection limit that in practice is hit well below the theoretical maximum of 255 when multiple connections accumulate from a single process. Once the connection limit was reached, subsequent ADODB connection open calls failed; the DLL’s error handler discarded the error and returned a success status to Authorware; the Authorware Calculation icon saw no error; the completion record was never written; the employee received the normal course-complete screen. Fix: add connObj.Close + Set connObj = Nothing at the end of every code path in the DLL (including the error path via On Error GoTo ErrHandler) to explicitly release the connection and return it to the Jet Engine connection pool before the function returns.

Authorware’s external function architecture uses two mechanisms for calling compiled DLL code: U32 functions (32-bit Windows DLL functions called via Authorware’s built-in CallDLL or CallScriptFunction system variable) and Xtras (Authorware’s plugin architecture, analogous to Director’s Xtras, which extend Authorware with new icon types or scripting capabilities). For database I/O in Authorware 7 without an LMS, the most common pattern is a U32 DLL written in Visual Basic 6 or Delphi that uses ADODB (ActiveX Data Objects) to connect to an Access MDB or SQL Server database. The U32 DLL is registered as an external function in the Authorware file via the External Functions dialog; Authorware passes parameters by value or by reference; the DLL returns a result value. ADODB.Connection (CreateObject("ADODB.Connection")), ADODB.Recordset (CreateObject("ADODB.Recordset")), and ADODB.Command are the core ADO objects. The connection string for Access via Jet OLEDB: “Provider=Microsoft.Jet.OLEDB.4.0;Data Source=\\server\training\completions.mdb”. For Access 2007+ ACCDB files: “Provider=Microsoft.ACE.OLEDB.12.0;Data Source=...”. Proper connection lifecycle: Set connObj = CreateObject("ADODB.Connection"); connObj.Open connString; execute the INSERT; connObj.Close; Set connObj = Nothing. The Set connObj = Nothing step is required to release the COM reference count; connObj.Close alone closes the logical connection but may not immediately release OS resources if the reference count is still above zero.

Macromedia Authorware was the dominant enterprise eLearning authoring tool of the 1990s and 2000s, distinguished by its icon-based flowline authoring paradigm. Where most programming tools use text-based code or timeline-based interfaces, Authorware authors build courseware by dragging and connecting icons on a vertical flowline: Display icons show screen content (graphics, text, and media); Interaction icons define branching interactions (hot spots, button clicks, text entry, menu choices, drag-and-drop, and time limit responses); Decision icons implement conditional branching and loops; Map icons are containers that hold nested flowline segments (equivalent to subroutines or modules); Calculation icons execute Authorware scripting language code (a Pascal-influenced proprietary language for variable assignment, math, string manipulation, and external function calls); Movie icons play embedded or linked video; and Sound icons play audio. The flowline is executed top-to-bottom, with branching determined by Interaction icon response evaluation and Decision icon conditions. This icon metaphor made Authorware accessible to instructional designers without programming backgrounds — the dominant workforce in corporate training departments in the 1990s.

Macromedia Authorware, SCORM, and the LMS integration architecture

Authorware’s SCORM integration architecture went through several iterations. Authorware 5 (1997) predated SCORM; completion tracking used AICC (Aviation Industry CBT Committee) HTTP communication to the LMS or custom external function DLL calls to flat files or databases. Authorware 6 added SCORM 1.1 support via the Authorware SCORM Adapter (a JavaScript-based bridge between Authorware’s communication variables and the SCORM 1.1 LMSInitialize/LMSSetValue/LMSFinish API). Authorware 7 (2003, Macromedia’s final version before the Adobe acquisition) added SCORM 1.2 compliance via a redesigned adapter and improved web delivery through the Authorware Web Player browser plugin and AuthorPackager (the tool that packaged .a7p source files into web-deliverable .a7r segment packages). Adobe acquired Macromedia in December 2005 and released Adobe Authorware 7.02 as a maintenance update in 2006; Adobe subsequently discontinued Authorware in 2013, with the Authorware Web Player browser plugin following Shockwave Player into end-of-life in 2019. The consequence for retainer developers is identical to Director: manufacturing companies, utilities, healthcare organizations, and government agencies that deployed Authorware courseware on corporate intranets in the 2000s continue running that courseware on Windows 10 and 11 workstations using standalone .exe projectors or shared network .a7r packages, but have no path to Authorware authoring support from Adobe.

The Authorware scripting language (no official name; sometimes called “Authorware Calculation script”) is a proprietary procedural language executed in Calculation icons. It resembles Pascal with some BASIC influences. Variables are declared with varName := expression (assignment creates the variable implicitly in Authorware). System variables like TimeLimit, SessionID, UserName, TotalScore, TotalCorrect, TotalWrong, and CompletionStatus are read-write global variables automatically updated by Authorware’s interaction engine. User-defined variables are global by default; local variables are scoped to a Map icon’s flowline if declared with local varName. String functions: Concat(str1, str2), SubStr(str, start, length), Length(str), UpperCase(str). Math: Mod(x, y), Round(x), Abs(x). External function calls: CallDLL("SafetyTrack.dll", "WriteCompletion", employeeID, moduleID, score) (the actual syntax varies; Authorware’s U32 external function call syntax depends on the function declaration in the External Functions dialog). Authorware also supports knowledge objects — pre-built packaged interaction templates (quiz question types, navigation structures, SCORM wrappers) distributed as installable Authorware knowledge objects (.a7k files) — which abstract common patterns into parameterized drag-and-drop blocks on the flowline.

The ADODB connection limit for Microsoft Access MDB files via the Jet OLEDB provider is a well-known constraint in multi-user desktop database deployments. The Jet Engine (Access database engine) enforces a per-database connection limit managed through the .ldb lock file (completions.ldb alongside completions.mdb); each open ADODB.Connection consumes one slot in the .ldb file. The theoretical maximum is 255 simultaneous connections to a single MDB; the practical limit under the Jet 4.0 provider in Windows 10 is typically 64–128 before performance degrades severely and 255 before connections are refused with “Too many open connections” (ADODB error −2147217887, Jet error 3343 “Unrecognized database format” or 3048 “Cannot open any more databases” depending on version). A single workstation running Authorware with a leaking DLL that creates a new connection per completion but never closes them can exhaust the connection limit by itself after 64 completions. In a deployment with 20 simultaneous learner workstations each leaking connections, the limit is reached rapidly. The correct architecture for multi-user concurrent Authorware deployments with database completion logging: use SQL Server or MySQL instead of Access MDB (which is a single-writer, low-concurrency file-server database not designed for 20+ concurrent connections from multiple workstations); or implement a connection pool in the U32 DLL using a single shared persistent connection with a CRITICAL_SECTION mutex for concurrent write serialization; or, simplest, ensure the DLL closes and releases the connection object on every code path including error paths.

Typical Authorware developer retainer work and what it looks like in a work log

ADODB connection leak in U32 DLL external function is the canonical Authorware invisible production completion-tracking bug. The pattern is consistent: a Calculation icon in the Final Assessment Map calls an external function (WriteCompletion in SafetyTrack.dll); the DLL creates Set connObj = CreateObject("ADODB.Connection"); opens it with connObj.Open "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=\\server\training\completions.mdb"; executes the INSERT; returns to Authorware — but never calls connObj.Close. The developer tests with two learner sessions — no limit reached. In production, 20 concurrent sessions each call the DLL; within the session, connections accumulate; the Jet Engine connection limit is reached; subsequent connObj.Open calls fail with “Too many open connections”; the DLL’s error handler discards the error and returns success; Authorware sees no error; the employee receives the normal completion screen; the completion record is never written. Fix: connObj.Close + Set connObj = Nothing on every code path (normal return and error path). Silent completion records lost per 20-learner session: 3–5 → 0. Work log: “SafetyCompliance.a7p; WriteCompletion external function in SafetyTrack.dll; Calculation icon 'LogCompletion' in Final Assessment Map; ADODB.Connection opened but never closed; 20 concurrent learner sessions; Jet Engine 'Too many open connections' (ADODB error after ~64 accumulated connections); completion record silently lost; fix: connObj.Close + Set connObj = Nothing on normal and error return paths; silent completion losses: 3–5 per 20-learner session → 0; 2h.”

SCORM lesson_status not committed before LMSFinish is the second most common Authorware retainer pattern in LMS-deployed courseware. An Authorware 7 safety compliance course uses the Authorware SCORM 1.2 adapter; at course completion, the Authorware flowline executes: (1) a Calculation icon sets cmi_lesson_status := "passed" (Authorware’s internal variable mapped to cmi.core.lesson_status by the SCORM adapter); (2) a second Calculation icon calls the SCORM adapter’s LMSFinish function. The LMS records the course as “incomplete” for roughly 1 in 10 completions. Root cause: the Authorware SCORM adapter uses a JavaScript setTimeout to debounce rapid successive LMSSetValue calls and batch-write them to the LMS; if LMSFinish fires before the debounce timer fires (which happens when the Calculation icons execute without any rendering delay between them), LMSFinish commits the data to the LMS before the cmi.core.lesson_status = "passed" write is sent, so the LMS records the final status as the default value (“incomplete”). Fix: add a 500ms pause (a Map icon with a Time Limit of 0.5 seconds) between setting the status variable and calling LMSFinish, allowing the SCORM adapter’s debounce timer to fire before the session ends. Incomplete LMS completions for completed courses: 1 in 10 → 0. Work log: “SafetyCompliance.a7p; SCORM 1.2 adapter; LMSFinish called before debounce timer fires for cmi.core.lesson_status set; LMS records ‘incomplete’ for ~10% of completions; fix: 500ms pause Map icon between status-set Calculation icon and LMSFinish Calculation icon; debounce timer fires before LMSFinish; incomplete completions: 1/10 → 0; 2h.”

Authorware piece file load time degradation from over-embedded media is the third common Authorware retainer pattern. An Authorware 7 course for new-employee onboarding has grown over several years to include 300 Display icons each containing an embedded screenshot imported as a 24-bit uncompressed BMP, and 15 Sound icons each containing an embedded uncompressed WAV narration clip. The packaged .a7r file (or standalone .exe) has grown to 210 MB. When distributed over the corporate network via Authorware Web Player, the browser downloads the entire .a7r package before displaying the first frame — on a 100 Mbps corporate LAN, downloading 210 MB takes 25–35 seconds. Employees close the browser before the course loads. Fix: convert all embedded screenshots to externally linked PNG files (reduced from 24-bit BMP to optimized PNG at 75% quality), convert all embedded WAV narration to externally linked MP3 (64 kbps mono); replace embedded Display icon content with linked media references (Authorware Display icon → Movie icon or Display icon with externally linked graphic). The .a7r package shrinks to 8 MB; the initial load time drops to 1–2 seconds; the remaining media loads on demand as learners navigate through the course. Work log: “OnboardingCourse.a7p; 300 embedded BMP screenshots + 15 embedded WAV narration clips; packaged .a7r size 210 MB; Web Player download time 25–35s on 100 Mbps LAN; converted to externally linked PNG + MP3 (hosted on //server/training/media/); .a7r reduced to 8 MB; load time 1–2s; 3h.”

How HourTab tracks Authorware developer retainer hours

Authorware ADODB connection leak bugs are invisible by the same mechanism that makes them impossible to reproduce in single-learner development testing: when one learner completes the course, the DLL creates one ADODB.Connection object; the connection opens successfully; the INSERT completes; the function returns; the connection object is never explicitly closed but the Jet Engine has 254 connection slots remaining. The developer confirms the completion record appears in the MDB and moves on. The only evidence of the problem surfaces during a quarterly compliance training session with 20 simultaneous learners — with no visible error on any learner’s screen, no Authorware error dialog (the DLL discards the ADODB error), no Windows Event Log entry from Authorware (the process-level error is swallowed), and no notification to the safety manager (who discovers the missing completions only when running the compliance report after the session). Diagnosing the problem requires connecting a debugger to the DLL or adding diagnostic logging to the DLL to capture the ADODB error on the path that fails, then confirming the error is “Too many open connections” and correlating it with the number of accumulated unclosed connection objects.

The work log must name the mechanism to be auditable: which Authorware piece file (SafetyCompliance.a7p), which external function call (WriteCompletion in SafetyTrack.dll, called from Calculation icon “LogCompletion” in the Final Assessment Map), the ADODB.Connection object (opened with “Provider=Microsoft.Jet.OLEDB.4.0;Data Source=\\server\training\completions.mdb”), the concurrent learner count (20 simultaneous learners during quarterly OSHA review), the completion records lost per quarterly training session before fix (3–5 silent losses), the records lost after fix (0), and the fix (connObj.Close + Set connObj = Nothing on normal return path and in On Error GoTo ErrHandler error path). A log entry that says “fixed database issue in compliance course, 2h” is not auditable. A log entry that names the piece file, the DLL function, the ADODB connection lifecycle, the Jet Engine connection limit, the silent data loss mechanism, and the connection-close fix is auditable and defensible to the OSHA compliance team. HourTab gives Authorware developers a public retainer-hours URL they send to clients — manufacturing companies, utilities, healthcare organizations, government agencies, and financial services firms that built safety compliance, onboarding, and regulatory training courseware in Macromedia and Adobe Authorware in the late 1990s and 2000s, maintained today by the original Authorware developer or a successor retainer consultant.

Comparative context: Authorware ADODB connection leak bugs are structurally related to resource-leak patterns in other legacy courseware and interactive deployment environments where an external resource is acquired for a brief operation but not explicitly released. ToolBook retainers cover the same class of problem at the OS file level: ToolBook’s FileOpen acquires an exclusive Windows OS file lock; if it is not released with FileClose before a concurrent session attempts FileOpen, the second session receives “File in use”; the Authorware ADODB leak is the same pattern at the database connection level. Lingo retainers cover Director’s FileIO Xtra openFile exclusive OS lock — same invisible single-user vs. concurrent-session divergence, same post-deployment analytics audit as the discovery mechanism. WinDev retainers cover HFSQL HLock file-system lock not released on validation failure branch — same “HCancelBuffer cancels buffer changes but does not release the file lock” resource-lifecycle misunderstanding as “ADODB INSERT completes but connection is not closed.”

FAQ: Authorware developer retainers