IBM App Connect Enterprise v12.0 Developer (C1000-171) Practice Exam

An ACE v12.0 developer must receive messages from a queue and route each to one of three back-ends based on message content.

1. Use a single output node and send the same message to all three back-ends
2. Build a flow with an MQInput node, a Route node evaluating content-based XPath conditions to distinct output terminals, and a path to the relevant back-end (MQOutput or HTTPRequest) on each
3. Skip routing logic and let each back-end filter for its own messages
4. Implement the routing in an external shell script outside ACE

A developer must correlate request and response messages in an asynchronous integration so replies match back to the original request.

1. Rely on message arrival order to pair requests with replies
2. Send request and response with no correlation and hope they align
3. Use a request-reply pattern with correlation identifiers (MessageID / CorrelationID) so the responding flow can match each reply to its originating request
4. Use a single flow that blocks indefinitely waiting for each reply

A flow must tolerate poison messages (messages that repeatedly fail processing) without stopping the input queue.

1. Silently delete any message that causes an error
2. Configure a backout queue and backout threshold, and handle failures on the Failure terminal or an exception path so poison messages are diverted rather than blocking the queue
3. Let the flow keep retrying the poison message indefinitely
4. Remove error handling so the flow never stops

A developer must transform a message from JSON input to XML output that conforms to a target schema.

1. Concatenate strings manually in a shell script
2. Use the graphical Mapping node (or ESQL in a Compute node) to build the XML from the JSON input and validate the result against the target schema
3. Hand-write the XML in ESQL with no schema validation
4. Skip transformation and send the JSON to the back-end as if it were XML

A developer must decide between ESQL and Java Compute for a complex transformation. What is the sound basis for the choice?

1. Use ESQL where its message-tree navigation is natural, and Java Compute where the transformation needs complex external libraries or logic that benefits from Java’s ecosystem — choose based on the transformation’s shape and the team’s skills
2. Always use ESQL regardless of the transformation’s complexity
3. Always use Java Compute even for simple message manipulation
4. Mix ESQL and Java at random within each flow

A solution must deliver each event to multiple independent consumers, decoupling producers from consumers.

1. Call each consumer directly in a loop from the publisher
2. Email every consumer for each event
3. Publish to a topic (for example via the Publication node) and let each consumer subscribe independently, so producers and consumers stay decoupled
4. Put all events on one queue and have consumers compete for them

A flow must collect responses from several back-ends and combine them into a single reply before returning to the caller.

1. Call the back-ends one after another and accept the cumulative latency
2. Use an aggregation approach — for example the Collector node (or Group Scatter/Gather nodes) — to fan out requests, collect the related responses, and assemble a combined reply
3. Query only one back-end and ignore the rest
4. Return several separate replies to the caller instead of one

A developer must promote flows through test, stage, and production without rebuilding them in each environment.

1. Rebuild the flows by hand in each environment
2. Copy flows between environments on a shared drive with no versioning
3. Package the flows into a BAR file, override environment-specific values (queue names, URLs) with policies or BAR overrides, and deploy the same BAR to each environment’s integration server
4. Deploy straight to production with no intermediate environments

A team must run ACE integration servers in containers on Red Hat OpenShift with managed scaling.

1. Keep everything on a single bare-metal machine and skip containers
2. Run integration servers only on developer laptops
3. Use the ACE-on-containers pattern — the App Connect Operator and Dashboard — running integration servers/runtimes as pods with BAR files deployed into them, and let Kubernetes manage scaling
4. Invent a custom deployment unrelated to OpenShift’s patterns

A developer needs to test and debug a flow interactively during development, inspecting the message at each node.

1. Use the ACE Toolkit’s Flow Exerciser (and debugger) to send test messages through the flow, step through nodes, and inspect the message at each stage
2. Deploy to production and watch what happens
3. Guess the problem by reading the flow diagram
4. Disable the flow and declare the bug fixed