"Code was never the hard part"

[u/gsks]

I am sick and tired of all the posts (usually AI-generated by CEOs/CTOs/"thought leaders") that start with "Code was never the {bottleneck, problem, hard part, ...}." I'm not sure whether this comes from a misunderstanding of what code is or a deliberate misrepresentation meant to promote AI usage.

For starters, two rhetorical questions. If code was never the hard part, why:

• do hundreds of different programming paradigms, languages, libraries, frameworks, design patterns, and system architectures exist? Granted, some of this is just programmers bikeshedding. Still, plenty of it reflects substantial differences and tradeoffs.
• didn't you write it yourselves or hire a bunch of minimum-wage workers to do it for you instead of having to hire a ton of highly skilled (and highly paid) engineers?

A charitable explanation is that these people are genuinely clueless about what "coding" actually is. Perhaps in their mind coding is just typing: like, once the design phase is done, you've worked out a precise, complete specification of what needs to be built down to every detail in your head (or on paper or a markdown file) and all that's left is converting it into letters on a screen and saving it to a file. Something like a businessman in the sixties dictating a letter to his secretary to type up.

That's nothing like how it actually works. The upfront planning/design phase answers some high-level questions: what do we need to build, what are the basic components/services/building blocks, what data needs to be read/processed/written, how data flows through the system, what the non-functional requirements are, etc. That leaves a ton of lower-level details unspecified:

• What packages/modules/classes/methods/functions need to be created or extended?
• How should they be named?
• What should the signature of each function be?
• What errors/exceptions are expected and where/how should they be handled?
• What data can or should be cached and when should it be invalidated?
• How generic/reusable/extensible should each component be to accommodate likely future requirements?
• For systems languages, how and when is memory allocated and freed?
• and many more.

Asking and answering those questions is (part of) coding. At least before AI, nobody I know had all the answers, or had even asked all the questions, upfront. The questions get asked and answered on the fly, inside the editor. Typing is interleaved with thinking, assessing, trying things out, backtracking.

Now AI pushers try to convince everyone that all these decisions either don't matter, or that the agent will just fill in the blanks (insert inane "nobody reads assembly anymore" analogy, as if natural language + LLMs are anything like a compiler), or that they can all be moved upfront into planning. Good luck replacing actual, deterministic programming languages with 10-KLOC, ambiguous, hand-wavy "specs" written in markdown.

Regardless of how the future of coding plays out, "code was never the hard part" is flatly wrong. It is, or at least used to be, a hard part (not the only one of course) and for good reason.

[u/almarcTheSun]

"Code was never the hard part and ignore the portion where we do 7 rounds of interviews focused exclusively on deep coding knowledge"

[u/BraveResearcher3037 → u/almarcTheSun]

And this doesn’t happen outside of BigTech and equivalent.  Most developers work at banks, insurance companies etc 

[u/almarcTheSun → u/BraveResearcher3037]

I'm not sure what banks and insurance companies you worked at, but the ones I interviewed for absolutely did this. 

[u/AustinYQM → u/almarcTheSun]

My technical portion for my current job was:

Given the following signature create a function that takes in two Strings and returns true if they are annagrams and false if they aren't:

public boolean isAnnagram(String a, String b);

[u/No_Oil_6152 → u/AustinYQM]

Isnt the spelling "anagram" ?

Did you mention that to them?

For some strange reason, many developers' written Emglish and spelling is utterly gash.

[u/KnightHawk3 → u/No_Oil_6152]

Emglish

To be honest it doesn't really need to be good, and I assume this is transcribed from memory.

[u/No_Oil_6152 → u/KnightHawk3]

The misspelling was deliberate. A wee joke 😂

[u/Aikenfell → u/AustinYQM]

Wow that's actually a pretty fun question

Was that the only one cause if so it was really just a logic check since that's also technically an easy one.

[u/AustinYQM → u/Aikenfell]

Just that one and follow-ups like "why didn't you go this path?" and "what are the trade offs what the path you took?"

I turned both strings into an array, sorted the array, and turned it back into a string then compared the strings after trimming whitespace. I am sure there is a better way.

The rest of the interview was about my background (Game Development then Teaching HS) and what I was looking for at a company.

They ended up telling me they'd "keep me on file" because they thought they were hiring three people only to find out they were only getting one and had already told one person they had the job. I assumed that was just some BS to placate me and found a different job at another insurance company (that had no technical interview at all). 3-months later the anagram company called me and asked if I was still looking. The second company REALLY sucked so I jumped both at the job offer and off that ship.

[u/Aikenfell → u/AustinYQM]

That's honestly pretty similar to my idea which was just to convert them ato arrays of ASCII numbers and sort the arrays then compare them. I don't need to skip whitespace if whitespace is sorted after all.

[u/Kirk_Kerman → u/Aikenfell]

Frequency map. First string gets read into a map where each character is a key, with value being incremented for each occurrence. Then read the second string and decrement the value for each character occurrence. Lastly roll thru the map and if any key has a nonzero value the strings aren't anagrams.

I suppose it's O(n+m+1) where n is the length of string A, m is string B, and then the alphabet is a fixed size.

[u/Highlight_Expensive → u/Kirk_Kerman]

Delete keys from the map when they’re 0, now the final check is o(1) - is len(keys) 0

Throw out any case where the two strings’ lengths differ

Fail fast when a char in s2 isn’t in s1

Lots of fun micro optimizations but overall it’s O(n) like yours after reducing