The Assignment Google Couldn’t Solve for Me

There was a programming assignment called Cooked.

That was already the first problem.

The actual game was Pişti, the Turkish card game.

But because our assignments were given English names, and because the English-speaking world had apparently failed to organize itself around Pişti, somebody had named the assignment Cooked.

In May 2010, I wrote about my response.

At first, everything was beautiful.

As usual, I searched for the assignment on Google.

Then I got nothing useful.

That was the joke.

It was also a small portrait of being a computer engineering student at a particular moment in the history of the web.

The first instinct was not necessarily:

How should I design this?

It was:

Surely someone has already done this.

Search first.

Think second.

This was not always laziness.

Sometimes it was efficiency.

Programming has always involved reuse.

Documentation.

Examples.

Libraries.

Other people’s solutions.

The internet simply made that instinct immediate.

You received an assignment.

You typed its name into Google.

Maybe a student at another university had uploaded the same thing.

Maybe a forgotten course page contained sample code.

Maybe a forum had discussed it.

Maybe the professor had borrowed the idea from somewhere public.

Maybe someone, somewhere, had already suffered on your behalf.

The web gave students a new form of optimism.

No matter how annoying the assignment looked, there was always a chance that the answer already existed.

You just had to find the correct words.

That belief depended on names.

And Cooked was a terrible name for search.

Search engines are powerful, but they are not mind readers.

You type Cooked.

The internet does not know that you mean:

a programming implementation of a Turkish card game called Pişti, given an English assignment title by someone who needed the title to sound international.

The internet hears:

cooked.

Food.

Recipes.

Things that have been heated.

Maybe slang.

Almost everything except your homework.

The assignment had escaped Google by accident.

Not through sophisticated anti-cheating technology.

Not through a private repository.

Not through an original algorithm.

Through vocabulary.

That is beautiful.

A problem that might have been searchable under its real cultural name had become almost invisible because its translated title was too ordinary.

Language defeated copy-paste.

For a student accustomed to searching assignment names, this was betrayal.

I had done my part.

I had opened Google.

What more did education want from me?

Apparently:

the assignment.

There is a strange educational moment when searching stops producing answers and you realize the remaining person in the process is you.

This is uncomfortable.

The internet has trained us to expect a trail.

An example.

A tutorial.

A Stack Overflow answer.

A GitHub repository, in later years.

A video.

A blog post.

Something.

When nothing appears, the problem suddenly feels much more personal.

You are no longer browsing knowledge.

You are responsible for producing some.

That can be frightening.

It can also be the beginning of actual learning.

The original entry does not say how I eventually completed the assignment.

It does not say whether I completed it successfully at all.

It does not say which language we used, what the requirements were, whether there was a graphical interface, whether the computer played against a human, or how the cards were represented.

I should not invent any of that.

All I know is the opening move:

Assignment: Pişti.

English assignment name: Cooked.

Student strategy: Google.

Result: nothing.

That is enough.

Sometimes the first five minutes of an assignment reveal more about student life than the final submission.

The final code is formal.

The beginning is honest.

What do students actually do when they receive work?

Read the entire specification carefully?

Perhaps.

Open a blank editor and begin designing data structures?

Sometimes.

Search the exact assignment title online?

Absolutely.

This habit existed before modern generative AI, before code assistants became ordinary, before software repositories were as central to everyday development as they are now.

Students already understood something fundamental:

information wants to be copied.

The internet was full of previous semesters.

Old lecture pages.

ZIP files.

Source code forgotten on personal websites.

Homework archives.

The digital debris of education.

Universities taught the same subjects repeatedly, and the web remembered.

A clever search could turn a new assignment into an old assignment.

This created a strange race between instructors and search engines.

An instructor could change a few details.

Rename the problem.

Adjust the input.

Alter the story.

Students would search anyway.

Sometimes the disguise worked.

Apparently Cooked worked very well.

It was almost too good.

If the assignment had simply been called Pisti Card Game, perhaps the web would have had a chance.

But Cooked was camouflage made from English.

The irony is perfect because English naming was probably intended to make the work look more standard or internationally readable.

Instead, the translation made the task harder to search.

Localization produced anti-plagiarism.

Perhaps unintentionally.

I like accidental solutions.

They are more human than designed ones.

Nobody needs to build an advanced cheating-detection platform.

Just name the Pişti assignment Cooked and let Google drown the student in irrelevant results.

Problem solved.

There is another layer here about technical English.

Computer science education often moves between languages.

The conversation may be Turkish.

The textbook English.

The code English.

The variable names mixed.

The assignment title English.

The game culturally Turkish.

The student mentally translating between all of them.

That mixture creates expressions that make perfect sense inside one classroom and almost nowhere else.

Cooked may have been one of those.

Technically related to the Turkish word.

Practically useless as a search term.

But memorable.

This is one reason technical education produces its own dialect.

Words are borrowed.

Translated.

Half-translated.

Pronounced locally.

Given meanings shaped by the classroom.

Students learn not only computer science but a linguistic ecosystem around computer science.

Some of those terms survive professionally.

Others remain attached forever to a particular course or semester.

The assignment title became one of those memories for me.

I do not remember the solution in the archive.

I remember the failed search.

That says something about memory too.

The hours of actual work may disappear.

The absurd first step survives.

Maybe because frustration is easier to store than routine effort.

If the assignment had appeared on the first page of Google and I had quietly adapted some existing solution, there might be no entry.

Success is often badly documented.

Failure creates stories.

The search produced nothing.

Therefore I complained.

Years later, the complaint becomes the interesting part.

It preserves a student strategy that feels both old and completely current.

Search first.

This has not disappeared.

It has intensified.

Today the tools are different.

A student may search the web, search repositories, ask a coding assistant, ask a language model, watch a tutorial, or combine all of them.

The temptation is the same:

Can the difficult part be outsourced before I fully understand it?

Sometimes yes.

And sometimes that is perfectly reasonable.

Professional programmers do not reinvent everything.

They reuse.

They research.

They read examples.

They ask colleagues.

They use tools.

The difficult educational question is where assistance ends and learning begins.

If the purpose is to produce working software, reuse can be efficient.

If the purpose is to learn how to produce working software, reuse can quietly remove the exact struggle the assignment was designed to create.

That tension existed in 2010 too.

Google was already good enough to make it visible.

The best assignments are often resistant to simple searching not because searching is immoral, but because the student still has to make decisions.

Understand.

Adapt.

Debug.

Explain.

If a search result removes all of that, the assignment becomes file transfer.

The funny thing is that students often discover this themselves.

You find code.

Excellent.

Then it does not compile.

Or it solves a slightly different problem.

Or you cannot explain it.

Or changing one requirement breaks everything.

Borrowed understanding has poor error messages.

At some point, you have to know what the code does.

Again, none of those later events are documented for Cooked, so they do not belong to this specific story as claims.

But the failed search sits right at the boundary.

Google had declined to remove the first difficulty.

The rest was mine.

There is something nostalgic now about the phrase “I searched the homework on Google.”

It captures a simpler web habit.

Search was a place you went.

You typed keywords.

You opened tabs.

You hoped.

The process contained uncertainty.

Could the answer exist?

Could you formulate the query correctly?

Could you recognize useful code when you saw it?

Searching itself was a skill.

It still is, but the experience has changed.

Modern tools increasingly try to produce direct answers.

The older web often gave you fragments.

A forum post.

A PDF.

A personal homepage last updated six years ago.

A code sample with no explanation.

You assembled your understanding from debris.

There was frustration in that.

There was also learning hidden inside the assembly.

A bad search result could still teach you vocabulary.

A partially relevant program could reveal a structure.

Following links could move you toward the subject.

When the search term itself was bad, however, none of that happened.

Cooked gave the web the wrong question.

This remains one of the central truths of information retrieval:

the quality of the answer depends partly on the language of the question.

A powerful search engine cannot rescue a concept you have named ambiguously unless it has enough context.

This is obvious today.

It was obvious then too, just in a more comic form.

One word.

Cooked.

The entire internet available.

No homework.

Perhaps the assignment title accidentally taught a better lesson than the assignment itself.

Naming matters.

In programming, we say this constantly.

Variable names.

Function names.

Classes.

Interfaces.

Files.

Projects.

The name should carry enough meaning that another person can understand what they are looking at.

Cooked failed this test magnificently.

It was clever only if you already knew the joke.

Without context, it communicated almost nothing.

That made it a terrible public identifier and an excellent defense against students searching for ready-made code.

The same name can be bad engineering and good pedagogy.

Context changes the score.

I also enjoy the confidence of the phrase “as usual.”

I searched Google as usual.

No embarrassment.

No elaborate justification.

That was simply part of the workflow.

Assignment arrives.

Google opens.

This honesty is useful.

Students are often described in idealized terms by educational documents.

They analyze.

They research.

They apply theoretical knowledge.

Yes.

They also look for shortcuts.

Everyone does.

Adults call their shortcuts productivity.

Students call theirs Google.

A professional engineer searches an error message and is considered resourceful.

A student searches an assignment title and suddenly we need an ethics committee.

The distinction is real, but not as clean as we pretend.

Both are trying not to solve an already solved problem.

The educational difference is whether solving the problem is itself the thing being practiced.

That nuance matters.

What I like about the old entry is that it does not try to resolve any of this.

It just laughs.

I searched.

Nothing.

Wonderful.

Now I have to work.

That is enough philosophy for a homework assignment.

The memory belongs in the same category as many student-life moments that seemed annoying then and charming later.

The impossible course.

The confusing assignment.

The professor’s strange terminology.

The program that works at 3 a.m. and fails during demonstration.

The library computer.

The printed notes.

The first time an algorithm finally makes sense.

These are rarely dramatic enough to feel like life events.

But together they form the texture of education.

A degree is not experienced as a diploma.

It is experienced as hundreds of small obstacles.

Cooked was one.

And the part I preserved was not the card game.

Not the code.

Not the grade.

The search box.

That feels appropriate for a computer engineering student of the era.

Before writing anything, ask the machine.

The machine answers:

No.

Fine.

Open the editor.