What made programming finally click for you?

Having a goal. I started in my teenage years so it's been a while, but coding small programs that take a number, double it and print it out gets boring after a while.

Then my father asked me if I could write a simple app that talked through the serial port to control a project of his. Having a goal, and external motivators, is what turns something you learn into something you use.

Have a well defined goal, and unless you're one of those with great internal motivation, share the goal with someone else.

The first thing they taught me in programming in uni was: "Divide and conquer". It took me some time to truly understand what that meant in terms of programming. I remember that when starting a software project, I always started to feel very anxious if I was unable to picture the WHOLE program in my head; after some time I understood that by dividing it into smaller problems, and solving each one of them one at the time (without thinking at all in the other parts), things will eventually be connected and work, like magic. By truly adopting this basic paradigm you start to think naturally about interfaces to connect these smaller parts of your program, and from there things just flow.

I don't know if this is what made it click for me specifically, but here's an interesting realization I recently came to about mental models in programming.

Somewhere along the line I conceptualized functions as a mapping from their inputs to their outputs, much like in mathematics, and I would later come to learn this is what's known as referential transparency[1]. Eventually, during a foray into functional programming, I discovered Lambda Bubble Pop[2] and thought it was brilliant because it was exactly how I had been resolving function invocations inside my own head pretty much for forever, and poof, higher-order functions just made sense. I recently showed it to a developer colleague of mine, though, and he had a very different reaction. In discussing with him, I gathered "replacing a function with its output" was rather alien as a concept; this was not at all how he thought about functions. I'm still trying to figure out how he does conceptualize functions, but I gather they're more lists of instructions than they are term replacements.

[1]: https://en.wikipedia.org/wiki/Referential_transparency

[2]: https://chrisuehlinger.com/LambdaBubblePop/

Not sure what you mean. I was fascinated by the idea of telling a machine what to do before I got started. That's what got me started. I tried it out with the first programmable machine I could get my hands on, which turned out to be a calculator, everything since feels like a new and cool variation on the theme of telling a machine what to do. Data structures, OOP, functional programming, parallelization, web servers, they have the benefit of being fun to think about in their own right, but within programming, they're still just tools to solve specific problems (better). Initially I assumed that all problems had a solution like this, turns out there are some fundamental limits to that, but thinking about those is more math than programming (and a good reason to prioritize math and fundamental understanding over getting married too closely to any particular programming paradigm).

Perhaps the closest to an epiphany that I had was in an AI course, realizing that building machines that don't take instructions but rather examples of what to do is a full paradigm in its own right. But arguably that's separate from programming (and imho underscores why understanding the fundamentals is more important). When it comes to memorizing syntax, that's just a function of how long and how recently I've been using that particular tool, it builds up and also decays fairly quickly, that aspect doesn't feel fundamental at all.

I've been programming since my teens and professionally for 15-odd years. I think programming really only "clicked" in the last few years. Now I know with reasonable certainty how I will structure a project and how much time it will take.

What made it click? There wasn't a specific point, but I think it was when I started to seriously branch out into multiple languages. I've dabbled in other languages before, but when I seriously started working with other languages and made larger projects in them did I understand how to structre the code so it's not terrible.

I started learning Python when I was 12 years old by reading books. I could understand the mechanics but I couldn't solve a problem I hadn't seen solved before. I tried to make a game of hangman, but I simply couldn't design it. I gave up on it.

Several months later, perhaps a year, I sat down to try it again. For some reason it wasn't so hard this time. I was able to get it to work.

I don't remember what my other projects were, but I remember struggling to design some more software. I couldn't tell where to begin or how stuff should work. So I'd just jump in somewhere and start somehow. I'd flesh out one component, and then when I'd go to write a component that integrated with it, I found my first design was wrong. I ended up throwing out drafts and restarting.

Through a grueling repetition of this I learned to have a better intuition. I increased my capacity to hold a large and complex program in my head, and to reason about it. I remember a job interview at 18 years old, when someone told me, "you write decent Python." I was quite proud.

I don't think they're was a single moment where it clicked. It was a painful teething process of repeatedly painting myself into a corner, throwing everything out, and starting again. I was very lucky to have supportive adults in my life who helped me out, along with kind strangers on the internet who looked at my broken code.

I'll tell you about one small moment of realization. Once I was asking for help online with a problem relating to my masking an import with a local variable, or something like that. After this was explained to me, Ned Batchelder gave me a command; "now, realize that importing is just a special case of assignment."

It legit blew my mind. It felt like a zen master had imparted special wisdom to me. It was a magical pedagogical moment I've never experienced again. Thanks again, nedbat.

This would suggest that you're free to choose your application model and interface design. But usually you're not.

A big part of todays programming work is spent on understanding what others have come up with about how the environment your app runs in is modelled and how it talks to your app and expects your app to talk and behave. This includes data models, process models, event handling etc.

So while there might be a big click when you discover that you need a place to store your data and have algorithms/code operating on that data, in common programming tasks it has to click again an again about others' ways of doing things and adjusting your code to fit that model.

And yes that can be fun and enlighting. Again and again.

When I started learning programming – just when I was starting high school – it was a very mechanical practice. I read something in a book, tried it and the results would match most of the time. I could understand what the code was doing, but not how it did it. Until I learn assembly and memory models when I was researching rootkits – infosec was the most exciting thing for me at that time. Then it dawned on me that programming was about manipulating data in a specific way to get the result you want. That made everything easier, looking past syntax and tooling to seek only data flows and intent.

The first time I remember anything programming-related clicking into place for me was when I used some cPanel database GUI to look at the MySQL db my Wordpress or Drupal site was using. Just browsed the tables, and much about what's happening behind the scenes clicked into place for me. Also foreign keys and normal forms.

Two things.

One was Visual Basic. VB helped me go from writing fun abstract play things to amuse myself to actually writing something that solved a real world problem for people at a real world company. This taught me that focusing on boring, simple and 'ugly' programs that actually end up in front of people and save them time (and money) is far more valuable than writing really clever programs that don't, and that's what programming as a profession (as opposed to a hobby) is all about.

The second was learning Haskell. The way Haskell forced me to think about everything connected to programming completely changed how I saw things and helped my build up a mental model of the programming 'world' that really made sense to me and made solving programming problems much easier.

I think I personally enjoy the magic of languages, compilers and their tools. A lot of work and fields make us very dependent on programming. We can achieve almost everything we want through programming. I used to be a person using a programming language, but now I'm working on my own programming language https://github.com/KusionStack/KCLVM , design a programming language and implement it, which will eventually improve the efficiency of developers, stimulate the creativity of more programmers, and let them feel b, I am working hard to realize this beautiful vision.

Teaching others.

Specifically, I learned to program in elementary school (2nd generation programmer), but when I was in 6th grade my school system had its first programming class. Unfortunately, the teacher didn't know how to program so I taught everybody including him. (It was the 90s in a rural school system). Having to explain things to others made me a.) think about my own thought processes and b.) think about why I was taught/learning to do things the way I was. It made me aware of the meta aspect of programming: It isn't enough to know how to program: It's also necessary to be able to think about one's own process.

Learning some Java when C++ was dominating. It seemed so much easier for the beginner to get a working program and think more about the problem space in a purer way. Also the fact it came with a great standard library.

When I realized x = x + 1 was not a math equation but notionally was x <- (current x value) + 1.

I don’t think there was that one “aha!”-Moment, but I always found out when something seemed to hard, if I would revisit it after couple weeks it suddenly seemed so easy. I guess there is a lot of cross-knowledge you can apply from learning thing A to things B and C. So I guess the best advice is never stop learning, just ingest knowledge; the actual programming topic doesn’t really matter.

However a couple things stand out:

- learning to use a debugger

- test driven development

- static typing

- learning a systems language (stack, heap, memory management, pointers etc.)

When I came to the conclusion that programing languages are much like spoken language. There are constructs such as alphabets, symbols, morphograms, logograms, etc and rules on how to use/construct these things in order to express a given idea.

Nothing earth shattering but once I became familiar with umpteen languages and paradigms, it because a lot easier to express myself when working in a new language as it's just figuring out a new take on a familiar structure.

Getting started: flash

Actually clicking that I can build my own tools and everything I can imagine: processing ( https://processing.org/ ). Yet another language with a lot of visuals, but I actually started to do some simple data processing with it. Too bad the js copy's website seems down: https://p5js.org

It never clicked for me? It just always made sense.

Maybe I’m still meandering around in the pre-click phase though and don’t know. Maybe one day it will click for me!

I started programming 30+ years ago

Any time I hit something new, it only "clicked" when I had an application for the topic/concept

Take tree traversal

I wrote a working ~400 line linear octree traverser in high school in C++

Learned about recursion my second year in college, and rewrote that traversal code in about half a page

I had seen/heard of recursion before (even before I wrote the tree traversal code), but hadn't seen it applied to the type of problem I was working on

Once I saw an application of recursive tree traversal (on a binary tree, fwiw), using it in my other setting was a 100% no brainer :)

That's still true today - though I "program" notably less now (scripting, tool-specific languages, etc), all the whizbang features of whatever mean precisely nothing until I have a use case/application for them

For me, it was the realization that some languages have REPLs and can be used just like bash. Since I started with Linux sysadmin and worked my way into programming, I found a lot of the details of programming hard to understand, e.g. runtimes, compilation, dependencies. Most intro compsci classes I've seen tend to use C++ for some reason.

But, once I started using Python, and specifically the ipython interpreter, I realized that programming didn't always have to be statically typed and compiled and work with a Makefile. It could work like a bash prompt!

Eventually, I did branch out into Rust for compiled languages, but my REPL realization gave me the ability to experiment and "fail fast" in a more familiar environment.

I tried teaching myself programming for a few years, on and off.

But it wasn't until I took a statistics class, which involved programming in R, that I began to realize the purpose of functions: to handle inputs, and return outputs.

The class involved data engineering, so I created functions to deal specifically with data.

And it was then that I realized "Ohhh... functions in any language just operate on data... so... with this knowledge, now I see the purpose of application routes in web frameworks like ExpressJS, Python Flask, etc."

A course on relational databases helped me understand how to store data.

And from there, I finally realized the purpose of a REST API, and how browsers connect to servers.

At that point, I realized "Wow, I finally understand how to create a full stack app (including database design)"

LOGO - it was this kind of graphics generation language where a cursor moved on the screen based on commands you put in. This clicked right away. I was 5 years old IIRC.

Then, during my pre-teen years, I couldn’t understand how games had several moving objects all at the same time even though it was sequential execution. Then the update-render loop clicked in as I discovered it. Together with that, all kinds of event handling, interrupts, context switching etc.

Then, with WPF, databinding really clicked in with any sort of retained-mode rendering. So then Angular, React etc as well.

I'm not entirely sure when did programming really clicked for me, but there is this one time that still sticks in my memory to this day. There was this video which explained the concept of functions, and I clearly remember that eureka moment when he explained about the "return value" and I really just paused the video and looked into my source file and programming has never been the same ever since. Prior to this I was really just doing copy&paste trial&error.

I can think of some specific things that clicked over the years , but getting acclimated to programming in general was a gradual process, rather than a "click".

It's not programming per se, but what really made things "click" for me as a software engineer was to really be diligent about making sure I was very clear on the problem I was trying to solve, and making sure that I focused on actually solving that problem. That helped me get past not knowing where to start, not focusing my efforts properly, and building for the sake of building (unless that was the goal!).

Programming? Still clicking, time to time...

But the first time, I was typing some very simple BASIC code on C64 from the user guide and a question popped in my brain: is it possible to change a program when it's running?

I was already a kid like to tinkering with basic electronics and mechanics but after this significant moment they started to decline steadily day by day and I put most of my time and energy to the programming.

Software development, another story...

To add to this question: is there any language in particular that makes learning programming concepts any easier? I often see people mentioned Visual Basic but since that is no longer around, what would be the next closest thing? I suppose Python?

I use PowerShell for a lot of my scripting needs and have found it to be pretty intuitive, but am wondering what other languages I might enjoy solving problems in.

Learning machine code. It finally made sense how the entire machine sort of worked at all levels. No longer were things like Javascript magic.

For me it was about to 2 years to get to the level of “if I can imagine the algorithm I have no doubt I can implement it”, but that was gradual and there are many more levels such as being able to code to a standard style or idiom, I would hesitate to identify an aha moment, but if there were one it would be after doing 2 online algorithms courses from Princeton and Stanford.

My Aha moment came when I built my first toy application using a layer approach. The data access layer, the business logic layer, and the UI. That moment came when I realized how these things come together. This is such a powerful concept; to successfully build a complex application requires the ability to integrate simpler abstractions.

This particular Read of The Fine Manual taught me a lot

https://archive.org/download/bitsavers_borlandturVersion3.0R...

The title of the classic Niklaus Wirth book. "Algorithms + Data structures = Programs".

Rereading the Wirth's book 20 year later, I finally realize it. Every product I have been working on was a data structure indexed by a key, then processed to transform the data into other data.

Here’s what it made it click for me: .addEventListener(‘onclick’, () => {})

My master's degree is a 2 year period when I realised that regardless of the scale and complexity of a problem, if you have a systematic learning approach and resolve, you can overcome it.

Programming a game made it click early for me. I however think the barrier of entry is almost too low today blurring the line of what programming actually is.

The Camel ("Programming Perl" by Larry Wall).

I was looking forward to a thread like this, very motivating! Being a hacker without a CS degree sometimes creates steep learning curves.

Pair programming with better programmers than me.

For me, it was my first semester of university. I was infatuated with a woman who was a Computer Science student. I was an Electrical Engineering student. CS students had to take Pascal. Engineers had to take FORTRAN (with punch cards). In order to try to impress her, I had to learn Pascal while also trying to learn FORTRAN. She changed majors the next semester.

TL;DR - when I taught someone and did all her homework as well.

Who says it has clicked yet?