arxiv: 2604.10399 · v1 · submitted 2026-04-12 · 💻 cs.PL

Recognition: unknown

Vanilla Object Orientation (VOO): A Value-Semantics Approach to Classes in Tcl

Alan Araujo

Authors on Pith no claims yet

Pith reviewed 2026-05-10 16:33 UTC · model grok-4.3

classification 💻 cs.PL

keywords Tclobject orientationvalue semanticscopy-on-writeperformanceTclOO

0 comments

The pith

Classes in Tcl can be built directly from native lists and dictionaries with copy-on-write semantics, delivering 7-18x faster object creation than TclOO.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper presents Vanilla Object Orientation (VOO) as a method to define classes in Tcl by composing them from the language's existing lists and dictionaries instead of adding separate framework infrastructure. Objects become plain Tcl lists whose memory is handled automatically through copy-on-write, which removes the need for explicit destructors that TclOO and Itcl require. Benchmarks on current Tcl versions show large gains in creation speed and memory use, while a companion C++ implementation keeps the identical Tcl calling interface but improves field access further. A reader would care because this demonstrates how relying on core language primitives can simplify object-oriented code and reduce overhead without introducing new dependencies or changing call-site syntax.

Core claim

VOO composes classes from Tcl's native data structures -- lists and dictionaries -- rather than introducing additional framework infrastructure. VOO objects are plain Tcl lists with automatic memory management through copy-on-write semantics, eliminating the destructor burden inherent in TclOO and Itcl. This yields 7--18x faster object creation and 4--6x better memory efficiency than TclOO on Tcl 8.6.13 and Tcl 9.0. A companion C++ migration path improves field-access speed (setter 2.3--2.6x faster) and memory (6.8--9.8x lighter than TclOO) while preserving the same Tcl call-site API. The compositional design scales better than framework-based approaches as the interpreter evolves.

What carries the argument

Composition of classes from plain Tcl lists and dictionaries using copy-on-write value semantics for automatic memory management.

If this is right

Object creation runs 7 to 18 times faster than with TclOO.
Memory consumption drops by a factor of 4 to 6 compared with TclOO.
No explicit destructors are needed because copy-on-write handles cleanup automatically.
The C++ companion path makes setters 2.3-2.6 times faster and objects 6.8-9.8 times lighter while keeping the Tcl API unchanged.
The approach scales more favorably than framework-based object systems when Tcl itself is updated.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

Similar value-semantics layering could be applied in other dynamic languages that already provide efficient list and dictionary primitives.
Existing TclOO codebases could be ported to VOO for performance-sensitive sections without altering call sites.
The C++ migration route suggests a practical hybrid model where hot paths are compiled while scripts retain the same interface.
Tcl maintainers might consider exposing lightweight value-based object support natively to amplify these gains.

Load-bearing premise

The reported benchmarks reflect representative Tcl workloads and copy-on-write introduces no hidden performance or correctness costs under realistic usage.

What would settle it

A measurement showing VOO object creation is not faster than TclOO on common patterns, or a concrete Tcl program where copy-on-write produces incorrect results or unexpected memory overhead.

read the original abstract

I present Vanilla Object Orientation (VOO), a framework that composes classes from Tcl's native data structures -- lists and dictionaries -- rather than introducing additional framework infrastructure. VOO objects are plain Tcl lists with automatic memory management through copy-on-write semantics, eliminating the destructor burden inherent in TclOO and Itcl. Benchmarks on Tcl 8.6.13 and Tcl 9.0 show VOO achieves 7--18x faster object creation and 4--6x superior memory efficiency compared to TclOO. A companion C++ migration path (VOO C++) further improves field-access speed (setter 2.3--2.6x faster) and memory (6.8--9.8x lighter than TclOO), while preserving an identical Tcl call-site API. Cross-version analysis confirms that VOO's compositional design scales better than framework-based approaches as the interpreter evolves.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

VOO shows how to build classes in Tcl from native lists and dicts with value semantics, delivering clear creation and memory gains in the reported tests while keeping a simple API and a C++ migration path.

read the letter

The main thing here is a compositional object model for Tcl that treats classes as plain lists and dictionaries rather than framework objects. This uses the language's copy-on-write semantics for automatic memory handling and drops the need for explicit destructors that TclOO and Itcl carry. The paper also ships a C++ version with the identical Tcl call-site API, which adds further speed on field access and even lower memory use. Cross-version runs on Tcl 8.6 and 9.0 are included to check how the approach holds up as the interpreter evolves. Those pieces are genuinely new relative to the cited prior Tcl OO work, and the concrete numbers (7-18x creation, 4-6x memory for the pure Tcl side) give readers something measurable to evaluate. The implementation details and migration path are laid out plainly enough that a Tcl user could try it without starting from scratch. The value-semantics framing is a straightforward way to reuse existing language machinery instead of layering new infrastructure on top. Benchmarks focus on creation and setter micro-tests, which show the claimed advantages. The stress-test concern about copy-on-write costs under mutation has some weight because the reported workloads appear creation-heavy and do not include aggregate measurements on frequent updates or shared objects. If real Tcl scripts do a lot of in-place changes after creation, the hidden copy overhead could narrow the gap, and the abstract does not spell out the full test cases or error handling. That said, the numbers are presented as empirical comparisons rather than fitted claims, and the paper does not hide the Tcl-specific scope. This work is mainly useful for Tcl practitioners who need lighter objects or for language researchers looking at value-based designs in dynamic scripting languages. A reader who wants to see a working alternative to standard OO frameworks with side-by-side data will find it worth the time. I would send it for peer review because the implementation is concrete, the comparisons are direct, and the central idea is falsifiable with the supplied code and benchmarks, even if the workload coverage needs more detail in revision.

Referee Report

2 major / 2 minor

Summary. The paper presents Vanilla Object Orientation (VOO), a framework that implements classes in Tcl by composing them from native lists and dictionaries with copy-on-write semantics, eliminating framework infrastructure and destructor requirements. It reports empirical benchmarks on Tcl 8.6.13 and 9.0 showing 7--18x faster object creation and 4--6x better memory efficiency versus TclOO, plus a C++ variant (VOO C++) that further improves setter speed (2.3--2.6x) and memory (6.8--9.8x lighter) while preserving the Tcl call-site API. Cross-version analysis is used to argue that the compositional design scales better than framework-based OO.

Significance. If the benchmark methodology and workload assumptions hold, the work offers a lightweight, value-semantics alternative to TclOO/Itcl that reduces overhead and destructor burden. The explicit cross-version comparison and provision of a C++ migration path with identical API are strengths; the empirical focus on creation, memory, and field access provides falsifiable performance data that could inform similar designs in other dynamic languages.

major comments (2)

[Benchmark Results] Benchmark Results section: The central performance claims (7--18x creation speedup, 4--6x memory efficiency) are supported only by creation and setter micro-benchmarks. No aggregate time or memory results are reported for workloads involving frequent post-creation mutations or object sharing, which would trigger Tcl copy-on-write copies and could materially alter the efficiency comparison.
[C++ Migration Path] C++ Migration Path section: The reported 2.3--2.6x setter speedup and 6.8--9.8x memory improvement for VOO C++ versus TclOO lack details on benchmark error handling, test-case selection, and how C++ objects interact with Tcl's COW semantics under mutation; without these, the cross-implementation claims cannot be fully assessed.

minor comments (2)

The abstract and cross-version claims reference Tcl 8.6.13 and 9.0; a summary table of interpreter versions, hardware, and benchmark repetition counts would improve reproducibility.
[Introduction] Notation for object representation (lists vs. dictionaries) is introduced early but could be clarified with a small example in the first section showing a sample VOO object structure.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the constructive and detailed feedback. We address each major comment point by point below, agreeing where revisions are warranted and providing the strongest honest defense of the manuscript's scope and claims.

read point-by-point responses

Referee: [Benchmark Results] Benchmark Results section: The central performance claims (7--18x creation speedup, 4--6x memory efficiency) are supported only by creation and setter micro-benchmarks. No aggregate time or memory results are reported for workloads involving frequent post-creation mutations or object sharing, which would trigger Tcl copy-on-write copies and could materially alter the efficiency comparison.

Authors: We acknowledge that the reported results are micro-benchmarks centered on creation and setter operations, as these isolate the overhead reductions from VOO's compositional value-semantics design without framework infrastructure. The paper's core argument is that VOO objects are native Tcl lists and dicts, so any COW copies triggered by mutations or sharing incur exactly the same cost as equivalent plain-Tcl code; VOO adds no extra per-object state or destructor overhead. Thus the relative 4--6x memory advantage and creation speedup should persist in aggregate workloads. That said, the referee is correct that explicit aggregate measurements would strengthen the claims. We will revise the Benchmark Results section to add a new subsection with aggregate workload results (e.g., repeated creation-mutation-sharing cycles) on both Tcl 8.6.13 and 9.0, confirming that the efficiency gains are retained. revision: yes
Referee: [C++ Migration Path] C++ Migration Path section: The reported 2.3--2.6x setter speedup and 6.8--9.8x memory improvement for VOO C++ versus TclOO lack details on benchmark error handling, test-case selection, and how C++ objects interact with Tcl's COW semantics under mutation; without these, the cross-implementation claims cannot be fully assessed.

Authors: The VOO C++ benchmarks reuse the identical creation and setter test cases as the pure-Tcl VOO suite to ensure direct comparability. Error handling uses lightweight C++ return codes in the hot path (no exceptions). C++ objects interact with Tcl's COW by exposing an opaque handle whose internal representation is a C++ struct that performs copy-on-write only on mutation, preserving the exact Tcl call-site API and semantics. We agree that these implementation details were insufficiently documented. We will expand the C++ Migration Path section with a dedicated paragraph on benchmark methodology, error handling, test-case criteria, and a short pseudocode example of the COW interaction to permit full assessment. revision: yes

Circularity Check

0 steps flagged

No circularity; purely empirical implementation and benchmarks

full rationale

The paper introduces VOO as a compositional framework built directly from Tcl lists and dictionaries plus copy-on-write, then reports measured speed and memory improvements via benchmarks on Tcl 8.6.13 and 9.0. No equations, first-principles derivations, fitted parameters, or predictions appear in the provided text. Claims rest on direct runtime measurements rather than any reduction of outputs to inputs by construction, self-citation chains, or renamed ansatzes. The central efficiency argument is therefore self-contained as an empirical comparison and does not trigger any of the enumerated circularity patterns.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

No free parameters, axioms, or invented entities are identifiable from the abstract; the work relies on standard Tcl interpreter behavior and benchmark assumptions.

pith-pipeline@v0.9.0 · 5446 in / 1020 out tokens · 46604 ms · 2026-05-10T16:33:41.110527+00:00 · methodology

discussion (0)

Reference graph

Works this paper leans on

12 extracted references

[1]

Ousterhout, J. K. (1994).Tcl and the Tk Toolkit. Addison-Wesley

1994
[2]

Fellows, D. (2006). TIP #257: Object Orientation for Tcl. Tcl Improvement Proposal. https://wiki.tcl-lang.org/page/TIP+%23257%3A+Object+Orientation+for+Tcl

2006
[3]

DeJong, M. (2000s). Integrating Itcl into the Tcl Core. Tcl Wiki Discussion
[4]

Tcl 8.6 Release Notes.https://www.tcl.tk/

Tcl Core Team (2013). Tcl 8.6 Release Notes.https://www.tcl.tk/

2013
[5]

Neumann, G., & Zdun, U. (2000). XOTcl: An Object-Oriented Scripting Language. In Proceedings of Tcl2k

2000
[6]

Tcl/Tk Documentation.https://www.tcl.tk/doc/
[7]

TclOO Manual.https://www.tcl.tk/man/tcl8.6/TclCmd/class.htm
[8]

Tcl Wiki: Integrating Itcl.https://wiki.tcl-lang.org/page/Integrating+Itcl+into+ the+Tcl+core
[9]

Tcl Wiki: TIP #257 Discussion. https://wiki.tcl-lang.org/page/TIP+%23257%3A+ Object+Orientation+for+Tcl 10 A Quick Reference This appendix provides concise reference documentation for VOO’s primary constructs and usage patterns. Class Declaration voo::classCl as sN am e ? - virtual ? ? - extends P a r e n t C l a s s ? { public{ type_t fi el dN am e d e f...
[10]

Object Creation (Explicit Values):Instantiate objects with all field values explicitly provided to the constructor
[11]

3.Setter Performance:Modify a single field value through the setter

Object Creation (Default Values):Instantiate objects using the no-argument construc- tor with all default field values. 3.Setter Performance:Modify a single field value through the setter. 4.Getter Performance:Retrieve a single field value through the getter
[12]

point " } } Listing 13: VOO syntax sugar: class and fields n am es pa ce evalPoint { variablex 0 variabley 1 variablename 2 14 variable_ _ d e f a u l t O b j [list0.0 0.0

Class Declaration Performance:Declare a complete class with fields and methods (one-time initialization cost). C VOO Syntax Sugar vs. Raw Vanilla Tcl This appendix demonstrates the value of VOO’s syntax sugar by comparing aPoint class written with VOO’s declarative syntax against the equivalent raw Tcl that VOO generates internally. C.1 Class Declaration ...