This is a perceptive observation.
And here are follow up questions which go deeper into it:
1. For which /kind/ of problem is one vs the other way better?
2. Which way benefits more from experience?
3. How does the tooling environment affect which way is more "interactive"?
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
yall don't do both?
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
With the LSP constantly checking the code you’re writing, it doesn’t feel like you’re not really trying it. So different when dealing with untyped languages though. If you don’t run constantly you can miss a terrible typo in your code that breaks prod.
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
The ideal way is very likely an amalgam of the two where your modeling tools are fluid enough that they allow you to quickly iterate your model and selectively run parts of the system in test scenarios.
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
No one can fix code in minutes what originally took hours to write, especially without any debugging in-between like step 1.
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
I’m the first, I love the rigorous method first, because I completely understand every minute detail, I’m weird I’ve always been like this
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
no.1 is my style of code.
then after full feature is achieved, i optimize and reimplement to avoid verbosity.
but with the advent of ai i’ve been more inclined towards no.2
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
i sometimes code for days without running/testing the code once
only after i’m fully done i run it, then i fix bugs and issues until it works properly
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
Type 1 : not confident in what you area doing, dont really know your codebase
Type 2 : I am the documentation, My mind is the runtime memory. all the variable pass through my brain upon change, and I have trouble of explaining it to others
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
I’m late to this party but let me say that you can have it both ways with OCaml since compile times are insanely fast and you can experience the joy of proper testing blog.janestreet.com/the-joy-…
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
I've been working on a new project for more than a year, but haven't run it even once yet. Should be trying it out within few weeks. Don't expect more than 2-3 bugs after first try. This is the power of #fsharp.
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
Kinda explains some work stuff atm.. Granted most of the team are quite junior, but hearing the words "yeah I've never really thought about design before starting code before" was a surprise 🙃
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
For years I have been using the first approach, and recently I am slowly moving to the second and can see more benefits
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
i agree with the approach we discussed. i’m generally more inclined towards iterating quickly, albeit scrappily, towards the end goal. kinda like sgd vs batch gradient descent
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
AI adds a third paradigm the equation, where you write tons of code really quickly with the AI and then you slowly iterate and clean it as you go. It’s not necessarily better but it’s the most effective way to use LLMs I think.
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
related
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
Testing?
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
Both please. Option 1 to work out what on earth you actually want the thing to do, then option 2 when you want other people to use it.
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
Interesting...
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.
Pros and cons of each? Which do you prefer — fast iteration or thorough upfront design?
Is one of these programming styles more effective in the long run?
I noticed two completely different ways of programming:
1. Write some small code, run, see the result, adjust, repeat for hours.
2. Sit for hours writing code, modelling with types, writing tests, then spend minutes fixing what you’ve got wrong.
Turns out, this deeply influences the technology, programming languages and frameworks you prefer.