New Information vs Shared Information

By the end of this lesson, you will be able to...

• Track when a technical object changes from new information to shared information.

• Maintain a, an, and the across several sentences or messages.

• Reintroduce an object when a new reader does not share the earlier context.

Idea in one sentence: Introduce an object with a or an, then use the while the reader can still identify the same object.

Core Insight

A technical conversation changes what its readers know.

At the start of a debugging thread, nobody has mentioned a worker. One engineer writes:

A worker stopped after a retry.

Now the worker is part of the conversation. The next message can say:

The worker is still healthy, but the retry exposed a bug.

A worker introduces one worker. The worker points back to it. The same movement happens with a retry and then the retry.

The important question is not only “Have I used this noun before?” Ask: Can this reader identify the object from the conversation we share? Article choice follows the reader's changing knowledge.

A Debugging Thread

Nora and Sam are debugging a queue worker. Nora begins with this message:

We saw an error in a worker after a retry.

This sentence introduces three objects:

• an error: one error that Sam has not seen in this conversation;
• a worker: one worker that has not yet been identified;
• a retry: one retry that is new to Sam.

Sam can now use those objects as shared information:

Did the error stop the worker?

Nora replies:

No. The worker finished the retry, but the retry exposed a bug in the parser.

The old objects use the. The bug is new, so Nora uses a bug. If the conversation continues, Sam can ask:

Does the bug affect every retry?

The bug now points to the bug Nora introduced. The article changes because the reader's context changed, not because the bug itself changed.

From Plain Meaning to Precise Terms

Plain meaning:

New information gives the reader an object that is not yet identifiable. Shared information points to an object that both writer and reader can now find.

In this debugging thread:

a worker -> the worker
a retry  -> the retry
a bug    -> the bug

Technical name:

A and an are indefinite articles. They often introduce one member of a group. The is the definite article. It tells the reader that the intended object is identifiable from earlier text or shared context.

These names are useful, but the reader-state question does the real work:

Can the reader identify this one?
no  -> introduce or describe it
yes -> the noun can be definite

A Worked Trace: Follow Three Objects

Read the exchange one line at a time. Each line updates what Sam can identify.

The input is a conversation with no shared worker, retry, or bug. Each introduction changes the reader's knowledge. The output is a short exchange where later messages can use the without repeating a long description.

Now compare a naive version:

We saw the error in the worker after the retry.
The retry exposed the bug.

This may be correct inside a conversation that already identifies all four objects. As the opening of a new debugging thread, however, it sounds as if the reader missed an earlier message. The cannot create the missing context by itself.

Check: Nora adds a new object: ___ alert contains the stack trace. The alert has not appeared before. Which article fits?

Think first, then reveal.

Answer: Use An alert contains the stack trace. After that sentence, Nora can write The alert came from the retry worker.

Shared Context Can Come from More Than One Sentence

Earlier text is the clearest source of shared information, but it is not the only source.

The current situation

During a call about one visible dashboard, someone can say:

The graph shows a latency spike.

Nobody mentioned a graph earlier, but everyone can see which graph the speaker means. The situation identifies it.

A precise description

A description can identify an object on its first mention:

The worker that owns the retry queue stopped at 09:14.

The phrase that owns the retry queue answers “Which worker?” The noun is new in the text, but identifiable to the reader.

Team knowledge

A team may share one relevant object:

The on-call engineer acknowledged the alert.

This works when the team knows who is on call for this incident. If two teams have different on-call engineers, the sentence needs more identity:

The payments on-call engineer acknowledged the alert.

So “first mention means a” is a useful starting pattern, not a complete rule. Reader identity is the better model.

When the Reader Changes

Shared information is local to an audience. Nora and Sam may know exactly which worker they mean, but a new incident channel does not inherit their whole debugging thread.

Their private exchange ends with:

The worker fails after the retry because the bug closes the connection.

Copying that sentence alone into a new incident channel gives new readers three unexplained objects. Nora should reintroduce them:

A retry worker in the billing queue fails after its second attempt.
The worker hits a parser bug that closes the database connection.

Now the first sentence introduces and identifies the worker. The second sentence can use the worker, while a parser bug introduces the bug.

This is an important editing habit: reset the reader model when the audience, document, or thread changes. The writer remembers the old context. The new reader may not have it.

Check: A private chat has discussed one deployment for ten minutes. You open a new incident report with The deployment introduced the error. What might be missing?

Think first, then reveal.

Answer: The new report may not identify the deployment or the error. A clearer opening is A deployment of the billing service introduced an error in the retry worker. Later sentences can use the deployment and the error.

Two Correct Sentences, Two Different Contexts

Both of these sentences can be grammatical:

A worker is consuming too much memory.
The worker is consuming too much memory.

They do different jobs.

• A worker says that one worker has the problem, but the reader cannot yet identify it.
• The worker says the reader can identify the intended worker from earlier text, a dashboard, or a description.

The difference is not certainty. Both statements can be certain. The difference is whether the identity is shared.

The same contrast appears here:

A retry exposed a parser bug.
The retry exposed a parser bug.

The first sentence introduces one retry. The second points to an identifiable retry, perhaps the retry shown in the previous log line. In both sentences, a parser bug remains new information.

Common Confusions

Confusion: once an object is introduced, the works forever

Why it is tempting:

The writer still remembers the object, even after many messages or a change of channel.

Better model:

Shared information belongs to a particular context. If the audience changes or the reference becomes distant, repeat a useful description: the billing retry worker, not only the worker.

Confusion: the means the writer knows the exact object

Why it is tempting:

The writer has a specific worker in mind and therefore writes the worker.

Better model:

The reader also needs a path to that worker. If the path is missing, introduce it with a worker or identify it with a phrase such as the worker in region eu-west-1.

Confusion: repeating the full noun is bad style

Why it is tempting:

Writers often try to avoid repetition. They shorten every later reference to the worker, the service, or the error.

Better model:

Useful repetition restores identity. In a long thread with several workers, the image worker may be clearer than the worker. Clarity matters more than avoiding a repeated technical noun.

Trade-offs and Limits

The new-to-shared pattern makes a message sequence compact. Once an object has been introduced, the lets the team refer to it without repeating its full description.

The trade-off is that this compactness depends on context. A short phrase such as the worker becomes ambiguous when another worker enters the discussion, when messages arrive out of order, or when part of the conversation is copied elsewhere. The signal is a reasonable reader asking, “Which worker?” A shorter reference saves words, but a fuller technical name survives context changes more reliably.

Adding a description costs a few words, but restores the reference. This matters most in incident work, where readers join late and must act without reconstructing every earlier message:

the worker -> the billing retry worker
the error  -> the connection-closed error

Articles do not solve every identity problem. The service is still vague when five services are under discussion. They also do not tell the reader whether a noun is generic or uncountable; the next lessons add those distinctions. This lesson's smaller promise is to keep one concrete object visible while a conversation develops.

Practice: Repair a Context Change

Nora copies these lines from a private debugging chat into a new incident channel:

The worker completed the retry.
The retry exposed the bug.
The bug closed the connection.

Rewrite the opening for readers who have not seen the private chat. Introduce the worker, retry, bug, and connection. Then maintain the shared references.

Model answer:

A worker in the billing queue completed a retry.
The retry exposed a parser bug.
The bug closed a database connection.
The connection reopened after the worker restarted.

Decision trace:

1. A worker and a retry introduce two objects.
2. The retry is shared; a parser bug is new.
3. The bug is shared; a database connection is new.
4. The connection and the worker are now shared.

Another answer can be correct if it gives the new readers enough identity. For example, The billing retry worker can work on its first mention because the description identifies its role. Use this quick rubric:

• Are new objects introduced or identified?
• Can every later the point to one clear object?
• Does the wording still work for a reader who missed the private chat?

Daily Practice Lines

• We found a bug in the parser.
• The bug appears after a retry.
• The retry stops a worker in the billing queue.

Say the three lines as one story. Notice the movement: a bug becomes the bug, and a retry becomes the retry.

Resources

• [ARTICLE] Cambridge Dictionary Grammar: A/an and the - Focus on how a noun moves from first mention to an identifiable later reference.
• [ARTICLE] Microsoft Writing Style Guide: Articles - Compare article choices in concise technical instructions and descriptions.
• [ARTICLE] British Council: Articles - Review how shared context and specific descriptions can make a noun definite.

Key Takeaways

• Use a or an to introduce one countable object that the reader cannot yet identify.
• Use the when earlier text, the current situation, or a precise description lets the reader find the object.
• Track the reader's knowledge across sentences: a worker can become the worker in the next message.
• Reintroduce or rename an object when the audience changes or several possible objects compete for attention.