How many programming languages do you know?

ben profile image Ben Halpern ・1 min read

Feel free to elaborate on your criteria for what "know" means... 😁


Editor guide

If my search history is any indication, zero.


I'm still chuckling to myself about this. Wish we could give unicorns for comments.


I am this close to hack NASA with my html skills


you might need to know more than html to do that. lol!


This plus some CSS skills would be quite enough.

HTML+css is turing complete!

I am not, I don't think you can prove it w/0 JS. lol!

Not personally, but this is cool, fuller write-up here.

I think we work on different planes ...

Thx for your CSS links tho!

PowerPoint is also Turing complete

PowerPoint is just a tool! Wrong channel! :)

Doesn't change the fact that it's Turing complete (also a little hint: the html+css dudes are joking, except for the Turing completeness, that's real)

dude, you would not know Turing complete if it hit you on the head ;)

this thread is now Turing complete! lol! Cheers!


It's amazing what you can do if you remember that "hack" in this day and age also means social engineering.

HTML/CSS is enough to cause some nasty problems if you hook the right people.

Also, don't forget Powerpoint is Turing Complete (youtube.com/watch?v=uNjxe8ShM-8). If you really want to spread lies and/or disrupt the ongoings of a business, that'll do it right there.


Common guys! Its pun intended, some of ya all needs to Google for their sense of humor, you might find it lying around in stakoverflow or GitHub 🀣

I thought I kept it that way, with some sprinkles on top ...


XML might do the trick


Html and css?? for nasa? i use html e css for haking the all world


Throughout the years I've used...

Turbo Pascal
8086 assembler
SPARC assembler
Scheme (LISP dialect from MIT)
Visual BASIC

I could be missing a few.

Of these, I regularly use only C#, Javascript, PHP and Transact-SQL, so at the moment I'd say they're the only ones I "know", as I've forgotten a lot of the others and going back would almost be like learning them again.


What is your favorite?


Hmmm... Overall, probably C# these days though I have fond memories of Turbo Pascal and 8086 assembler. I never did anything that really worked in assembler, but I had a lot of fun playing with it. I learned a lot about the 8086 (a simple processor by today's standards) just by learning the language, and that helped when dealing with low-level stuff in other languages.

Lately I'm mostly dealing with JavaScript (front-end; the back-end is in C# but I haven't touched it in a few weeks) and it's driving me completely crazy. I'm having a lot of fun. :D

Your list looks a lot like my history too.

You should look at F#

It's been on my list for years, but I never really got to it. :(


We're nearly career twins!


Definitely depends heavily on the definition of "know", and I guess also "programming language"

Have written something meaningful in? Over 30 different "families" of languages, where I'd say e.g. BASIC includes C-64 BASIC, QBASIC, GW-BASIC, and so on, C++ includes various Borland C++ and such things all the way to C++20.

Write actively and could write something new in without needing to refresh my memory first? More like .. 5? Incl. like BASH and PowerShell.

Mostly these days I write things in Python and Go, but I can unfortunately remember most of JavaScript as well. In the past the list is long and some are very specific things like Quake C and ZZT-OOP that are hard to even remember were a thing.

I try to make a point about learning new languages constantly, since most of the new things are pretty cool and have great new use-cases. Some of the things I plan to learn more about in the future:

  • Zig has a lot of promise to kill off C finally
  • Kotlin might get Java developers to finally migrate, and might provide us a new cool way to make one codebase for both frontend and backend
  • Rust has exciting new thoughts on reliability, but the syntax is pretty hostile to get into - hopefully they'll work on that in the future
  • Nim has a lot of promise to also give us ability for compiling to multiple targets and to build e.g. low level software in much more convenient languages
  • Elm is delivering on a great promise to make frontend programming pleasant again, and the community has a lot of interesting great takes on e.g. animation, web application styling, etc.

For some reason I cannot reply to your comment about JavaScript so I'm replying here.

Since you don't like JavaScript that much and interested in Elm I just want to let you know about Mint - the language I created to solve the issues of programming for the frontend. I wrote a series of posts here so you can check those out if you are interested :)


Thanks, I'm definitely interested in all alternatives. Actually now that I think about it a bit more Flutter is one of the more promising developments, as you can write an app once and deploy to multiple targets, one of the (currently alpha) targets being web, and you get massive speed benefits on mobile over doing it the other way and deploying web apps on mobile.

I am aware of Flutter and it's intriguing, however I am always sceptical about software that offers compiling the same code to the web and mobile, it is extremely hard to make things look and behave exactly the same on mobile and web without breaking the web.


IDK, it feels unfortunate that I remember JavaScript πŸ˜‚πŸ˜‚πŸ˜‚

#touch @lietux
#zap greating
#give health 5


Whoa. Instantly transported to middle school.


Almost every language!

I think if you know in deep at least 1 programming language then you already know how others will (or probably) behave/work. Of course there are exceptions, because older languages have different workflows or elements. But that's the fun part: go test yourself!

Now referring to programming languages I really feel comfortable with and knowing exactly how they work... I'd say 3 and a half!


I agree with you in general that understanding a single language at a very deep level will let you easily pick up many, many others, but I don't think one is enough to cover everything, because I think there are a few different fundamental threads in programming languages that different enough that being deeply familiar with one will not prepare you for the others.

I'd probably argue that there are three major threads:

  • imperative languages β€” Languages in which the main thing you do is write down a list of steps for the computer to follow in order. This is probably the 75% case. This covers everything from low-level C or Go, to Object Oriented languages like Ruby or Java, to more scripty languages like Python, Perl, or JavaScript.

  • functional languages β€” Languages in which the main thing you do is define how to solve very small problems independent of the main task of the program, then wire these smaller problems together to solve bigger problems. It is certainly true that many of the imperative languages above have functional aspects to them and can be used in a functional style, especially flexible, interpreted languages like Ruby, Python, and JavaScript. However, in my experience there's a big difference when you step into a purely functional language like Lisp or Haskell, and writing imperative code in a more functional style won't fully prepare you.

  • declarative languages β€” Languages in which you don't really give the computer a list of instructions, but instead you describe the problem for the computer to solve, or sometimes the outcome you desire, and let the machine fill in the blanks. This is a rare breed of language and is often found as an ability of languages that otherwise fall under one of the two above categories, though explicitly declaritive languages do exist. My main exposure to this paradigm is through Prolog, a Turing-complete logic-based language in which you feed the system a set of facts and relationships then ask it questions. Constraint programming, in which you hand the system a set of rules or conditions that must be followed in solving a problem then let the system work out a satisfactory solution, would fall under this label as well, and Oz seems to be a popular language choice, though I haven't used it.

Of course, as I alluded to above, many (most?) languages fall at least somewhat into more than one of these categories, and they are probably better thought of as "paradigms" or "approaches" of programming rather than "types of language". What I'm really trying to get at is that I think it's super valuable to pick a language or two from each of these different categories or paradigms and spend some free time digging in deeply and really wrapping your head around each of these very different perspectives.

I took a course during college called "Programming Languages" in which we had three big programming projects: one in Java, one in Racket (a flavor of Lisp), and one in Prolog. This was, in my opinion, one of the most valuable courses I ever took, and probably one of the most valuable coding-related experiences I've ever had, because it forced me to really lean into these three different perspectives and actually use them enough to make something substantial. It showed me how much variety there can be in how we talk to computers.

I highly recommend this as a personal project for anyone who wants to broaden their mind. First, go through a tutorial for some flavor of Lisp (Racket is a nice introductory one, though everyone has their fav) and write something non-trivial, like a Tic-Tac-Toe player or something. Next, go through a tutorial for Prolog and write something else non-trivial, like a simple chatbot based on Markov chains or something. It's a wild ride.


I totally agree with your point, thank you for your response, but only if we speak for those who actually have many directions in their professional profile.

For example in my experience I wouldn't need to know more than 1 language to master the languages that are connected to my area, however, I usually explore many other languages that are not necessary for my work just for fun. If I wouldn't that wouldn't affect my job or my performance. I mean, I know people earning a lot of money only knowing and working in PHP (haha).

So as we always say, it depends on what you're working on, where you'd like to be working or what you have fun developing.

Oh yeah, absolutely! Sorry, should have been more clear on that point: for practical purposes, if you learn Java to a super deep level, you should be well equipped to pick up Ruby, Python, JavaScript, C#, or any number of similar languages.

My main point was really that learning these other paradigms is good for expanding your problem-solving perspective. Especially functional programming: since dipping my toe into Lisp, the way I think about problems in JavaScript and the other mostly-imperative languages I actually use has changed a lot.

Totally agree!

For me, learning JavaScript and C# made Python almost a piece of cake, more than learning it from scratch with a weak knowledge of any other language.

I always encourage everyone to explore even if it's not connected to what they're doing, who knows where we'll be in 5 years!


Especially languages of the same paradigm!


Well, in short because JS is one of the more awful experiences you will ever have with programming in the modern world.

Nowadays you can't do anything remotely serious with it without a massive toolchain that makes setup really difficult, near impossible to figure out what goes on at every step, and challenging to debug things. Want to just write a quick little thing in JavaScript? You'll have to go to stack overflow to copy & paste a bunch of helper stuff into your code before you can even write the most basic "pick a random number between X and Y" into your app.

The NPM ecosystem is pretty terrible for many reasons, mainly poor design of NPM, and the fact that JavaScript having almost no useful standard functions at all means there's a library for everything - installing a few basic dependencies for your project will end up with you downloading hundreds of libraries, many littered with bad decisions, security implications, and gotchas. Then someone decides to just push a new version to GitHub but reuses an old tag and suddenly your builds break for no apparent reason.

There is no clear standard for formatting code, there are gotchas with the popular choice of not using semicolons, and there's roughly 16 different variants of the language - the JavaScript that actually runs on your browser (but just which parts depends on the browser hue hue), ES6, ES6 + flow, and so on. There is constant infighting about whose tool of choice is the best, and they keep evolving but there's no good documentation about anything, so you end up having to waste a ton of time guessing.

The community is full of people who think all of these issues are good, and like the new features with incomprehensible syntax, like apparently functions weren't clear enough when they were function(arg, arg2) { return "something"; }, but now need a shorthand syntax that looks like the nightmarish things from CoffeeScript, yet nobody is interested in trying to fix the serious and deep issues with the language. For some incomprehensible reason people like writing short code, like arg = ~~arg instead of clear code.

One such issues that is constantly causing pains to everyone working with anything where JS is related is that there is really no validation of arguments. People get lazy with using named arguments and doing checks, so they pass option objects, but these objects are never validated against any schema, so you end up e.g. writing configuration like {plugin: ["foo"]} and can't figure out why the foo plugin isn't loaded. No errors anywhere, it just doesn't work. Turns out you were supposed to use the key plugins, and you just wasted a day on one character.

The whole object and prototype system is like a massive hack and feels like an afterthought, which causes significant memory leaks and other issues all the time - think you can bind a reference to this.processClick on some event handler? No - this is another reason to end up with tons of pointless boilerplate in your applications to copy & paste a bunch of this.processClick = this.processClick.bind(this) in the constructor.

Then there are a lot of the just plain language design issues, like Number, clearly wrong choices for truthiness, lack of errors where clear errors in code occurred, poor error handling in general especially in the new async handlers, and so on.

There's probably quite a lot of other things that I quickly bump into every time trying to work with JavaScript, and these are just the ones I can quickly remember off the top of my head.

Really the best way to write JavaScript is to not write JavaScript and adopt another toolchain instead. TypeScript is ok, but ends up with most of the same convoluted toolchain anyway, and you end up with having to deal with npm and typings which are really poorly available. Elm and other such languages with their own ecosystem and tools that just compile into JavaScript are the biggest hope I have for the frontend world.

+1 for the really honest rant - sounds like WASM support in other language ecosystems can't come quick enough :)

It would be pretty amazing if in the near future WASM became a fully viable option, with full access to DOM and all the browser APIs, where you could load WASM code onto a browser as easily as JS code.

So many great languages compile to WASM now that it'd basically revolutionize the whole frontend experience, both for developers and users. This actually makes me ponder if Electron was nicer if you'd build WASM apps for it πŸ€”

Until then, these languages compiling into JavaScript are a glimmer of hope, Flutter maybe one of the bigger ones due to getting pretty significant performance benefits on mobile devices.

Also check out Bolero. It is F# MVU on web assembly. I haven't used it per se, but we are developing a product using its constituent elements (F# and Elmish, but built with JS toolchain similar to how we did Elm). I also have an Elm project in production a couple of years for comparison. For both technical and non-technical reasons, I prefer F# Elmish over Elm.


Interesting one :) Here is my list

Language Confidence
PHP * * * * *
Javascript * * *
Pug * * *
SQL * * *
Python * *
SASS * *
Typescript * *
C# / ASP.net *
VB.net *
Java *
C *
C++ *

You should definitely learn some more Java! It looks a lot like PHP too


Nice suggestion, I was thinking of which language should I spend more time on between C# and Java. Maybe I will try Java again one of these days... :)


Let's see ... including those I could do more than just write "Hello, World" in ...

  • Assembly Language (6502) learned this on the Commodore 64.
  • Active Server Pages web dev in the early days
  • Bash coz Linux
  • BASIC first language (TI-99/4A)
  • Boo from my intro to MVC
  • C when I got tired of assembly
  • C++ my introduction to objects
  • C# one of two languages I've used since it was created
  • COBOL early business developer days
  • Fortran forced to use this in college (maybe why I dropped out?)
  • Go learned recently, mostly for its WebAssembly support
  • IBM RPG/RPG ILE from my AS/400 programming days (now iSeries)
  • J# tried this out to transition to C#
  • J++ sadly fell for this in the early days of Microsoft
  • Java language used in the startup days of a company I worked at in late 00s
  • JavaScript second language I've used continuously since it was invented
  • JScript coz I liked it better than VBScript
  • LINQ for biz data queries and aggregations
  • Lisp because sets are fun
  • Objective-C back in the early mobile device management days
  • Pascal language I learned in high school
  • Perl get stuff done on Unix machines
  • PHP webmaster days
  • PowerShell admin all the things
  • QuakeC one of my favorite languages - I was quite active in the Quake scene
  • QBasic to get it done faster
  • Rust one I've learned most recently and am quite enjoying
  • SQL/T-SQL coz apps need data, too ... wrote my first SQL in 1994 (25 years ago!)
  • TypeScript making JavaScript scalable since the beta
  • VisualBasic COM objects for the world!
  • XPath/XSLT because XML was going to rule the world

Wow, thanks for that excuse to trip down memory lane! I am familiar with/have written code in probably a half dozen more, but that's more hobby. The languages I listed I either have been paid to write or could have if I was working age when I learned them.


I'm strongest in C#, PowerShell and JavaScript.

I have a workable skillset in Python and SQL (if you want to consider SQL a language). But I definitely need to Google a lot more.

I used to work in PHP a lot, back in the 4.x/5.x days. So I would consider that knowledge pretty much lost at this point.

We'll call it 3.75 programming languages


How do you decide whether you know a language? Is it just knowing the syntax, or actively using it, or even being able to use it when called for? πŸ€”


You feel comfortable writing in it and you able to write idiomatic code

idiomatic* means that the code you wrote is seen as correct way of doing it or more like the "appreciate & preferred" way of writing the code by the overall community of that language.


I like this definition


Those that I actively use these days: JavaScript, TypeScript, HTML, CSS, Python, MySQL.

Have used before/took classes on it but don’t use them very often anymore (various degrees of confidence, some I could start working with again fairly quickly, others that I only used a couple of times five years ago I’d need a bit more time catching up with): PHP, ActionScript, C, C++, Objective C, Swift, C#, Matlab.


I lost count and I kind of don't care πŸ˜„ Probably less than many here, but most than average I guess.

I discovered that knowing a language is important... up to a certain point. What really matters is how you use it - in relation if what it can do, if course.

Getting to know a language (meaning the syntax) is a matter of a couple of months tops. But knowing the best practices and its ecosystem is something that takes years...


I'll use "know" as in "met" :3

So, I've met:

turbo pascal, vb6, vb, c++, java, python, xml, xaml, python, javascript, sql, matlab, hmtl, css, c#, php, scheme, prolog and I think that's it? it's what I remember hahaha

I had to use most of them in classes, nowadays I use mostly use c# :D


I consider any programming language that I can navigate as well as I can French (which isn't great) to be a language I know... Therefore I'd say about three. But some days I would have to google how to print for a hello world so perhaps it's none, as would be my mastery of french as well. lol


I have started programming 3 years ago, and I proud that I know more than a dozen of languages now.

It is not hard to learn after learning a language deeply as first (as desire said). I first started with java, then js. At present I'm confident more with js and lua, but also good at java and python.

Here is the list of other languages I know:

  • C#
  • Ruby
  • Kotlin
  • Swift
  • C/C++
  • Pascal
  • PHP

In no particular order, the programming languages of projects I worked on:

  • Ruby
  • Python
  • C
  • C++
  • C#
  • Java
  • Javascript (ECMAScript, NodeJS and all that jazz)
  • Typescript
  • Transact-SQL
  • PHP
  • CSS / HTML (I count both as one)
  • Latex (Might as well count it if we count HTML and CSS)

I could list a bunch more that I have toyed with, but for me, knowing a programming language means that you can program in it with minimal Googl'ing


Java,C#, and JavaScript and by knowing I mean I actually develop stuff in this. And lately Cypher if that is a language hehe.

Rest is basically playing with and could swich to them if I want to but I don't 😁



I tend to give an answer to this question that is long-winded and frustrating to people. First, once you reach a level of proficiency with programming where you understand the big pieces that you'll see in any particular language (loops, conditionals, value vs reference, comparison, common design patterns) it's not very difficult to pick up the syntax to apply those concepts in a new language, so in that sense, I don't find this question all that useful. "Do you know $LANGUAGE?" "No, but I can probably be reasonably productive in it within a couple weeks."

But! Do I think that this means I "know" all the languages? Not. At. All. For me, knowing a language in programming is more about knowing what is idiomatic and which design patterns apply most commonly. So, in that sense, I think I really, truly know maybe 3-5 languages starting with Ruby, Javascript, and Objective-C but then I would include in a second tier of lower fluency Typescript, Go, and Swift.

I also think it's a mistake to think that because you know the syntax or even the idioms of a language means you'll be able to be productive in it without learning some ropes. I have been writing Javascript professionally for about 8 years but the last few months have been my first time working in Node.JS projects, and adding that to the mix has presented a whole different set of challenges. Conversely, someone with a lot of Node expertise would probably struggle to work productively in the architecture required for browser extensions at the beginning.

What I would advise people looking to expand their knowledge of different programming languages is to learn about different paradigms of programming and the advantages and disadvantages, analyze the tradeoffs. Prototype-based languages like Javascript and Lua have different strengths from languages that emphasize functional programming paradigms like Clojure and Haskell. And dynamically typed languages like Ruby and Python have advantages and challenges compared to statically typed languages like Go or Swift. What are the advantages of concepts like pattern matching and which languages leverage them the best? These are actually useful questions and learning about the different paradigms expands your toolset so that you have more kinds of information to bring to bear on solving problems. I think the biggest challenge and probably the biggest benefit to learning wildly different languages from what you already know is this process of learning that these different paradigms even exist. For instance, I wasn't even aware I should know about pattern matching until I dipped my toe into Elixir and now I see that it's a powerful feature that enables some very elegant solutions to really thorny problems.

If you already feel comfortable in a programming language or two, maybe learn to implement different paradigms there. What constraints does that impose or what possibilities does it expose? Before I left my last job, I had a coworker that introduced some pretty pure functional programming to a Javascript project. It was really challenging to think about the problem in a way that I wasn't accustomed to thinking about Javascript code.

Like I said, my answer to this "simple" question is long-winded, but I hope it's helpful to break folks out of the mindset of treating programming languages like Pokemon. Instead, I hope you'll focus on learning the concepts that will expand your programming toolbox so you can find elegant solutions to interesting problems.


I know Kotlin and Java, although Swing UI layouts still confuse me. These are the languages I would say I know, without qualification.

I know Python, C++, Objective C, and JavaScript, so far as I could probably Google my through whatever problem I have, but I MAY need to watch a tutorial by the end of it.



The very first language I ever learned. Intro to computing was the course. We did Karel the robot, I learned Principles of Object-Oriented Programming with it, learned Android programming with it and later did a course on design patterns mostly with it


Not only we were learning the language but with C++, I learned Data Structures and Algorithms. It later came in handy in learning computer architecture as these two are very complementary.


With this I include html, css and javascript. Funny enough, when I wasn't close or had access to a computer, I used my phone (a Galaxy Pocket Plus at the time) to run as a lamp server. I even used php to practice Data Structures with single and double linked lists. (Most of the apps I used as servers have been taken off google play. I don't know why)


Used to teach us design patterns but I still went back to java just to understand what python tried to express

8086 Assembler

Part of course work for systems programming and compilers. This was fun. I'm sure it's gonna make it easy for me to pick up a side project with microcontrollers and robotics one day.


I'm still learning it. You never really know JavsScript. But with it, I've learned JQuery, Angularjs, Vuejs, NodeJS, etc. and I don't know if that list will ever stop growing.


At first, I was intimidated by it, but I learned later that it isn't so scary. I converted my android app to use only it.


This I learned through picking up Flutter. From there I've been interested in AngularDart also. Especially the part about code sharing and state management (or the lack of. I'm not certain)

CSharp (the pound sign disappeared when I used it)

I completed a udemy course on it, therefore I know it. Also, I'm writing a .NET Core project just to check how comfortable I am with it.

I feel like I should write a full-blown post out of this πŸ€”


I'm not sure that I agree that everything mentioned in this discussion falls under 'programming languages' but I'll define 'know' as meaning a language that I understand (or in some cases, understood) well enough to either make a living from (ie. poeple paid me to work with that language) or produce tools used by others. In roughly chronological order of first picking up the language:

Basic (on a PDP machine at a technical college in 1976/77 - no computers at home or school back then)
JCL (if HTML is a programming language, then so is IBM's Job Control Language)
VS BASIC (IBM mainframe variant)
INFO (probably the most obscure entry on this list, a 4GL from Doric)
EXEC2 (old IBM mainframe scripting language)
BAL/HLASM (IBM mainframe assembler)
ST Basic/Fast Basic (on an Atari ST)
Motorola 68000 assembler
Superbase BASIC (SBL)
Windows batch files (especially the dialect used by Take Command and predecessors)
LotusScript (in the Lotus Domino/Notes context)
VBA (primarily under Excel)
Easytrieve Plus

There are at least seven variants of Basic in that list, and apart from APL (which I haven't used in more than 30 years) most of the languages are procedural and I would anticipate being able to make sense of a program written in that language if it was put in front of me.

Of the above I still write in REXX/SBL/HTML/PHP/SQL for leisure activities, write Python/REXX and read C/COBOL/PLI/JCL/SQL for work. REXX has been my favoured tool for 'quick and dirty' programs for more than 30 years and I'm currently trying to get my head around Rust as a possible replacement for C in situations where performance is more important than the elapsed time to something usable.


Depends on what you mean by "know". If measuring against, "knowing all possible ways of doing things in a given language," then "none."

Mostly, I have an overall knowledge of the things I ought to be able to accomplish in any given language, and then one "home" language where I can do those things with minimal dicking with Google to refresh myself. I've a couple other languages that I need to have close-to-the-top of my brain, but what those are and their "freshness" relative to each other varies depending on workload (i.e., "how recently I've had to use them"). That list changes over time – sometimes with addition of a new language or a language falling into the "mental archives" – an is heavily driven by work-demands.

On the plus side of code-linters, it tends to mean that the amount of <LANGUAGE_A>y-ness of my <LANGUAGE_B> output is reduced over what it used to be.



  • Languages that I know pretty well and I can be productive in time zero (maybe modulo a refreshment for those I do not use since long time)
    • BASIC
    • PASCAL
    • C
    • C++
    • PostScript (yes, it is Turing complete...)
    • Tcl/Tk
    • LISP
    • PERL
    • PHP
    • Ruby
    • Ada
    • Unix shell (sh-like)
    • Matlab
    • few assemblies (Z80, 386, ...)
  • Languages I have some experience with, but not a big deal
    • JavaScript
  • Languages I played with them for a bit or that I read about them. I guess I will be able to read a program, but I do not feel like I could be operative since time zero.
    • FORTH
    • Prolog
    • Simula
    • COBOL

Oh, yes, also I programmed the TI-57 (if you are not too old, you do not what I am talking about... :-))

I could throw in also LaTeX since I guess it is Turing-complete, although LaTeX programming (not just writing shorthand macros) is quite an experience...


I use web-based references to remember, supplement and write about 2% of code.

CSS grid
Android SDK
Kotlin (Android)
Actionscript 3
Flash Server Side ActionScript
Linux BASH shell scripts
Microsoft.bat scripts
RED 5 sever side Java
Wowza sever side Java

Other assets of calmchess


I am sure that I will be able to adapt to any language as long as I have the references and cheat-sheet with me. Though will take time to make something with it as need of remembering the best practices and studying the code of that language to understand which would be the best way to conquer problems etc.


HTML, CSS really good knowledge, use it day to day. PHP preffered language with strong dev skills. C# moderate and use it day to day basis. JS (scripting not programming language) but eill include. Know many libraries too such as Node.JS, Laravel, .Net framework ....


I can print out Hello World! to the console with every single programming language ever invented by humanity 😎

Bow to me, you nerds!


How about Assembly, the original language? πŸ˜‹


Damn it, I'm busted...

Damn you, Ken Bellows! I shall have my revenge!

My first computer (an 1802 processor in a system that was published in Electronics) did a LED sign board controller by hand assembling the code and inserting it into memory using switches! I then thought that punch cards were a step up!


Adobe Script
Bunch of other scripting environments.
Here I've listed everything beyond "Hello world" example. 😁


As long as I can bring my IDE about 5. It also depends what count as a programming linguage. If css, xml, yaml etc. count it's a lot more. Without IDE it's pretty hard.


Ones I've delivered production code in, in approximate chronological order

6502 Assembler
8048 Assembler
8086 Assembler


Generically, I'd consider 'knowing' a programming language to be having a sufficient understanding of the syntax and core language semantics to look at an arbitrary snippet of code (with sensible naming) and understand generically what it's doing (possibly with access to documentation about the API's it's using). IOW, you can read and understand at a basic level code in that language without needing to look up stuff like the basic syntax.

By that measure, I 'know':

  • C
  • C++
  • Java
  • POSIX shell script
  • Python
  • Lua
  • Perl (5 only)
  • BASIC (2 dialects)
  • Forth (basics, not specific dialects)
  • JavaScript (ES5 and newer only)
  • Elixir
  • Erlang
  • PowerShell (2.0 and newer)

And, if you consider them 'programming languages':

  • HTML (4.01, 5, and XHTML 1.1)
  • XML
  • JSON
  • YAML (1.2 and 1.3)
  • CSS (3)
  • SQL (core functionality + 2 dialects at a basic level)
  • Half a dozen network protocols (SMTP, HTTP, etc)
  • Half a dozen configuration file formats

Various shades of knowing:

I know Kotlin: I use it every day and could write poetry in it if you asked.

I know Java: I can understand any code written in Java - albeit slowly - but since I'm doing mostly Kotlin I'm forgetting the ampersand and inverting the order of arguments all the time

I know Typescript: the language is straightforward and I can use it in the same IDE so I can submit pull requests to my frontend colleagues: I copy paste then adapt.

I know Bash: I wrote a lot of scripts with it, but still have to Google every time I want to do a for loop.

I know Haskell: I know the name of the language and that it has lots of M.....


I've used Java, Kotlin, C#, Go, Python, TypeScript, JavaScript. I would say I "know" Java, Kotlin, C#, TypeScript, JavaScript.

"know" as meaning, if I'm giving a problem odds are I can write code without having to do a quick google search on the syntax.



So JavaScript it the language that's most natural for my eyes to read and write. However at some point I was going crazy with ruby still love that language. PHP is a language that I have been forced to learn either from school or from previous jobs I had.

So JavaScript and Ruby!


Langs I'd say I know (or rather, knew at a past time):

  • sh/Bash
  • Fish
  • C/C++ (a long time ago, and a lot has changed since then)
  • PHP
  • Python
  • Java
  • C# - WinForms + ASP.NET - fun times
  • Scheme - learned for a class - this was my "gateway" lang to learning functional programming concepts
  • JavaScript
  • TypeScript
  • Go
  • Rust
  • SQL

Langs that I've investigated (partially learned):

  • D
  • Haxe
  • Kotlin
  • Lua
  • Nim
  • Ocaml/ReasonML/F#
  • Perl
  • R
  • Rebol
  • Red
  • Ruby
  • Smalltalk

In retrospect, what I've come to value that I've learned in my journey is a set of abstractions that make solving complex problems doable in clever ways: OOP, functional programming, reactive programming, actors, text-processing, data-structures, memory models, data ownership, concurrency, package management, etc. For this reason, I tend to favor languages that support these strategies. My favorites to pair together (at the moment) is Fish for scripting the system, TypeScript for generalized scripting, and Rust for the lower-level.

Fish is much more sane shell scripting. TypeScript has an awesome type-system (for a scripting language). Rust has the best developer experience for a systems programming language I've ever encountered. Fun times!

For completeness, I should list some things I know I need/want to review:

  • Linear programming
  • Dynamic programming
  • Graph algorithms
  • State machines (both NFA + DFA)
  • etc.

I’ve done substantial programming in 23 different computer languages (programs with over 1,000 lines) over my 35 years of programming. But, currently regularly using HTML/CSS, JavaScript, go, ruby, tcl/tk, python, zsh, scheme, prolog, VimScript, and php. Of frameworks, I’m mostly using Svelte with NW.js.


Note that I'd be hard pressed to do most of this today, but I can relearn if I need to...

Stuff I've done a deep dive in for school/production work:
-- Fortran
-- Pascal
-- C
-- C++
-- Scheme
-- SQL (including a few variants like SOQL, HQL, etc.)
-- SPARC Assembly
-- Java (applets, JSP, servlets, and relatively modern Java)
-- Cold Fusion
-- Javascript (vanilla and with jQuery/AJAX)
-- Classic ASP
-- Perl
-- C# (both in ASP.NET Forms and ASP.NET MVC)
-- SED/AWK/Grep/etc
-- Shell scripts (Bash, the DOS shell, etc.)

Variants of BASIC
-- Apple BASIC
-- Visual BASIC (pre .NET)
-- VBA (macro language for Office)

Stuff I've had to read in production but not really do a lot of coding in:
-- Ruby (on and off the RAILS)
-- Python (that hurts considering I'm currently a data engineer)
-- Scala
-- Kotlin

Stuff I've dabbled in but never got to really use:
-- React
-- Angular
-- Cypher
-- Node

And there's a list that's just as big if you open up various tools, ecosystems, frameworks, data formats, etc. that aren't quite "languages" in a traditional sense but do have a learning curve.


I used to think I could "know" a programming language in a week or two.

I still can program in one in that amount of time and lean on a linter/style checker to achieve some semblance of idiomatic code.

For this definition I'd say I "know":

  • C
  • Scheme
  • Javascript
  • Java
  • Go
  • Ruby
  • Python

I've built projects in all of those languages and with the help of the internet I can become productive in them again.

However to truly "know" a language now and be able to do deep debugging of issues I feel like I need to understand more of the nitty gritty of it. How does it implement threads? What is its memory management/garbage collection like? Etc. etc.

In addition to this I like to ask myself "would a seasoned $LANGUAGE programmer understand this code?" "Would they be surprised by anything?"

For that definition of "know" I mostly just know Ruby. 😱


If I say, it's every language I "heard of" it's too many.

If I say, it's every language I worked with "professionally" it's still too many, because I started working as a tech blogger, which led to using many languages in my blog posts.

If I say, it's every language I feel (or felt) comfortable using, it would probably be PHP, JavaScript, C, LiveScript and VBA, because those are the ones I used to write bigger projects.

At the moment I'd consider myself only comfortable using JavaScript and often have a bit of fear using another langauge, because my knowledge of JS is so deep that I think it would take too long to get to know another language THAT good.

On the other hand, I didn't start with that deep JS knowledge and still used it everyday, so it's probably not needed to get things done :D


I was going to say, "define know"...

I'm an expert in Python and C++, and formerly in ActionScript 3.0. Of course, "expert" is a hard term to pin down: what I mean is, my code in these languages is clean, idiomatic, and efficient, and I have a solid grasp of the underlying language patterns and principles. (Pluralsight confirmed, at least on the first two, so that's something.)

I'm able to write good code in C, HTML, CSS, and Bash. I used to be at this skill level with Visual Basic .NET and VBScript, but I haven't used either in years.

I'm reasonably comfortable messing about in Java, SQL, Haskell, X86 Assembly, and FORTRAN.

So, only counting actual programming languages, I "know" 14.


My odd ball measure for "know" : I am aware of and possibly looking forward to language changes in the next release.

D, C#, C++

Since C++ is more of a product of following D, it could be crossed off.

Otherwise I've had the pleasure of working with likely 10 or more languages such as fril.


Being able to write something meaningful, probably somewhere around 20ish.

Having contributed to an actual project at work/contracting: about a dozen (C, Java, Go, PHP, Ruby, Python, JS, Perl, Clojure, Erlang, various SQL dialects, VB, Lua, a LOT of bash). If we include FOSS contributions, this goes up by about 3-5.


Stopped counting around 1998 :)

I can start writing code in any language on the first day. Some important details might be missing, but they will come in about two weeks. The last time I did it was this August with Objective-C. :)


Firstly by "know" I mean: Have the ability to write basic programs in said language with little to no extra knowledge needed e.g writing a "Hello World" program in Java with knowledge garnered from C#.

With that said, I know seven languages but only ever use two or three at a time depending on the project. The only reason I "know" that many, is because I learnt Java first and its syntax is pretty similar to other languages except Perl, Rust and Ruby to name a few.


In order of familiarity*frequency of use:

JS in various flavours
SQL in various flavours
Good ol' Haskell

Probably still missing a few. I very much echo the others listing "one size fits all" - so long as you're familiar with the basic paradigms. Between OOP, FP, event-driven, the Go channel concurrency, and different type systems, I've probably covered most short of assembly, PASCAL, and some research languages.


Let's see what I can remember:

Language Confidence
Python * * * * *
JavaScript * * * * *
Visual Basic * * * * *
BASIC * * * * *
Turbo Pascal * * * * *
PHP * * * *
SQL * * * *
ActionScript * * * *
VBScript * * * *
Delphi * * *
bash * * *
Prolog * * *
XSLS * * *
Maple * * *
C# * *
C++ * *
C * *
Java * *
Assembly *

Right now I know 1.5 language very well.

TypeScript and thus I know enough of JavaScript to be happy.

I used to use Java and Python, and even a little Go, but I don't even look at those languages anymore so I'm sure I've forgotten them.


I think I've dabbled in every one of them over the years πŸ˜‹. Not really, but I've dug deep enough into so many that it's just not a thing anymore.

I'll throw out a few I didn't see below though!

IBM 360 Assembly


I've been around the block a few times...
I've listed the languages I've used in active development, and left out the languages that I just dabbled with.

I'll attempt alpha-order.

BASIC (at least 10+ varieties)
GMAP (probably should be in assembler list below)
SQL (Not sure I'd call this a real language though.)
Visual Basic, J++

1802, 8080, Z80, 6502, 6800, 6805, 6850, 65816, 8048, 8051, 8080, x86, Z8, Z16, Atmel AVR

Wrote compilers for BASIC, C.
Developed my own proprietary interpreted language.

I have to agree that having a very deep understanding of a couple languages really do give you a leg-up on new languages that come along.

I would also add that it's very beneficial to dabble with your own compiler, and/or scripting language as you really get how it all works after that.

Just adding a postscript: I didn't consider things like HTML, CSS as 'languages'. Perhaps some do but I chose not to list those types of things.


Currently, I know only Javascript but I'm planning for Rust or Python. πŸ€”


How did you land on Rust?


Actually I want to get into machine learning and IoT. So, Rust seems better option for IoT