How many programming languages do you know?

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

Comments

[Ben Lovy]

If my search history is any indication, zero.

[jeikabu]

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

[Sandeep Balachandran]

I am this close to hack NASA with my html skills

[dataPixy 🧚‍♂️]

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

[Ruslan Shashkov]

This plus some CSS skills would be quite enough.

[dataPixy 🧚‍♂️]

hardly, maybe try XSS ;)

[Ben Lovy]

HTML+css is turing complete!

[dataPixy 🧚‍♂️]

if you say so :)

[Ben Lovy]

you don't have to take my word for it

[dataPixy 🧚‍♂️]

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

[Ben Lovy]

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

[dataPixy 🧚‍♂️]

I think we work on different planes ...

Thx for your CSS links tho!

[DownloadPizza]

PowerPoint is also Turing complete

[dataPixy 🧚‍♂️]

PowerPoint is just a tool! Wrong channel! :)

[DownloadPizza]

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)

[dataPixy 🧚‍♂️]

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

[dataPixy 🧚‍♂️]

this thread is now Turing complete! lol! Cheers!

[Unfrozen Caveman Dev]

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.

[Simon Stanley]

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 🤣

[dataPixy 🧚‍♂️]

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

[/]

XML might do the trick

[dataPixy 🧚‍♂️]

sure! try it with SOAP! 🤓

[PabloMezak]

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

[Ken Bellows]

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.

[Michel Renaud]

Throughout the years I've used...

BASIC
Turbo Pascal
8086 assembler
SPARC assembler
C
C++
COBOL
Modula-2
Scheme (LISP dialect from MIT)
Smalltalk
VBA
Visual BASIC
C#
Javascript
Java
Typescript
PL/SQL
Transact-SQL
PHP

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.

[Fulton Browne]

What is your favorite?

[Michel Renaud]

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

[Unfrozen Caveman Dev]

We're nearly career twins!

[Erebos Manannán]

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.

[Jesse Phillips]

:greating
?n
#touch @lietux
Hi
#zap greating
#give health 5

[Szikszai Gusztáv]

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 :)

[Erebos Manannán]

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.

[Szikszai Gusztáv]

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.

[galoisWannaBe]

IDK, it feels unfortunate that I remember JavaScript 😂😂😂

[Ben Lovy]

ZZT-OOP

Whoa. Instantly transported to middle school.

[Erebos Manannán]

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.

[Phil Ashby]

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

[Erebos Manannán]

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.

[Kasey Speakman]

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.

[Ken Bellows]

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.

[Jeremy Likness ⚡️]

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.

[Anwar]

Interesting one :) Here is my list

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

[Alexander P.]

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

[Anwar]

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... :)

[Pandita]

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