The parts that matter, taught from the inside
I am Aivars Kalvans, author of Modernizing Oracle Tuxedo Applications with Python, and I have spent close to two decades building and supporting C++ applications on Oracle Tuxedo in production, in an environment where downtime is measured in money and the queues never sleep. This is a hands-on, instructor-led training about the Tuxedo that real systems use, not a recital of the manuals.
You will not just learn that it works. You will learn
how it works: which system calls a service call makes, where a
request waits when a queue backs up, what the BBL is doing while you
sleep, why a full queue turns into one-second sleeps that bubble up
through your whole domain, and which C++ mistakes kill servers in
production. I trace this stuff with strace, gdb,
and bpftrace for a living, and the training shows you the
same lens. When I write a behavior down, I write it down to the system
calls, like how a full queue
turns into one-second sleeps that bubble up through the whole
domain until the clients feel it.
Along the way you will also meet the tooling I build around this
world: Fuxedo, my open
source reimplementation of the Tuxedo API (building one is the most
thorough way to learn the semantics), ipcqmon for queue
latency from eBPF, and the
tuxedo-python
bindings that the book and the labs are built on. The monitoring
side comes from the same school: I have designed and run my own
TSAM-style instrumentation that hooks into Tuxedo at the same extension
points Oracle TSAM uses, and productionized it (notes on
that home-built monitoring). That experience is why the monitoring chapter is
about mechanics, not dashboards.
| Format | Content |
|---|---|
| 2 days | Days 1 and 2 below: build and operate a production-grade Tuxedo application, Python-first, with the reliability machinery (MIB, transactions, /Q) that separates a demo from production. Half lecture, half labs, everyone boots and debugs their own domain. |
| 3 days | Adds Day 3: C++ internals, the memory minefield, and a debugging bootcamp (gdb, valgrind, planted bugs). The second half of Day 3 is reserved for your system: bring your failing service, your confusing timeout, your migration question, and we take it apart together. |
| Custom | Customer-specific tracks on top of the 3-day format: high availability and clustering, performance tuning and queue behavior, migration paths from legacy C/C++/COBOL clients, security levels, cloud-era infrastructure, or domain gateways. |
Day 1. Make it work. From zero to a running, load-balanced service: clients, servers, services, UBBCONFIG, tmboot. Typed buffers (STRING, CARRAY, FML32) with ud32 and boolean expressions. The flag gymnasium: every service-call flag, what it actually does, and a lab proving it (investigating Tuxedo flags is the kind of depth to expect). Under the hood from the first hour: IPC queues, SSSQ vs MSSQ, watching a server die and come back.
Day 2. Make it reliable. Administration and
monitoring through the MIB (tpadmcall, .TMIB) and a monitoring script you
take home. Distributed transactions: TLOG anatomy, timeout semantics that
bite people (how
SCANUNIT and timeouts really interact), TPNOTRAN when
you do not want in. /Q queues: tpenqueue,
tpdequeue, message and correlation IDs, TMQFORWARD. Database integration.
Beyond the LAN: workstation clients, and the showpiece, an HTTP and JSON
front-end served from inside a Tuxedo server.
Day 3. Make it yours. C++ implementation details: buffer ownership, what tpreturn really does, the dangling pointer and alignment traps. A debugging bootcamp with gdb and valgrind against intentionally broken services. Then your systems on the table.
I have been approached before to deliver the standard Oracle Tuxedo curriculum, and the materials exist. This training is deliberately shaped differently. It is the Tuxedo good parts: the features that show up in real systems, taught at the level of mechanics. Where the official documentation tells you what a call does, we look at what the process does: the msgrcv it blocks in, the shared memory it locks, the queue depth that explains the latency spike. When something misbehaves at 3 a.m., that is the knowledge that gets you home.
Everything is hands-on. Labs run on real booted domains; participants break things on purpose and learn to read the wreckage. The Python bindings mean the whole curriculum moves fast, but nothing is hidden: when it matters, we drop to C to see what the Python is doing for you.
And the sentence to hold onto: what you learn in this course transfers 1:1, including to the only platform where your UBBCONFIG still loads.
Tuxedo developers and maintainers, system administrators, integration and migration engineers, teams modernizing legacy ATMI systems. Basic Python and Linux command line are enough; the labs carry you through the rest.
The training doubles as a low-risk evaluation point for teams weighing their options: because I build Fuxedo and the Python bindings, you also get an honest, practical view of migration paths away from license pressure, without the sales pitch.
The training is backed by years of posts that go down to the system calls. A few of them: