The misleading green signal is simple: asyncio.create_task() returned a Task, task.done() was already True, and a subsequently registered add_done_callback() eventually ran. It is tempting to compress those observations into “the scheduler ran the task and then invoked the callback.” With asyncio.eager_task_factory, that explanation can be wrong in two different places.
Python documents eager task execution as a semantic change: when the eager factory is installed, coroutine execution starts synchronously during task construction. If that coroutine returns or raises without blocking, the task is never scheduled onto the event loop for coroutine execution. The same documentation warns that task execution order can therefore change. eager_task_factory was added in Python 3.12.
Callback registration has a separate contract. Task.add_done_callback() follows the Future.add_done_callback() semantics. If the Future or Task is already done when the callback is registered, Python does not invoke that callback inline. It schedules the callback with loop.call_soon(). The event-loop contract in turn says call_soon() callbacks execute in registration order at the next event-loop iteration.
That gives us a narrow acceptance question: when an eager coroutine completes before create_task() returns, can we prove separately that coroutine completion happened synchronously, that callback registration happened afterward, that the callback itself remained deferred, and that exception-bearing eager completion behaves the same way?
This playbook answers that question with a disposable single-process fixture, synthetic inputs, CPython 3.13.5 as the executed baseline, an independently authored expected-case manifest, a negative control using the default task factory, an evidence ledger, and an explicit ACCEPT / REPAIR / RERUN / HOLD gate. No claim is extended to unexecuted Python versions, alternative event loops, patched interpreters, threads, frameworks, or production side effects.
Define the acceptance contract before touching the scheduler
The acceptance contract must distinguish four events that ordinary logs often collapse into one: coroutine body entry, Task terminal state, callback registration, and callback execution. Under the eager factory, the first two can occur inside the call that constructs the Task. Callback execution cannot be inferred from that completion because Python gives already-done callbacks a separate call_soon() path.
For this qualification, a synchronous eager success is accepted only when all of the following are evidenced: the coroutine records coro:start and coro:return before after:create_task; the returned task is already done; callbacks A and B are registered only after that point; neither callback has executed at the after:add_done_callback checkpoint; and both subsequently execute as event-loop callbacks. An eager synchronous exception has the same ordering requirement, except the terminal Task must hold the synthetic ValueError and callback code must retrieve that exception rather than leave it unobserved.
The exception requirement matters operationally. Python’s development guidance explains that exceptions stored in Tasks or Futures but never retrieved may later produce a “Task exception was never retrieved” diagnostic. Debug mode is available through asyncio.run(..., debug=True) and other mechanisms, so this fixture runs with debug enabled and deliberately calls task.exception() for failed terminal tasks.
The blocking boundary is equally important. If an eager coroutine reaches an operation that suspends it, eager execution stops there and ordinary event-loop scheduling resumes. Python describes eager Tasks as being scheduled only when they block. Consequently, a callback registered after create_task() in that case is registered while the Task is still pending rather than after completion.
The default-factory case is the negative control. With no eager factory, create_task() schedules coroutine execution instead of running the body synchronously before returning. Python’s coroutine-and-task documentation distinguishes creating a coroutine object, scheduling a Task, and later execution; that distinction is exactly what the negative control must preserve.
Refonte’s guide to the asyncio.gather sibling task lifecycle tracks which sibling Tasks remain alive after gather() propagates an exception, whether the workers complete, and what side effects they produce. Here, the question is when a callback can observe a single Task that finishes during construction.
A compact contract looks like this:
Case | Required pre-drain state | Required callback behavior | Required terminal state |
eager_sync_return | coroutine has returned; Task done | A/B deferred, never inline | result ok |
eager_sync_raise | coroutine has raised; Task done | A/B deferred; exception visible | ValueError stored |
eager_blocks_once | coroutine entered; Task pending | callbacks attached while pending | later result ok |
lazy_sync_return_negative_control | coroutine not yet entered; Task pending | callbacks attached while pending | later result ok |
A passing task.done() by itself is therefore not release evidence. It says the Task is terminal; it does not state whether its coroutine ran eagerly, whether it returned or raised, whether a callback was already registered at completion, or whether a post-completion callback has yet executed. Python documents Future.done() as covering result, exception, or cancellation, and documents result() and exception() separately.
Pin the runtime, disposable fixture, and independent oracle
The executed baseline for this research was CPython 3.13.5, reported by the interpreter as:
3.13.5 (main, Jul 15 2026, 20:25:40) [GCC 14.2.0]
CPython
Linux-6.18.57-x86_64-with-glibc2.41
asyncio.eager_task_factory available: TruePython.org records CPython 3.13.5 as the fifth 3.13 maintenance release, released June 11, 2025. Later 3.13 patches have superseded it. At the time of the fixture report, the maintained 3.13 documentation identified itself as 3.13.18. The execution record covers 3.13.5 only.
The relevant public semantics are stable across the cited 3.13 documentation: eager execution starts during Task construction; callbacks added to an already-completed Future are scheduled with call_soon(); and call_soon() callbacks run in registration order. The exact CPython v3.13.5 source is also available under the tagged Lib/asyncio/tasks.py and Lib/asyncio/futures.py sources, which makes implementation inspection possible without pretending implementation structure is itself the cross-interpreter public contract.
The fixture is deliberately disposable: one fresh asyncio.run() invocation, one process, one thread, no network, no filesystem state beyond optional captured JSON, no database, no wall-clock sleeps, and no external service. Synthetic literal values identify every outcome. The only suspension primitive is asyncio.sleep(0), used as an event-loop yield rather than a timing assertion.
Refonte’s asyncio.to_thread context-capture validation also distinguishes coroutine construction, Task creation, and execution. It traces when the execution context is captured and explicitly excludes eager task factories.
Save this as eager_callback_fixture.py:
import asyncio
import json
import platform
import sys
EVENTS = []
SEQ = 0
def emit(case, event, data):
global SEQ
SEQ += 1
EVENTS.append({
"seq": SEQ,
"case": case,
"event": event,
data,
})
def done_callback(case, name):
def callback(task):
payload = {
"done": task.done(),
"cancelled": task.cancelled(),
}
if not task.cancelled():
exc = task.exception()
payload["exception"] = repr(exc) if exc else None
emit(case, name, payload)
return callback
async def sync_return(case):
emit(case, "coro:start")
emit(case, "coro:return")
return "ok"
async def sync_raise(case):
emit(case, "coro:start")
emit(case, "coro:raise")
raise ValueError("synthetic-eager-failure")
async def blocks_once(case):
emit(case, "coro:start")
await asyncio.sleep(0)
emit(case, "coro:resume")
emit(case, "coro:return")
return "ok"
async def run_case(case, mode, coroutine_factory):
loop = asyncio.get_running_loop()
if mode == "eager":
loop.set_task_factory(asyncio.eager_task_factory)
elif mode == "lazy":
loop.set_task_factory(None)
else:
raise ValueError(mode)
emit(case, "case:start", mode=mode)
loop.call_soon(emit, case, "ready:before")
task = asyncio.create_task(
coroutine_factory(case),
name=case,
)
emit(
case,
"after:create_task",
done=task.done(),
)
task.add_done_callback(
done_callback(case, "done:A")
)
task.add_done_callback(
done_callback(case, "done:B")
)
emit(
case,
"after:add_done_callback",
done=task.done(),
)
loop.call_soon(emit, case, "ready:after")
await asyncio.sleep(0)
emit(
case,
"after:drain1",
done=task.done(),
)
await asyncio.sleep(0)
emit(
case,
"after:drain2",
done=task.done(),
)
outcome = {
"done": task.done(),
"cancelled": task.cancelled(),
}
if task.done() and not task.cancelled():
exc = task.exception()
outcome["exception"] = repr(exc) if exc else None
if exc is None:
outcome["result"] = task.result()
emit(case, "case:end", outcome)
loop.set_task_factory(None)
async def main():
emit(
"__meta__",
"runtime",
python=sys.version.split()[0],
implementation=platform.python_implementation(),
platform=platform.platform(),
eager_factory=hasattr(
asyncio,
"eager_task_factory",
),
)
await run_case(
"eager_sync_return",
"eager",
sync_return,
)
await run_case(
"eager_sync_raise",
"eager",
sync_raise,
)
await run_case(
"eager_blocks_once",
"eager",
blocks_once,
)
await run_case(
"lazy_sync_return_negative_control",
"lazy",
sync_return,
)
print(json.dumps(EVENTS, indent=2))
if name == "__main__":
asyncio.run(main(), debug=True)The expected state must not be generated from those observations. Author it separately before accepting the run. Save the following as expected_manifest.json:
{
"schema": 1,
"runtime_policy": {
"implementation": "CPython",
"python": "3.13.5"
},
"cases": {
"eager_sync_return": {
"mode": "eager",
"after_create_task_done": true,
"terminal_exception": null,
"terminal_result": "ok",
"ordered_events": [
"coro:start",
"coro:return",
"after:create_task",
"after:add_done_callback",
"ready:before",
"done:A",
"done:B",
"ready:after"
]
},
"eager_sync_raise": {
"mode": "eager",
"after_create_task_done": true,
"terminal_exception":
"ValueError('synthetic-eager-failure')",
"ordered_events": [
"coro:start",
"coro:raise",
"after:create_task",
"after:add_done_callback",
"ready:before",
"done:A",
"done:B",
"ready:after"
]
},
"eager_blocks_once": {
"mode": "eager",
"after_create_task_done": false,
"terminal_exception": null,
"terminal_result": "ok",
"ordered_events": [
"coro:start",
"after:create_task",
"after:add_done_callback",
"ready:before",
"coro:resume",
"coro:return",
"ready:after",
"after:drain1",
"done:A",
"done:B"
]
},
"lazy_sync_return_negative_control": {
"mode": "lazy",
"after_create_task_done": false,
"terminal_exception": null,
"terminal_result": "ok",
"ordered_events": [
"after:create_task",
"after:add_done_callback",
"ready:before",
"coro:start",
"coro:return",
"ready:after",
"after:drain1",
"done:A",
"done:B"
]
}
}
}The independence property is procedural, not magical. The harness records facts but contains no expected event list. The manifest declares expectations but executes no coroutine. Review them separately; then reconcile them. Copying observed output into expected_manifest.json after a failure destroys the oracle and turns the test into self-confirmation.
Reproduce synchronous completion and callback ordering
The central case uses a coroutine that returns without suspending.
Observed on the pinned CPython 3.13.5 fixture: sync_return() entered and returned before asyncio.create_task() returned to the caller. task.done() was already True at after:create_task. After callbacks A and B were registered, the immediate next ledger event was still after:add_done_callback; neither callback had executed inline.
Only after control yielded to the event loop did the queued entries execute:
coro:start
coro:return
after:create_task done=True
after:add_done_callback done=True
ready:before
done:A
done:B
ready:afterThat observation matches the documented decomposition. The eager factory executes a non-blocking coroutine synchronously during Task construction, so its body can finish before the Task is returned. Once the Task is already done, add_done_callback() schedules each callback with loop.call_soon() instead of calling it immediately. Because ready:before had been registered first, followed by callback A, callback B, and ready:after, their observed order matched the documented call_soon() registration-order rule.
The eager Task constructor ran the coroutine to completion before create_task() returned. The event loop never scheduled a separate step to run its body. The callback was registered after the Task had finished. Registration queued the callback through call_soon(), and the callback executed when the event loop regained control.
Consider a callback registered immediately after Task creation.
task = asyncio.create_task(cached_lookup())
task.add_done_callback(record_completion)This code does not imply that record_completion was present while cached_lookup() executed. With eager startup and a synchronous cache-hit path, cached_lookup() may have finished before the assignment to task completes. The callback still receives the terminal Task later, but it cannot retroactively observe an in-body checkpoint that was never recorded independently. The Python eager-factory documentation explicitly identifies immediate coroutine execution and changed ordering as semantic changes.
This is also why a callback API should not be used as proof that a callback “participated in completion.” It may simply have been registered after completion and queued afterward.
The eager exception case produced the same temporal structure:
coro:start
coro:raise
after:create_task done=True
after:add_done_callback done=True
ready:before
done:A exception=ValueError(...)
done:B exception=ValueError(...)
ready:afterThe ValueError("synthetic-eager-failure") did not escape synchronously from the create_task() call in this executed CPython 3.13.5 case; it became the Task’s stored terminal exception, which the callbacks later retrieved. That result is an observed CPython 3.13.5 outcome, with no guarantee of the same outcome across implementations. The documented eager behavior says a coroutine that raises synchronously is never scheduled to the event loop, while the Future contract defines exception() as the operation that returns the stored terminal exception.
A related example is asyncio.shield cancellation and task completion. A worker can outlive cancellation of its shielded waiter. A done callback can classify the worker’s terminal state, while the question of whether it was registered before the worker completed remains separate.
The controlled blocking case proves the opposite registration boundary. blocks_once() entered synchronously under the eager factory, but await asyncio.sleep(0) forced suspension. At after:create_task, the Task was therefore pending. A and B were attached to a pending Task, not queued immediately as callbacks for an already-done Task. The observed ledger was:
coro:start
after:create_task done=False
after:add_done_callback done=False
ready:before
coro:resume
coro:return
ready:after
after:drain1 done=True
done:A
done:B
after:drain2The difference is the useful discriminator: eager does not mean “always fully synchronous.” It means execution begins synchronously and continues that way only until the coroutine completes, raises, or reaches a suspension boundary. Python’s eager-factory documentation states exactly that Tasks are scheduled when the eager coroutine blocks.
Use the negative control and preserve failure evidence
The negative control disables the custom factory with loop.set_task_factory(None) and runs the same sync_return() coroutine. The 3.13 event-loop documentation defines None as restoring the default task factory, while the normal Task documentation describes create_task() as scheduling coroutine execution.
The observed CPython 3.13.5 sequence changed immediately:
after:create_task done=False
after:add_done_callback done=False
ready:before
coro:start
coro:return
ready:after
after:drain1 done=True
done:A
done:B
after:drain2That negative control is essential because otherwise a harness that merely reports eventual callback execution could pass under both eager and ordinary scheduling without proving anything about eager startup. The control establishes a concrete discriminating signal: under the executed eager synchronous cases, coro:start occurred before after:create_task; under the default factory, it occurred afterward.
A negative control must fail the assumption being challenged, not merely produce another green row. Here the challenged assumption is “create_task() returns before the coroutine body can run.” The default factory exhibits that ordering in the fixture; the eager synchronous case does not.
Refonte’s AsyncMock task-completion validation distinguishes a recorded call, entry into an await, and successful completion. It also keeps expected values independent of observed state, the same discipline used here to check eager Task construction.
Failure preservation must happen before cleanup. If any expected ordered event is missing, duplicated, or reversed, save the raw JSON first. Do not immediately reset the factory, rewrite the manifest, or rerun until the failed ledger is retained. A failed sequence is the evidence needed to distinguish a test defect from a runtime change.
For this fixture, cleanup is intentionally small: every created Task reaches a terminal state; every failed Task’s exception is retrieved; the task factory is restored to None; and asyncio.run() owns the loop lifetime. Debug mode helps surface never-awaited coroutines and never-retrieved exceptions if the fixture itself regresses. Python documents those diagnostics explicitly.
A preservation record suitable for a qualification run should contain at least:
{
"run_id": "locally-generated-unique-id",
"python": "3.13.5",
"implementation": "CPython",
"platform": "...",
"debug": true,
"manifest_revision": "reviewed-before-run",
"fixture_revision": "reviewed-before-run",
"stdout_json": "preserved",
"stderr": "preserved",
"exit_code": 0
}Do not call a failed run “flaky” merely because a second invocation passes. Ordering is the phenomenon under test. A discrepancy between two supposedly identical runs is itself a reason to investigate environmental identity, fixture mutation, interpreter patching, or unsupported scheduling assumptions.
Build the per-case evidence ledger and reconcile state
The research execution produced the following case ledger on CPython 3.13.5. These rows are observations from the disposable fixture, not claims about other Python versions.
Case | done() after create_task() | Coroutine relative to return | Callback registration state | First callback execution | Terminal outcome | Evidence status |
eager_sync_return | True | finished before return | Task already done | after event-loop yield | result ok | OBSERVED |
eager_sync_raise | True | raised before return | Task already done | after event-loop yield | stored ValueError | OBSERVED |
eager_blocks_once | False | entered, then suspended | Task pending | after later completion | result ok | OBSERVED |
lazy_sync_return_negative_control | False | body had not started | Task pending | after scheduled completion | result ok | OBSERVED |
CPython 3.12.x replay | No observations | expected same public semantic shape | EXPECTED / NOT EXECUTED | |||
CPython 3.13.18 replay | No observations | requires separate evidence | EXPECTED / NOT EXECUTED | |||
CPython 3.14.x replay | No observations | requires separate evidence | EXPECTED / NOT EXECUTED | |||
CPython 3.15.x replay | No observations | requires separate evidence | EXPECTED / NOT EXECUTED | |||
PyPy or alternative event loop | No observations | outside qualification | EXPECTED / NOT EXECUTED | |||
The Python 3.14 task documentation and the 3.15 documentation describe the same eager-factory behavior. Python 3.14 also extended support for eager start during task creation. Each of those runtimes still requires a separate execution record.
Reconciliation should be mechanical. For each case, compare the recorded event sequence with the independently authored manifest; then compare terminal state separately. Do not derive expected callback order from the log you just generated.
A compact verifier can be added as reconcile.py:
import json
import sys
manifest_path, observed_path = sys.argv[1:3]
manifest = json.load(open(manifest_path))
observed = json.load(open(observed_path))
runtime = next(
row for row in observed
if row["case"] == "__meta__"
and row["event"] == "runtime"
)
policy = manifest["runtime_policy"]
if runtime["implementation"] != policy["implementation"]:
print("HOLD: implementation mismatch")
raise SystemExit(2)
if runtime["python"] != policy["python"]:
print("HOLD: Python version mismatch")
raise SystemExit(2)
failures = []
for case, expected in manifest["cases"].items():
rows = [r for r in observed if r["case"] == case]
events = [r["event"] for r in rows]
cursor = 0
for event in expected["ordered_events"]:
try:
cursor = events.index(event, cursor) + 1
except ValueError:
failures.append(
f"{case}: expected ordered event missing: {event}"
)
break
after_create = next(
r for r in rows
if r["event"] == "after:create_task"
)
if (
after_create["done"]
!= expected["after_create_task_done"]
):
failures.append(
f"{case}: after:create_task done mismatch"
)
terminal = next(
r for r in rows
if r["event"] == "case:end"
)
if (
terminal.get("exception")
!= expected.get("terminal_exception")
):
failures.append(
f"{case}: exception mismatch"
)
if "terminal_result" in expected:
if (
terminal.get("result")
!= expected["terminal_result"]
):
failures.append(
f"{case}: result mismatch"
)
if failures:
print("REPAIR")
for failure in failures:
print(failure)
raise SystemExit(1)
print("ACCEPT")Run the fixture and reconciliation as separate steps:
python3 eager_callback_fixture.py > observed.json
python3 reconcile.py expected_manifest.json observed.jsonThat separation gives the evidence bundle three identities: fixture source, independent manifest, and observed output. A real release process should additionally record source hashes or version-control revisions before execution. Do not compute a hash after editing the failed fixture and then attach it retroactively to the old output.
The event ledger also clarifies documented contract versus observation:
Statement | Evidence class |
eager factory begins coroutine execution synchronously | DOCUMENTED CONTRACT |
synchronously returning/raising eager coroutine is not scheduled for coroutine execution | DOCUMENTED CONTRACT |
callback added after completion is scheduled via call_soon() | DOCUMENTED CONTRACT |
call_soon() callbacks run in registration order | DOCUMENTED CONTRACT |
CPython 3.13.5 produced ready:before, A, B, ready:after | OBSERVED RESULT |
an external callback cannot be attached through normal post-create_task() code before a synchronously eager coroutine finishes | ENGINEERING INFERENCE from the construction boundary |
later Python patch versions will reproduce this exact ledger | EXPECTED / NOT EXECUTED |
Repair the smallest boundary and define recovery
The first repair rule is not “disable eager execution.” The repair depends on what contract actually failed.
If application code incorrectly assumes that a callback registered immediately after create_task() must have been present before the coroutine body ran, repair that assumption. A post-creation done callback is a terminal notification mechanism; under eager synchronous completion it can be post hoc. If the required observation must occur inside the operation before completion, instrument the coroutine or the operation boundary itself rather than pretending callback registration happened earlier.
For example, this pattern is unsafe as proof of startup observation:
task = asyncio.create_task(operation())
task.add_done_callback(record)record can still classify the terminal Task correctly, but it cannot establish that it was registered before an eager synchronous operation() ran.
A bounded repair is:
async def operation_with_evidence(ledger):
ledger.append("operation:entered")
result = compute_from_memory()
ledger.append("operation:completed")
return result
task = asyncio.create_task(
operation_with_evidence(ledger)
)
task.add_done_callback(record_terminal_state)Now in-body evidence and terminal notification have different responsibilities. The eager factory may alter when operation_with_evidence() executes, but it cannot erase the explicit entry and completion records already authored inside the coroutine.
If the defect instead lies in a callback that assumes success merely because task.done() is true, repair the callback to classify cancellation, exception, and result separately. That follows the documented Future/Task terminal-state APIs rather than assuming “done” means successful.
def record_terminal_state(task):
if task.cancelled():
ledger.append(("cancelled", task.get_name()))
return
exc = task.exception()
if exc is not None:
ledger.append((
"failed",
task.get_name(),
type(exc).__name__,
))
return
ledger.append((
"succeeded",
task.get_name(),
task.result(),
))A rollback for this laboratory requires only deleting the generated evidence directory or discarding the in-memory run and starting another fresh process. There are no durable side effects. A production system cannot inherit that conclusion. The eager Task APIs provide scheduling and Task-state semantics; they provide no application transaction rollback, idempotency, message deduplication, or external-effect reconciliation guarantee. Those concerns are outside this playbook’s scope.
Refonte’s asyncio.Queue.join processing validation separates a synchronization signal from independent evidence that work actually happened. Its expected manifest tests queue processing. This fixture needs its own expectations for eager Task startup.
The recovery protocol is fail-closed:
Preserve observed.json, stderr, runtime fingerprint, fixture identity, and manifest identity before changing anything.
Classify whether the mismatch is an implementation defect, harness defect, unsupported runtime, incomplete evidence, or environmental interruption.
Repair only the smallest identified boundary. Do not simultaneously change Python version, test cases, event instrumentation, and manifest.
Start a clean process with the same reviewed manifest when a rerun is justified.
Run the negative control again. A repaired eager case without its discriminating default-factory control is incomplete evidence.
Compare the full case inventory. Never promote a partial rerun into acceptance of the original batch.
Post-repair verification must include both the repaired case and at least one case that was already passing. Otherwise a repair may merely move the ordering defect. For this playbook, an eager callback repair must re-run eager_sync_return, eager_sync_raise, and lazy_sync_return_negative_control; the blocking case should also remain in the canonical batch because it proves the eager-to-scheduled boundary.
Assign responsibility for the interpreter pin, fixture revision, manifest revision, and decision record to the runtime owner.
Apply the ACCEPT, REPAIR, RERUN, or HOLD gate
The decision gate must consume evidence, not confidence.
Evidence state | Decision | Required action |
pinned runtime matches; all canonical cases present; observed ledger matches independent manifest; negative control discriminates eager from default scheduling | ACCEPT | archive evidence with bounded version claim |
complete evidence proves fixture or application logic violates the declared contract | REPAIR | change smallest failing boundary, then execute full verification |
fixture and manifest are sound, but execution was interrupted or evidence capture failed for an environmental reason that does not invalidate prior state | RERUN | use clean disposable state and same reviewed inputs |
runtime differs from qualified pin; manifest was edited after seeing results; case inventory is incomplete; prior state cannot be reconstructed; unexplained ordering divergence remains | HOLD | investigate before another acceptance claim |
For the run performed for this research, the appropriate bounded decision is ACCEPT for the four-case CPython 3.13.5 disposable fixture. All four cases completed, the eager synchronous return and raise cases were already done when create_task() returned, post-completion callbacks were not invoked inline, the callbacks later appeared in expected call_soon() order, the blocking case crossed into scheduled execution, and the default-factory negative control produced a different startup boundary.
That ACCEPT does not accept CPython 3.13 generally, CPython 3.14 or 3.15, another event-loop implementation, an application framework that installs a different task factory, or a production callback that performs external side effects. Those are EXPECTED / NOT EXECUTED until separately qualified. Python’s own eager-factory documentation warns that immediate execution changes semantics and can alter task execution order; that warning is a reason to preserve version-specific evidence rather than generalize one ledger.
For broader backend training, the Refonte Learning Backend Development Program describes a three-month course requiring 10–12 hours per week. Applicants need a basic understanding of programming and must be working toward a bachelor’s degree or higher. The curriculum covers Node.js and Express, MongoDB and SQL, REST APIs and microservices, authentication and authorization, testing and debugging, Docker and cloud deployment, and a capstone.
The program includes hands-on projects and describes a potential internship experience. Successful completion can include a Training Certificate and a Certificate of Internship. Consult the current curriculum and admissions terms for details. The published outline does not list asyncio.eager_task_factory as a topic.
