two problems

Some people, when confronted with a problem, think "I know, I'll use regular expressions."

Now they have two problems.

Jamie Zawinski

Some people, when confronted with a problem, think "I know, I'll use blockchain."

Now they have two problems, immutably recorded forever.

Some people, when confronted with a problem, think "I know, I'll use multithreading."

then two they hav erpoblesms.

Ned Batchelder

Nothhw tpe yawrve o oblems.

Eiríkr Åsheim

Some people, when confronted with a problem, think "I know, I'll use Java."

Now they have a ProblemFactory.

Chris Lonnen

Now they have an AbstractProblemFactoryBean.

Some people, when confronted with a problem, think "I know, I'll use microservices."

Now they have 99 problems and monitoring is all of them.

Now they have a distributed system of problems.

Some people, when confronted with a problem, think "I know, I'll use machine learning."

Now they can't explain why they have two problems.

Now they have a 99.9% confidence level that they have two problems.

Some people, when confronted with a problem, think "I know, I'll use XML."

Now they have a problem description document.

Some people, when confronted with a problem, think "I know, I'll use Docker."

Now they have two problems, perfectly isolated from each other.

Now they have the same problem in three different environments.

Some people, when confronted with a problem, think "I know, I'll use TypeScript."

Now they have Promise<Problem<T>>.

Some people, when confronted with a problem, think "I know, I'll use NoSQL."

Now they have eventually consistent problems.

Now they have {problems: 2, scaling: 'horizontal'}.

Some people, when confronted with a problem, think "I know, I'll use Kubernetes."

Now they have problems orchestrated across multiple clusters.

Now they have pods of problems.

Some people, when confronted with a problem, think "I know, I'll use git."

Now they have merge conflicts.

Some people, when confronted with a problem, think "I know, I'll use serverless."

Now they pay per problem.

Some people, when confronted with a problem, think "I know, I'll use GraphQL."

Now they have nested problems.

Now they can query their problems efficiently.

Some people, when confronted with a problem, think "I know, I'll use WebAssembly."

Now they have problems at near-native speed.

Now they have problems in multiple languages at once.

Some people, when confronted with a problem, think "I know, I'll use agile."

Now they have two-week sprints of problems.

Now they have daily standups about their problems.

Some people, when confronted with a problem, think "I know, I'll use quantum computing."

Now they have problems in superposition.

Now they're not sure if they have problems until they measure them.

Some people, when confronted with a problem, think "I know, I'll use vim."

Now they can't exit from their problems.

Some people, when confronted with a problem, think "I know, I'll use CSS."

Now they have floating problems.

Now their problems need !important.

Some people, when confronted with a problem, think "I know, I'll use AWS."

Now they have problems in multiple availability zones.

Now their problems auto-scale.

Some people, when confronted with a problem, think "I know, I'll use MongoDB."

Now their problems are Web Scale.

Some people, when confronted with a problem, think "I know, I'll use OAuth."

Now their problems need constant refreshing.

Some people, when confronted with a problem, think "I know, I'll use Flutter."

Now their problems are cross-platform.

Some people, when confronted with a problem, think "I know, I'll use Arduino."

Now they have hardware problems.

Now their problems need proper grounding.

Some people, when confronted with a problem, think "I know, I'll use binary."

Now they have 10 problems.

Ned Batchelder

Some people, when confronted with a problem, think "I know, I'll use floating point arithmetic."

Now they have 1.999999999997 problems.

Tom Scott

Some people, when confronted with a problem, think "I know, I'll use Ruby."

Now their problems are all elegant.

Some people, when confronted with a problem, think "I know, I'll use npm."

Now they have dependency problems.

Some people, when confronted with a problem, think "I know, I'll use Safari."

Now their problems only work in Chrome.

Some people, when confronted with a problem, think "I know, I'll use large language models."

Now they're 87% confident they have two problems, but they hallucinated three more.

Now their problems are token-limited and need context windows.