What is your "Coder/Language Fit"

twitter logo github logo ・1 min read

In tech startup jargon you hear this convention a lot:

Product/Market Fit

Founder/Startup Fit

Product/Founder Fit

Etc.

It's basically the idea that a product isn't inherently going to succeed but if it's found the right market fit, things will go well. Or that no founder is inherently great, but with the right project, they can really succeed.

So what is your coder/language fit? The language that works for you because of how you are as a person—not necessarily because of its inherent greatness. No language is without flaw, nor is any language totally terrible. It's about the fit with the project, or in the case of this question—the person.

twitter logo DISCUSS (45)
markdown guide
 

Python and Ruby are my two favorites. Honorable mention to Bash because it's fun. :)

I've tried to learn more strict static, compiled languages (and I will keep trying, because I think it's an important skill to have), but I can't be nearly as productive or creative as I can in Python and Ruby. I love that you can just throw some code into a file and run it right away. I love that they're forgiving of little things.

I love that they don't have semicolons, and minimal code braces. #spacesbeforebraces #butalsoendkeywords

They don't have huge, giant, opaque, intimidating build toolchains, and they've got a robust standard library that cuts down on how frequently you have to install a dependency, which means that when you do install a dependency, it doesn't install the entire whole world of other people's dependencies.

It's funny that they're so different in their philosophies:

  • Python: There should be one way — and preferably only one way to do any given thing right.
  • Ruby: There are many good ways to do things (method aliasing, anyone?), and whichever way makes you happy is what you should do.

And both of those things resonate with me, but in different ways and situations.

If Python had blocks and the focus on method chaining that Ruby does:

numbers.filter(&:even?).map(&:to_s).join   # happy sigh

I would be very happy.

The only thing that I really feel myself missing is an easy way to deploy my code repeatably to someone else without having them go through a bunch of steps that make no sense because they don't do Python.

But no matter how often I go off to learn another language, I always find myself coming back to Python and Ruby. They're really the only languages that I've ever written something and then sat back and smiled because the code was so slick and pretty.

So anyways... I ❤️ Python and Ruby.

 

I love that you can just throw some code into a file and run it right away.

Some compiled languages can do that, for example Go and Nim.

I love that they're forgiving of little things.

This is a great example of where I think we deviate in terms of personality - the fact that the language forgives something that could be an error (or might become a problem at a later time) is what drives me crazy.

I dislike languages such as PHP, Ruby, Python and JavaScript because they're too forgiving.

I enjoy languages such as TypeScript, C#, Go and Nim because they knock you over the head when you're doing something that might not be safe.

What's annoying and restrictive to you, to me is a helpful, guiding language that teaches and drives me towards correctness.

I also love the fact that strict languages, in addition to the syntax and idioms, don't have a bunch of rules and what-ifs I have to memorize - when types can be automatically cast, all the rules about casting, and so on. I like the fact that a string is a string, a number is a number, and you can't write code that implicitly converts things without any visible artifacts of my decision-making.

Do you have a great memory?

I have no capacity for rote memorization, and I've always suspected that's one of the main characteristics that separate your kind from my kind.

I simply can't trust myself to remember on monday what I wrote on friday, and so, for me, it's crucial that everything is formally defined and decisions written down; not as a matter of discipline, but simply by letting the language guide me to it.

Working in languages like PHP or JavaScript is tiresome for me because of the discipline it requires to write good code.

I've tried to learn more strict static, compiled languages (and I will keep trying, because I think it's an important skill to have), but I can't be nearly as productive or creative as I can in Python and Ruby.

For me, it's almost the reverse - I can't be nearly as productive in languages like Python and Ruby.

As for being creative, I do enjoy messing around in PHP or JavaScript when I'm experimenting - just that most of my work is production, not experimentation or prototyping, and when it comes to preparing some JavaScript experiment for the real world, I immediately rewrite in TypeScript... and I'd be lost in my own code without it ;-)

 

I couldn't agree more with you. If you check my reply to the same article, I program in Ada and in Ada you suppose that the programmer is just a fallible human being, so the compiler must protect the programmer from self.

With a minimal of care (e.g., defining your own types instead of always relying on the standard ones, using enumeration types instead of constants, ...) the compiler can catch many bugs that in C, PHP, Javascript, ... would sleep for years before being triggered and blowing everything up.

I often say that programming in Ada is like doing pair programming, with the compiler playing the role of your partner.

 

I think you would love F# (or Haskell or any other functional programming language) for the strong type system the languages are built around. If you design your types correctly, a lot of errors will be caught at compile time. fsharpforfunandprofit.com has some really cool articles and uses of F#, but he does NOT know how to write for beginners. I had to learn functional programming by other means before his stuff clicked with me, but once it did I learned some mind-blowing things.

I'm actually not fond of purely functional programming languages. While they're great in theory, I find that the barrier of entry is too high for most people, and code in functional languages tends to be more nested and harder to understand.

It's not a skill that most people acquire easily - and while you could say that it's worth the investment (and you'd probably be right) there is a shortage of talented programmers to begin with, most of them do not know functional programming.

Besides, I don't think there's really a functional programming language that is popular enough that you could describe it as "mainstream"?

I do think that programmers should know some functional programming language concepts and have an understanding of the qualities, but, from my perspective, it's better to choose mainstream languages that also allow functional programming - so we can apply the concepts when it makes sense and adds value, but, the rest of the time, we can leverage the talents of the majority of the talent pool.

You bring up a lot of really good points. The learning curve is pretty insane, from me hearing about functional programming and trying to learn it for the first time until I felt moderately comfortable using it, 2 years had passed. Some of that is the lack of good resources or poor community support, but it is difficult.

Scala might be the most mainstream language that you can use for FP? And of course Javascript. F# still feels like a second-class citizen in the .NET world. Getting .NET to play well with F# can be a PITA. I get away with using it for scripts and that's about it. I get confused trying to scale out a large project - OK I can write a monad and implement some cool data transformation, but how d I write an entire program functionally? I don't see any tutorials offering that.

It has changed the way I write C# and JS in a positive way. I am about to start contributing to the F# foundation I think. Making it viable...one ticket at a time!

 

I mostly use JavaScript (because web sites) and, fortunately, I've found that it meshes well with me. It lets me have nice bits of both OOP (everything is an object!) and functional programming (love map/filter/reduce!). It's not perfect by any means, but it's been flexible enough to let me try all sorts of things out and find a flow that feels good. I'm sure that there are lots of other languages with nice features that I'd like to have, or would if I knew about them.

 

For me that language has always been Python but I'm not sure anymore. I found a good fit in it because of its simplicity, the creators efforts to avoid complexity while creating a language that can be used to solve complicated problems. It's my "go to" language.

The thing is though, I have changed as a human and as a programmer over the years and Python has mostly been the same language (I know, it looks like I'm talking about a romantic relationship gone sour).

I do not know where my "language fit" lies. Ruby is nice but I've always liked it less than Python. JavaScript to me it's just a means to an end (frontend web) and Go feels the same way as well (lean servers).

I might be an orphan after all.

 

I feel like there is sometimes a thirst on people's part for change for its own sake, and that's really not great when it comes to computer languages. I think the relative stability of the core syntax of python is not a bad thing. And I'm with you that it's the language I would pick for this discussion as well.

There are aspects of the language that I would definitely change if I could, but those tend to be things that don't really apply to the basic syntax. For example, I think the import/module/package system in python has continued to be confusing from day one, and it's not really much better today than it was in python 2. I think npm is far superior for example compared to the mess we have in python.

Another thing is the infamous global interpreter lock. It's not something that is always going to be a major problem, and there are of course workarounds. And some people will even argue that it has some benefits. However I do consider it to be fundamentally inelegant and kind of weird for a modern programming language.

Finally, some of the standard libraries are better than others. I've definitely encountered some modules where I was wondering if I'd somehow stumbled into Java. It surprised me that more effort had not been put into keeping to the philosophy of python in that regard.

The basic syntax is pretty darn great though. It's simple without being too simple. When it comes to understanding open source code, it's definitely the language where I've found it the least difficult to figure out what people are trying to do.

 

I feel like there is sometimes a thirst on people's part for change for its own sake, and that's really not great when it comes to computer languages. I think the relative stability of the core syntax of python is not a bad thing.

Yeah, mine is not a criticism to Python per se, I definitely value this thing. I'm just saying that I'm not sure it fits in my brain as easily as it did when I picked it up first.

For example, I think the import/module/package system in python has continued to be confusing from day one, and it's not really much better today than it was in python 2.

I partly agree. The package system has been messy but the import and module system is quite alright. BTW I believe Pipenv covers almost every need now

I think npm is far superior for example compared to the mess we have in python.

Maybe, but in reality npm suffers by the enourmous amount of small packages with large dependencies trees that transform node_modules in a mess. The tool is solid though. "Far superior" to me means that the other tool is barely ok, but I wouldn't call Pipenv barely ok. It works.
It took too long to get there and there are still kinks but I believe we're on the right path. Finally 😅

Another thing is the infamous global interpreter lock. It's not something that is always going to be a major problem, and there are of course workarounds. And some people will even argue that it has some benefits. However I do consider it to be fundamentally inelegant and kind of weird for a modern programming language.

I disagree. The GIL was a very smart move (Python was developed at the end of the 80s, not exactly a new language), it made the Python ecosystem of libraries and packages develop faster with the added bonus of creating (mostly) thread safe extensions. Many industries ate it up because they could use its simple syntax and extend with C wrappers. I think the GIL is one of the reasons why Python popularity grew over the years and it still relevant after 30 years.

Someone thought about removing it in Python 3 (they were already breaking compatibility) but they didn't because they still didn't think it was worth it: extensions would become harder to write and single threaded Python programs without the GIL would be slower.

Keep in mind that the GIL is a real limit only with CPU bound multithread programs that do calculations in Python. If you are I/O bound you're fine. If you're CPU bound but inside the C API you're fine.

This is one of the reasons the GIL is still, with its drawbacks, a smart move for Python.

ps. there are implementations of Python that do not have the GIL like Jython...

 

Maybe throw it all out of the window and go weird. Give Haskell or Clojure a shot, wear that hat for a while 🙃

 

I was at meeting yesterday and a Ruby dev I've known for years suggested I try Clojure as well :D

The universe has spoken!

I had a lot of fun with Clojure from 2009-2012 :-) Then I moved to SE Asia and the Clojure community here is small, bordering on non-existent. I still try to stay up to date though, it's a neat language and you'll have a ton of fun with it.

 

I find Go to mesh pretty well with my brain. I can't put my finger on it exactly and I haven't gotten around to use it in a large project, but something about Go just clicks with me. Maybe because it's inherently a simple language, there's not much syntax or keywords to learn before you get into all the concepts. Or maybe it's just the fact that I can finally have one variable named properly for each of its use cases.

 

Honestly modern object oriented PHP. Along long time ago, in a land far away I tried to learn C and had no idea about programming or anything. Nothing clicked and I got very frustrated with it and I decided programming was not for me.

Eventually I found PHP and figured out how to build things and to make web applications. Eventually I learned lower level concepts that C teaches you but learning PHP well first helped usher in a new Era in my life.

 

After 20 years I have grown to like and sometimes love php, despite really not wanting to!

 

Nim is that language for me. It has very flexible syntax that lets me write code the way I like. Some people hate conditional expressions, but to me, the statement work around is so much noisier and harder to read. Ditto for implicit returns. If a procedure is a single expression, I think an implicit return on that expression makes the procedure easier to read. It has FP and OOP functionality, but it isn't militant about either (pretty similar to JavaScript in that regard). Its approachable as a language, and none of its semantics have been particularly difficult to understand.

But what really makes Nim a language that fits me as a coder is its fit as a "hacking" language. My other language love is Clojure, which is a fantastic "software engineering" language. Its great for a large, shared, enterprise grade project. The JVM is rock solid, it has the libraries, and Clojure is fantastic on top of all of that. But if I want to sit down and hack, its just not my first choice. I don't want to be concerned with JVM classpaths, jars, Closure compiler (for JS target), AOT compilation, and all of that. I can open a .nim file, throw down some lines, and compile a static binary with no fuss. I've currently got a couple side projects in Nim, and I've only run into issues with the language a couple times.

 

I definitely go with, well, Go. I like that there are very simple patterns, enforced standards (via the included go fmt command), easy/intuitive testing designs (the _test.go pattern) - things like this, and others for sure, appeal to my strong inclination towards simplicity, structure, and doing things one way.

 

For many years my answer would have been Ruby.

Nowadays I really don't know though: I wrote/contributed to production code in C, Visual Basic, Perl, PHP, Ruby, Python, Clojure, Go, JS (and things that transpile to it), Java, SQL, MUMPS, Lua, Erlang, Swift, and probably some others I forgot. I spend most of my time with Go right now, because we do a lot of it at work and I like it well enough.

However, if I really had to pick one, my vote would go to Elixir, because it meshes a lot of the things I like about different languages into a pleasant and coherent whole that just makes sense to me. The honorable mentions go to Rust, since I'm quite interested in low-level/systems programming and SQL which oddly enough I've always enjoyed.

 

We're in almost exactly the same boat!

The honorable mentions go to Rust, since I'm quite interested in low-level/systems programming and SQL which oddly enough I've always enjoyed.

I can so relate to it, though I don't find much time to explore system programming. I have fond memories of Linux system programming in C and I keep dreaming of returning to it with Rust. Anyway . . .

I seem to have struck a chord with Crystal these days, so much so that I started supporting the project financially. 🤗

 

I seem to have struck a chord with Crystal these days, so much so that I started supporting the project financially.

We're really almost in the same boat then, I've been supporting Crystal on Bountysource for a while now. :-)

Super cool! I mean, I'm surprised because I never supported open source software before, especially something so new. Anyway, looking forward to the future. :-)

 

JavaScript/Python

Not what you initially though. I love using Python as a general purpose language. I use JavaScript in the browser, but I really love it server side.

You can do great things with a Node.js sever and a Python client!

 

I'm rather new, but may I know how would you go about building a Python client?

 
 

I really love working in Kotlin, but it seems like the stars never quite align to where I can use it as my primary language at work. It's usually my default for new backend stuff for personal projects now. I think my favorite thing is how modern it feels but you also get the power of the very mature Java ecosystem.

For more ad-hoc stuff I love python, I can cobble together something workable extremely quickly. Also, comprehensions are a wonderful quality of life feature.

 

I'm in the same boat. I use Kotlin almost exclusively for my side projects, both JVM and JS stuff, but my work projects are mainly still Java. Some projects are slowly adding a bit of Kotlin, but its just hard to start integrating new Kotlin while most of the app is plain Java. It's just so natural, when fixing a bug in Java code, to just keep writing new Java for it.

I think it's just a matter of time. Kotlin has really only been a "very mainstream" language for a year or so now. As more greenfield projects get started with it, it will get more acceptable to migrate existing projects to it as well.

 

I've been enjoying functional Javascript side for a while now and recently started learning Elm. While it's strongly opinionated and has very few syntax constructs, I really enjoy it. Can't say I am productive in it yet, but that's my 2019 goal.

 
 

I would say TypeScript as well. I'm fairly new to it, but I've been finding it to be incredibly useful. Self-documenting in a sense, great at helping me catching silly mistakes, and fairly flexible. I've had some friction with the syntax, but I'll chalk it up to unfamiliarity.

 

This is actually something I've thought about a lot recently when I talk to people about different languages, and for me it's Ruby. And as you said not because Ruby isn't without its flaws, or that Ruby is the right fit for every project. But I have found that Ruby fits really well into my personal mental model of programming. Most things in Ruby work how I expect them to work.

It's syntax is simple enough that it can almost look like pseudo code in simple cases and is easy to visualize, for me personally.

Another thing that makes Ruby fit well into my mental model is it's complete lack of typing, and emphasis on 'duck' typing, or having objects of different types that respond to the same methods, and acting on all of them using this shared interface. This fits well with how I imagine objects working in my head.

Ruby is the language I will probably pick if I just want to knock something out quickly and the language doesn't matter. But for new learning focused projects there are a few other languages like Elixir and Rust that I want to get more into!

 

C++ and Python are my all-time favorites.

C++ is one of my favorites because of the complete control it gives me. I adore memory management, so allocation, pointers, and the lack of a garbage collector make me very happy. I'd rather have all the control with the risk of undefined behavior, rather than no undefined behavior with limited control. Anyway, I love debugging undefined behavior. Besides that, C++ offers all the tools to work in every imaginable coding paradigm, or any combination thereof - procedural, object-oriented, generic, functional, you name it. I'm not limited to one possible solution: I can build practically anything well.

I love Python's unique syntax and underlying logic. Immutability is absolutely awesome! I appreciate the Zen of Python, and I'm drawn to the audacious beauty of the language itself. Python as a community and a language places great value on doing things well, which is one of my highest personal values.

I know many other languages, and that list continues to grow, but C++ and Python are my perennial favorites. Each release only strengthens that passion.

 

I've given several newer languages a shot (apart from what most people are familiar with, i.e., PHP, Python, Ruby, Java, JavaScript): Go, Rust, Elixir, Clojure, Racket, Scala, and so on. Granted I didn't dive deeper into them, but I found adjusting to them a mental struggle of sorts. These days I'm having a lot of fun exploring Crystal, which to me seems like Go done right. This might change, but I feel really calm and happy when exploring and coding (minor) things in Crystal, even though I have only a passing familiarity with Ruby. 😇😇😇

 

TypeScript: you get the syntax and expressiveness of JavaScript, coupled with the type safety of most OOP languages.

That, and also, the fact that TypeScript mostly looks at "shapes" of objects, rather than specific classes and interfaces, allowing us to write expressive code. Who cares where an object came from? As long as the object has the right shape, then we're good to go, something that C# lacks (although somewhat available with LINQ). C++ somewhat implements such an idea, but TypeScript is much easier to get started.

 

For me it’s not really about the language. Over the years I’ve been variously obsessed with Basic, Z80 assembly, Fortran, C, Perl, and now I tend to write everything in Python and use a lot of Raspberry Pis. Within broad limits you can write any application in any language (*), and you are going to produce the best result in the language you know best and are most comfortable with.

(*) I had a roommate who was trying to write a word processing program in Basic, so there are obviously anomalies by the score.

 

I'm gonna pick Python as it's adaptable and allows me to use it for almost everything I need.

Ultimately if I need something specialised for that specific usage I will always focus to get the important things done and out there regardless the tools used.

 

Ruby and Ada

Yes, they couldn't be more different: duck typing the former, very strong typing the latter.

Duck typing is not as robust as strong typing, but its flexibility makes it very easy to write some fast-and-dirty code. Typical use case: if I have some text file that I need to process to extract information or if I need to write some networking code for an extemporaneous need.

However, for larger and longer-lived software I prefer the order that Ada can enforce to your code.

Sure, you could do the same with C or Ruby by choosing some coding convention, but having the compiler enforcing it and checking it before you can run the code it is much better. How many times I had to run some code again and again in order to find a bug that would have been spotted at compile time by Ada.

 

I've found my happy place with Kotlin, JetBrains has really created a wonderful language that can be deployed to all platforms I love to work on, namely Android and the Linux command line, often with a codebase that's mostly identical.

 

This thread was inspired by this interaction

One thing I would like to emphasize in my to-be-created language is that there should, generally speaking, only be one correct way to do something. I think it would make the syntax more uniform and make things less difficult to document, etc.*

So I suppose at some point I'll have to decide between and vs. &&, not vs. ! vs. ~ and so on. Leaning toward the English-like options.


*One interesting effect this would have is that there would only be one kind of loop. No for vs. while, just some kind of loop feature.

Yeah, Ruby pretty much goes the other way completely with that. I try not to indulge it too much, but this mentality jives with my personality, probably helps create the right coder language fit.

 

I have a somewhat different view. I've shipped code in a lot of languages over the years, ranging from Forth to Haskell. At this point I judge a language by what I loathe in it. In Haskell, for example, monad transformers and error handling were the primary points of loathing back in 2008 or so (though I hear that there are some improvements on the former). Ruby has a lot to loathe. Go fits a particular niche really well, and as long as you don't try to use it for anything but that, it's great. C++...let's just move along. Python has the GIL, but remarkably little else to loathe, especially since they fixed Unicode support and added some type annotation capabilities in Python 3.

 

I'm going with the object oriented type and, I don't know, maybe java or c# or even nest.js which is the mvc type like c# and is based on express with typescript.

 

Haskell, because I love to write short, concise and elegant code and also am a mere mortal so having the compiler have your back is nice.

 

For me it's Go. Since I picked it up, I haven't been able stop.
All my projects are now almost exclusively written in Go.
Everything just makes sense.

Classic DEV Post from May 31

Presentation Tips for Technical Talks

Presentation Tips for Technical Talks

Ben Halpern profile image
A Canadian software developer who thinks he’s funny.