This story was rather poignant for me, as I am, let's just say quite a bit over 40.

I learned to program when I was in high school and noticed a Teletype 33 ASR in a corner of the math classroom. I knew about Teletypes from being a ham radio operator, but I thought they were just for sending and receiving text over the air or over a phone line to another Teletype. You could either connect to the other Teletype and type in real time, or you could punch a paper tape first and then send it over the air or across the wire at the full speed of 10 characters per second.

https://en.wikipedia.org/wiki/Teletype_Model_33

This Teletype was special, though. The school had an account with a local timesharing computer company, and for a mere $30 per hour ($200/hour in today's dollars) you could dial in and run a BASIC program.

https://en.wikipedia.org/wiki/Time-sharing

Naturally my first program was:

10 PRINT "HELLO"

and it printed HELLO!

You can probably guess the next line I added to the program:

20 GOTO 10

Whoops! This wasn't just text scrolling on a screen, it printed out line after line on the roll of Teletype paper. Had to hang up the dialup modem fast.

That summer I got a job as "night operator" at the timesharing company (Transdata in Phoenix, AZ). The great thing about this job was they shut down the timesharing service at night. So I had their SDS Sigma 5 all to myself. My first personal computer!

I found a copy of the Algol-60 Report and taught myself Algol. And then Sigma 5 machine language. It was great fun to see how much of a program I could write on a single punch card (80 bytes).

We had a nice single-card program that you could put in front of a deck of cards to print out the whole card deck. But it was kind of slow, because it would read a card, print the card, read the next card, print that one, etc.

There were a few bytes left on that print program card, so I squeezed in code for a double buffer. It would read the first card, start it printing, and then while it printed read in the next card, overlapping the reads and writes so it printed twice as fast.

That fall I went to Caltech, lasted a year and flunked out. I loved science and math, but when we got to partial differential equations my mind just couldn't handle it. But there was a systems programming class, and the final project was to write an infix expression parser and evaluator with operator precedence in assembly language.

I was the only person in the class to turn in a complete working program with test cases. I could probably tell you exactly where I was sitting when the instructor announced the results. I had found my calling, and have been at it ever since.

My secret weapon: while everyone was punching cards with their program, submitting the batch job, and waiting hours or overnight for the core dump when it crashed, I found an interactive console on campus where I could code and run and test my program in real time. Just like the Teletype I learned on.

Moving forward to the present, I interviewed with a FAANG company last week. It reminded me a bit of the discouraging experience the article's author initially had with LOGO and competitive programming.

Everyone I interviewed with, and the company recruiters, were all super nice and supportive. But the gist of the interview process was to tackle four medium to hard algorithm problems and come up with not only a working solution but a perfectly optimized solution, in 15 minutes each!

The recruiters advised me to spend at least an hour or two every day for two weeks on LeetCode banging through as many algorithm problems as I could, timing myself to see if I could solve each one with optimized code in that 15 minute time limit.

There was also a system design interview focused on scaling out a backend system to support a billion users. I explained to the recruiter and the interviewer that this wasn't my forte, but I had a lot of experience with low level hardware interfaces and was really interested in a job in their hardware group. They don't hire for a specific role like that, though, they hire "generalist engineers", which means being able to come up with a fully optimized solution for any algorithm in 15 minutes - and without the ability to run and test your code.

In fact, they used an online code editor that normally lets you do just that, but this capability was disabled. I suppose they were trying to limit the online editor to match the capabilities of what you could do scribbling code on a whiteboard.

This all reminded me of what discouraged the OP's author so much about his initial foray into programming: the competitive coding competition with LOGO. That is fun for some people, but not for him and not for me. I would rather learn how to cooperate with other programmers, not compete with them.

One of the algorithm problems stuck in my mind. Of course it was a LeetCode problem that you can read about here:

https://leetcode.com/problems/valid-palindrome-ii/

"Given a non-empty string s, you may delete at most one character. Judge whether you can make it a palindrome."

In Python, there is a simple solution for this:

def is_palindrome_with_at_most_one_character_deleted( string ):
if string == string[::-1]:
return True
for i in range( len(string) ):
s = string[:i] + string[i+1:]
if s == s[::-1]:
return True
return False

If the string slice notation is unfamiliar, here are some references:

https://www.google.com/search?q=python+slice+notation

But of course this simple solution would not be good enough. What about the time complexity?

This LeetCode problem has 520,862 submissions at the moment, with 191,325 accepted. The solution above would not be accepted.

There is a faster solution, but it is less obvious and prone to off by one errors and other logic errors. It's not that complicated, but not something I would expect anyone to code correctly and verify in 15 minutes.

If that kind of competitive programming was what programming looked like to me, I could see myself being easily as discouraged as the OP was.

Fortunately there are other fish to catch in this grand ocean of programming!