The subjective experience of coding in different programming languages (2023) | Hacker News Reader

The subjective experience of coding in different programming languages (2023)

interconnected.org

47 pointssolarwindy56 comments

https://web.archive.org/web/20250130131324/https://interconn...

> But the overall synesthesia? I have no idea. I assume that most people have some form of it? As unfounded as that is.

I don't get the physical reactions that the author describes, but when I'm in the zone, I literally stop seeing or being aware of the screen, keyboard, etc. and start "seeing" groups of geometric shapes that interact with each other in my mind.

The nature of that doesn't change according to the language I happen to be using, but the language choice can absolutely affect how easy it is to get in the zone. Some languages are better suited to certain kinds of tasks than others, and if I'm using one that isn't well-suited then entering the zone is simply impossible. Instead, I just feel like I'm fighting the language.

Yes, I start visualising the machinery too.

Similarly to reading a novel. At one point the text becomes background and I start seeing the scenes in my mind.

Oh, that's an excellent analogy. I think I'll steal that!

Which languages do you code in? Because for me the available mental structures I can use to think are radically different when I code in golang as compared to elixir, just because they have radically different paradigms for approaching data transformation.

I am competent or better in about 10 languages (a couple in each of the major programming paradigms), but in my current position I primarily use C, C++, and Python. I don't know golang or elixir.

I get synaesthesia in some languages (smalltalk, sclang, forth, lisp, occasionally perl) but not in any others. But I don't know if that has to do with the language or with the kind of projects I do in them, and I'd love to figure out a way to determine that. Maybe I should try writing a generic "not-in-domain" project in one of those and see.

I've dealt with C in college and nothing more, so for me It's just a bunch of macros on top of assembly. C++ was the language we used in OOP class, I know it's a beast of many faces, but we used it mostly like you'd approach using java. Python is very expressive but I think it's closer to C when compared to elixir because it lacks advanced pattern matching. I think the four main domains are procedural, object oriented, functional and visual (programming in excel for instance). Navigating those realms unlocks different ways of thinking and different mental structures. None is better than the other, they just lend themselves better to different classes of problems, and choosing the one that fits best your experience and the target domain will make it more likely to get in the zone when using these technologies.

Elixir is spectacular for visualizing, it’s all just changing the shape of your data all the way down, and all the standard modules have exactly the right tools for doing whatever step needs to come next. It’s so easy to find yourself zoned in. Go has the rhythm of error handling everything, it feels like you’re steadily plodding along with these mini checkpoints.

Yeah, if not for these checkpoints I think I'd have a much more fluid experience with golang, but I respect the fact they didn't choose to implicitly send errors through the callstack, I just never managed to find a good solution for making these callstacks clear.

Take this function I contributed not long ago to the project I work on: https://gitlab.com/nunet/device-management-service/-/blob/aa...

In it for each step in the procedure of saving the config file I need to check whether it's successful, otherwise send back the callstack. I often find it confusing to navigate back when I have an error and to maintain code that has many such steps.

Fascinating! Is the mental picture a side effect, or do you feel like it helps you reason about/manipulate the shape of the code?

It seems to be a side effect. It doesn't help me in any obvious way. However, when it's happening then I've also ceased to be conscious of writing code. It just flows of its own volition.

I mean, I know I'm writing code, but I'm not consciously seeing, analyzing, formulating, or typing in code.

Edited to add: On reflection, the geometric vision does actually help me sometimes. When there's something wrong with the code I've written (be it a syntax or logical error), then the shapes react in a way that I'll call "dissonant". I pay attention to that signal and more consciously analyze what I've just done, to find the error.

The reason I ask: there's a story about a physicist who was so kinaesthetic in his thinking that somebody walked into his office to find him rolling around on the floor, trying to embody rotations from the point of view of a particular system or something...

I can't say that my own subjective feelings while coding are so useful! But I like to imagine that they're a meaningful contributor to my "taste" of what good/bad looks like

(Wish I could track down the reference)

I certainly don't get as deep as that physicist, but I do think I understand. When I'm working out a difficult logical/data/programmatic problem, then I use my hands in a similar way. I'll form hand shapes that in my mind represent geometric shapes and physically use my hands to "arrange" them in various ways until something "clicks" in my head. That "click" isn't the win of finding a solution, but more like a feeling that I have now grasped the true essence of the problem.

Essence of the problem is the right word. If we go with F. Brooks’ words, it’s like all the accidental complexity fade away and all that’s left is the idealistic view of how things should work. Then all that left is making it happens with code

It helps in my case. Bash is all about text so you just see text being output and manipulated. Something like lisp is about lists and eval, so you mostly see those and equivalent expressions. With something like React, there’s this tree representation of state that is always on your mind.

It’s a more abstract representation than code. Not as fixed, but helps greatly with designing the next steps.

I do the same, but I don't recall if I ever do it at the editor. I do the "shapes" thing when thinking about code design problems. (And not because I'm thinking in XML.)

For me it's more about "feeling" badly written code, as if it stinks and is unpleasant to look at, and conversely enjoying nicely written one, and seeing its elegance and beauty.

Especially when I have to familiarize with code written by someone else, I usually start by "cleaning" it - small refactorings such as splitting overlong functions and simplifying expressions, that are trivial to prove as correct even without a deep knowledge of the code purpose.

Only when the code looks sufficiently clean and familiar, I start adding the requested new features

I also do this sort of restless refactoring. I find interacting with a new codebase is a kind of brain hack that (subjectively) helps me get up to speed faster.

This is also how I have traditionally looked at new codebases. I don't necessarily actually clean it up (I dislike changing someones style unless it is completely necessary) but I build up a mental model similar to what you're outlining. It's been really interesting with these LLM coding tools. I may not disagree with the implementation in terms of logic (it just does what I've prompted it to do after all) but something about it will 'stink'. Amusingly this feeling is the true 'vibe' of 'vibe coding' to me.

I sometimes wonder if this is the result of experience/education (I'm not a compsci major) or if it's just a naturally different way to think about systems.

(blog author here)

If you're interested in the multiplayer cursors + cursor chat, my philosophy is that every web page deserves to be a place, and pages should feel busy if lots of people are there

plus you can grab the code. here's the write-up:

https://interconnected.org/home/2024/09/05/cursor-party

This is such a cool effect but I'm afraid its novelty is conflicting with its affordances.

Have you seen cases where people are using it in a more familiar manner? Like, they've moved on from the newness but there's still a bunch of people? Feels like being in a subway station where everyone is bumping into each other right now instead of just sharing the space as needed.

yeah this is definitely over the edge -- signal is lost in the noise

my main enjoyment has been to hang out on my own blog (which it generally pretty quiet) and say hi to people as they drop by. I've had a few pleasant interactions that way, and a couple people said hi in Unoffice Hours (link in the left column) or on the socials after

but generally I feel like "ambient togetherness" is just the beginning of something, and it needs to be paired with something more persistent to be useful (like a discord only open to subscribers, that kind of thing), and I haven't gotten around to building that side of it yet.

I think that’s a very cool philosophy but unfortunately it makes your website unusable for me on mobile. It feels like ants are crawling all over my screen.

It's very cool, but the motion is also incredibly distracting while reading. It literally makes it physically difficult to read.

Might I suggest quickly fading the cursors out entirely as soon as the user starts to scroll, maybe? Then you could have the effect at the start, but be less distracting while reading.

Or just a floating counter in the corner to say how many people are currently viewing it, maybe with the two most popular flags and your own flag and a fourth "other". Because it's one thing to know it's busy (cool, it's popular, I'm participating in something!), but it's another thing to feel busy, distracted, claustrophobic.

I assume you want to prioritize people reading your actual content over the feeling of busyness.

there's a Quiet Mode toggle in the corner of the screen for that purpose

Thanks. Honestly, given all of the random comments in bubbles and other UX I never even saw it. I realize it's obvious once you've seen it, but everything else was so distracting I genuinely didn't. And I was literally trying to just "tune everything out" and read, not assuming there was an option to disable it that I should look for.

Also, "quiet mode" doesn't suggest any clear link to the cursors. I get what you're saying with it, but I'm more likely to assume it's got something to do with the site playing sound effects I don't hear because I've got my device on silent mode.

First time I saw this, I didn't realize these were other people cursors, I really though the point was to be an annoyance (some people actually do this!). I thought the movement was random, and that it was a way to make it harder for people to see their actual cursor.

The country flags make it much more clear. Still an annoyance, but now I get it, and I am more than amused than annoyed now.

Anyways, it doesn't work for me on Firefox 128.11.0esr, Debian 11 (yes, outdated, I know, but still in LTS), I had to use Chrome/ium for the cursors to show.

I absolutely love it

I'd have to think more about the synesthetic experience, but I'll never forget that my fingers hurt when I wrote Objective-C. I could never locate what the source was; I could have been pressing harder on the keyboard, or I could have been holding tension in my hands. But the language quite literally felt different in a very real, physical way.

edit: it could also have just been me typing with more frustration due to XCode :p

Great observation. Definitely something about those square brackets which puts my right hand in tension

I loved working in XCode at the time, it just "felt" better, it made obj-c "feel" good even though it's a very old language; the navigation, the colour scheme (I think I used the midnight theme), using gestures to do a swipe history back, the integrated tools, side-by-side views, etc, nothing like it.

I tried it again last year or so though, trying out the newer tools like SwiftUI and its live preview, and didn't enjoy it; the stability and performance was just all over the place.

I am curious about people's experiences who are really good and use the following languages regularly: C, OCaml / Haskell (although Haskell feels way different to me), Common Lisp (or any Lisp), Erlang / Elixir, and Forth / Factor. To me, these languages seem to be significantly different.

Edit (before I will not be able to do so): thank you for everyone's replies (in advance, too)!

I use Clojure a lot at home and Typescript at work. The experience is dramatically different. Clojure makes me feel free. It feels easy to experiment and the whole world feels open to me.

Typescript on the other hand feels like being confined to a small room. There's not much flexibility. Not much is open to me. It's very regimented and I can sense better solutions, but they're off limits to me either because of the required type gymnastics or the language primitives.

I'm not sure if I would consider myself 'really good', but in a previous life I have used Haskell professionally, albeit only for small-scale applications (alongside a Scala codebase).

For what it's worth, I actually really enjoyed using Haskell. It did force me to think differently about problems and I feel that this has carried over to writing cleaner code in non-functional languages like Go/Java. I liked it so much so that I wrote a book about writing functional code in Go along with a supporting OSS library.

Would I recommend it for really large-scale applications? Maybe not, because you'd want a mature ecosystem with a lot of support, and the secondary issue is that you want to have a large candidate pool when hiring people.

Small disclaimer though, the last time I used Haskell professionally was in 2018-2019, so it's not 'recent' experience.

I've been working with functional programming languages for the most part of my career now. Mostly Elixir and Clojure, but some OCaml/Haskell too. I believe after FP "clicks", there is no going back. Everything else feels just so unnecessarily complex.

My favorite is still Clojure by miles ahead, besides it being a functional language, its data-oriented approach to writing programs is completely different from anything else I've ever seen. I currently work with Elixir, and there isn't a day that goes by without me thinking "gosh, this would be so much simpler to solve in Clojure".

> gosh, this would be so much simpler to solve in Clojure

My colleagues are so sick of hearing this.

How come? Genuinely curious.

I feel the same way with Go, OCaml, Factor, Erlang / Elixir, Common Lisp, and even Perl, depending on what I am doing. Heck, I still have new projects written in C due to its simplicity, which is what I want sometimes, and more control.

I end up working with a lot of data transform pipelines, and Clojure's strong support for names (with namespaced keywords) and generic data structure manipulation makes the code you have to write more succinct.

This kind of task is also extremely well suited to a repl. You define a temporary var, and start threading it through a series of super small functions that only slightly change the data until you get what you want.

    (->> my-data 
         parse
         (filter some-pred)
         (map my-mapper)) ;; and so on, if you need more

For me, the big thing is REPL driven development, and immutable data structures. Everything can be inspected. It's easy to get insight into basically any small piece of the program as if you were using a debugger (but you don't have to).

For others that found the website design made it difficult to read the post: there's a "quiet mode" button at the top right.

(blog post author here) I added Quiet Mode because of the feedback last time one of my posts hit HN, it was chaos haha

(btw you can hit / to enter cursor chat, it's fun if a bit distracting)

Thank you for this! The website is insanely distracting, but at the same time kinda fun. Reminds me a bit of the chaos of the early 2000's internet I was used to :)

I seem to recall reading an interview with William Gibson in which he said "someday we might have little squishy things that can read any form of physical media you wrap them around". That's what working in Lisp feels like to me. It's something squishy, and you can wrap it around any sort of problem and solve it fairly quickly. Smooth it out enough and it might even be an efficient or elegant solution. I've compared Emacs to a beanbag chair because it too is squishy, comfortable, and once in it it's difficult to leave, nor do you particularly want to.

Languages with nice type systems, like Standard ML or Ada, have the feel of Buckminster Fuller's tensegrity constructs: rigid yet flexible.

I fully agree with everything mentioned.

I think this synesthesia idea bumps into the concepts of comfort and understanding. In that I feel it also extends to the environment im in and the tools im using. Like if I switch to a different type of keyboard or the monitors are positioned weirdly; or especially if im not using a certain IDE or developing without a language server.

Being immersed in software development, and the different ways we do it, can be a visceral and emotional experience.

> It’s a relief to close the braces.

I always type the closing bracket right after opening one then go back one character to start typing inside. Same with parentheses and quotes. It's a hassle when the IDE does it for me because then I have to delete one of them.

you will submit to the will of the IDE...

I don't like not really knowing a language

I can barely do Swift for ex. where I come from JS/PHP/Python but I was able to get by working on an iPhone/watch app

Not vibe-coding either, just watching YouTube/reading tutorials

For some reason Java always makes me feel ill. C# is okay though, weirdly.

I had the identical reactions, and like you it doesn't make a lot of sense.

Java: "stiff", awkward, verbose. Gets the job done but ugh.

C#: "soft", flexible, has possibilities

Although to be fair I programming in Java a long time ago, and haven't done much with C#. C# I see as a "corporate Python", vs Java I see as a language designed by committee and not for use by humans.

I've heard Java is way, way better now.

Java gives me similar feelings to what people say about Go: it may be a little verbose, but you always know exactly what to write and how to write it, and looking at other people's code you get a very good sense of what it does because it follows very familiar patterns.

The "brotha, eugh!" feeling comes from the enterprise frameworks, which tangle all that up in a mess of factories, DI autowiring, and inversion of control. COBOL may have been a lot to type, but its execution model was straightforward, like a BASIC program. Java EE's execution model is NOT straightforward. And it's no wonder why so many attempts to "modernize" old COBOL code using Java EE fail.

In my case it helps that I've been poking at Java since the very beginning, having discovered a bug in the 1.0.1 runtime, and compared to contemporary C++, it was a delight except for the performance problems.

C# doesn't feel too different from Java to me, aside from being more "Microsofty".

"Proper" generics, value types, LINQ, operator overloading, excellent native interop etc make a big enough difference to me atleast to prefer c# over java. Is being "Microsofty" a bad thing and "Oracly" or "Googly" a good thing?

It's more of a "I recognize coding styles and conventions associated with this company" than a judgement of good or bad.

Java made me think in pure object-oriented, GoF Design Patterns systems; tight types, defensive programming, detailed documentation, the works.

But then I got bored with it. I like meticulousness sometimes, but it started to feel like Java was just excessive and impractical.

C# is an evolution of Java, and unlike Java didn't have a 8-year pause or however long it was before they finally started moving again (the period between Java 6 and 7 I think).

That is odd, cursory looks at C# sure the hell looks like Java, certainly largely a blatant rip-off. Methinks you have feeling for Microsoft.

i feel like when i copy something to the clipboard, its in my (little) finger, near the left ctrl key. it kinda tense till i can paste it and don't have to remember what's there anymore

I get the same feelings when I edit code in different languages.

study_n += 1

Reply on news.ycombinator.com