Recommend me a programming language

pathief@lemmy.world to Programming@programming.dev – 82 points –

I've been working with a Javascript (+ TypeScript) + Java + SQL stack for the last 10 years.

For 2024 I'd like to learn a new programming language, just for fun. I don't have any particular goals in mind, I just want to learn something new. If I can use it later professionally that'd be cool, but if not that's okay too.

Requirements:

  • Runs on linux
  • Not interested in languages created by Google or Apple
  • No "joke languages", please

Thank you very much!

EDIT: I ended up ordering the paperback version of the Rust book. Maybe one day I'll contribute to the Lemmy code base or something :P Thank you all for the replies!!!

170

Id suggest rust, gets you a step closer to the hardware and a bit of a different paradigm than Java while still feeling high level.

Rust is definitely something I've been keeping an eye on. The syntax looks a bit scary, to be honest, but looks very versatile.

I'll second Rust, it's so fresh and versatile! You can go from super low level stuff all the way to things like web frameworks with WebAssembly and whatnot.

The memory model is definitely a unique beast but I've found it gave me some insight on how it all actually works behind the scenes and I appreciate the strictly enforced correctness too.

I'm a Rust noob. At first it's daunting and nothing will compile. But it's getting easier and I feel like getting over that initial difficulty is mainly a matter of internalizing a few basic rules, after which it feels more natural. So from what I've seen so far, I wouldn't rate Rust as especially difficult. It certainly feels easier than C++.

For a really challenging language I'd suggest Haskell. That one nearly broke my brain because thinking functionally is really very different if you're used to more procedural languages. Rust, it seems, teaches you new discipline, but Haskell teaches you a different way of thinking.

Anyway, that's how it feels as a relative noob in both.

Definitely rust, and definitely use rustrover from jetbrains for an IDE. It's amazing

Except that actually doing anything with hardware is "unsafe."

Well, yeah, because doing things with hardware is just always unsafe in that sense, no matter if you're implementing it in Rust or C or Assembly. As long as you know what you're doing (and the hardware manufacturer did, too), it's not actually unsafe.

Rust just decided to isolate the code parts where you need to be extra smart like that, whereas in C or Assembly, you might need to be extra smart throughout the entire code base.
Obviously, no sane C programmer would just randomly start scrubbing memory addresses in UI code, but it's still just helpful to have the naughty code clearly indicated.

Python seems to be a staple for as long as I can remember and it looks like it's still gonna be going strong for a good while yet!

I'm thinking of taking the dive and finally learning it myself soon.

Packaging solutions kinda sucks, but we're about to get a JIT in the main CPython so that's exciting.

When I used to work a lot with Python the packaging solutions available were the bane of my existence. I hope they've gotten better by now..

Python is especially great for quick scripts or PoCs. I've been using it a lot lately to prototype some things and it just makes it a breeze

Main complaint is the snake_casing convention. By far my least favorite

Hah I love snake case.

I also love python for distributed micro tasks and data pipelining

I am the only person that feels like snake casing belongs in declarative stuff, data serialization etc. (SQL, protobuf, JSON, YAML...) while camel case elsewhere?

I don't hold any of that, I just find it the most readable for me.

If you decide to take the plunge, I highly recommend the programming course on mooc.fi.

Hadn't heard of that, will check it out for sure. Thanks 🙌!

Anytime. Their discord community there is very active and helpful. If you'd like help or feedback without getting muddied by discord, feel free to inbox me.

Great for prototyping and quick scripts.

That and such rich set of libraries for anything you want.

C# is a great choice.

Incredibly versatile language and should be an easy jump from java.

Agreed, as a Java developer you will hopefully find C# familiar but more refined. They share a lot of the same features now, but C# seems to do them all better, in my opinion. Linq especially is just so much more enjoyable for me than Java Streams.

.NET Core (now just .NET) readily runs on Linux and Visual Studio has a free edition that is superb - an IDE provided by the language developers. Of course, you can always use Visual Studio Code or a third-party offering like Rider (by JetBrains so the transition from Java could be very easy of you are already familiar with their programs).

My only complaint on C# is that the .NET versioning is a little confusing if you aren't already familiar. However, that's only an issue if you work with legacy code. New versions after .NET 5 are all the same naming and upgrading is generally effortless, just changing a single number in your project file and downloading the proper SDK

My two cents: I strongly agree with this. We just deployed an intranet blazor server app running on Linux (don't know which distro) and apache (we might switch to nginx soon). It works very well and we had to write less than 100 lines of JS (mostly for file download and upload) One of my workmates was hired one year ago and at the time he didn't know anything about .Net stack. Now he is mostly autonomous and he loves .Net and blazor in particular. Obviously YMMV.

Bundle size is my only complaint with blazor, has to send the .net runtime in webassembly to the client.

Aside from this, C# on the browser is an absolute joy to use. I'd use for everything if I could.

You are talking about Blazor webassembly, I am talking about Blazor server side, which loads as fast as a "normal" website.

Server side Blazor has other caveats, that's why I specified it is an intranet project, where server side Blazor fits very well. Anyway, at the moment, Microsoft is still putting effort in polishing both type of Blazor hosting model.

This is not our first Blazor intranet web app and some of them are running in production for one year more or less.

It is really a joy to program using Blazor, especially if you need cross tab/browsers/device/user real time communication, which comes almost free thanks to underlying SignalR channel.

Ah you mean Razor then. Blazor lets you run C# in the browser, but Razor is the one that needs a server and streams changes to the client using signalR.

I know Microsoft didn't get this right with naming and you got caught in the trap but there are 2 (actually 3) ways of hosting Blazor.

I also see that this confusion won't help OP choose Blazor over some more coherent dev environment hehehehe

Sorry, that's my bad, I was under the impression that Blazor and Razor were two distinct ways of doing things. Thanks for that link, it was very helpful.

Razor

Razor is the templating engine that's been there since the original MVC. Blazor Server is the one that needs a server and streams changes to the client using signalR. Blazor WASM is the one that uses Web Assembly. As of .Net 8, Blazor can now also ne used as a generic SSR backend. They all use Razor Components, which is a component model using the Razor engine.

Not to be confused with Razor Pages, which is also a generic SSR backend.

I get the impression OP wants to try something new. Java and C# are pretty similar.

Just don't bring your damn factories over. For some reason Java developers just love unnecessary layers of abstraction and forcing that ridiculous factory pattern.

And they bring it to any language they develop in after Java.

If you see someone saying "no Java developers" for a position, this is why. They've been trained incorrectly, as a joke.

All the core parts of dotnet (e.g. roslyn) seem to be built that way. I find them very frustrating to work on. Between that and the whole nuget thing being somewhat FOSS unfriendly, I'd steer people away from C#.

I don't get how NuGet is FOSS unfriendly. I mean, at worst you could set up your own repository. All the tools are local. It wouldn't be difficult to set up your own source if that was absolutely necessary.

The whole thing is built around pulling binary packages from servers, and there's no consistent way of building those things from source.

It's extremely difficult to package anything non-trivial without referencing those binary blobs.

They had to build this whole custom thing (https://github.com/dotnet/dotnet) just to make the SDK itself buildable from source, and most releases still have some binary dependencies. They only did it for the SDK so it could be packaged in Debian, etc.

In my previous company we had a dot net + Microsoft SQL server stack. The code base was admittedly really really bad but those .NET Web Forms were horrendous to work with. C# in general felt very close to Java at the time, except for the LINQ queries I guess.

I'm sure that, like PHP, the technology has come a long way and things are better and more modern right now. This was before Nugget was even a thing! Regardless, I feel like those chapters in my life are finished. I'd rather try something actually new to me!

I have a couple of suggestions based on what you want!

Ocaml: A good intro into functional programming

The languages you've used seem to be primarily imperative style. Ocaml is not commonly used in the industry (with some exceptions), but it has a vibrant small community, and more importantly, because it's a functional language, it will be different enough from what you know. Even if you don't use it in industry, it will teach you a lot that would be hard to learn using non-functional languages.

Ocaml is a compiled language, with a very fast compiler and very good type system.

Scala: the only semi-mainstream language that blends OOP and proper functional programming well.

Although scala is mostly a functional language, it still has most of the gestures of imperative OOP languages like Java. It is also far more mainstream than ocaml and has used in industry.

Scala also runs in JVM like Java, and thus gives you access to most JVM libraries.

Rust

Intro into low level programming Other answers spoke enough about Rust so I won't dive here

Zig

similar to Rust in low-levelness, but less mainstream, better C interop, and other interesting differences

Raku: the result of 15 years of programming language design

Raku, formerly perl 6, was almost redesigned from the ground up to resolve complaints of perl 5. It has a very interesting design, with a gradual type system, a blend of functional and OOP paradigms, plus interesting syntax features like sigils and grammars.

There are many interesting languages out there. I could talk forever about this, but I'll leave you with the above. I personally would recommend ocaml if you're interested in functional programming or care about performance. Otherwise, Raku, since its very interesting but doesn't perform well (Raku's VM is still immature and under development).

Coming from JavaScript, they may enjoy using ReScript instead of Ocaml.

I tried to give OP languages that would be reasonably different from what they know already, so that its more fun (imo).

However I didn't know of ReScript, so I gotta check it out.

I'm sorry, but as someone who was paid for Perl 5, I have trouble seeing the appeal for Raku.

The first thing they should have done was nuke Perl from the orbit. Instead they built on top of the magic variable hell.

So no thanks. PHP is much better.

1 more...

I can recommend Rust - I'm training a few people on it.

And a pure functional programming language like Haskell or Scheme, if you don't know what functional programming is, or are not comfortable with it. Functional programming needs a different mental approach to traditional (imperative) programming paradigm. Some of the more modern languages like Rust, JS and Python incorporate a lot of functional programming constructs. So it makes sense to learn them.

And a lisp - Common Lisp's popularity is a public secret. Scheme is also fine. This family is homoiconic (program and data are treated more less the same). The syntax is actually very close to its AST. This gives Lisp unparalleled metaprogramming capabilities - mostly through macros. Macros in traditional languages are nowhere near Lisp Macros.

If it interests you, study a stack based language like Forth or Factor. Though they feel very different from Lisps, they have similar underlying properties. And you get more or less the same advantages.

+1 for Rust, the learning curve can be pretty daunting, but once you're over the hump you'll never want to go back

Agree. The official book is a really good start though, and available for free. https://doc.rust-lang.org/stable/book/

I actually ordered the paperback version of the book. I hope it's not too outdated compared to the online version, I just enjoy reading in actual paper :P

The second edition was published last Feb (2023) I believe. I read it on my Kindle, having "flicked through" the online version about 6 months prior, and yeah having it page by page with bookmarks etc was almost as good as paper, but far superior to the web version and I was able to read it cover to cover and gain a lot from it. I immediately then read about 4 other books on Rust! Can recommend "Rust Atomics & Locks" by Mara Bos, and "Rust for Rustaceans" by Jon Gjengset for the next level up.

Yeah, I did indeed buy the second edition! Thanks for the suggestions! Cheers.

Learnyouahaskell.com is a good way to get started with Haskell. I'd recommend that as best for your mind expansion mission.

Personally, the language that's taught me the most to learn has been Haskell. It has a lot of very interesting ideas and a learning curve that plateaus after most other languages. There are several ideas that have trickled down from Haskell to other parts of the programming world and learning about them in the context Haskell is in my opinion better because you'll learn about them in a context where they fit in with the rest of the language very well instead of being late additions that offer an alternate way of doing things.

Coming from Java and JS, Haskell has a very different approach to a lot of things so you'll have to re-learn a lot before you get productive in it. This can be frustrating for some but you'll learn more if you get over that hump on the other hand.

Haskell doesn't see very much industry use and arguably isn't very well suited for industrial application (I haven't used it professionally so I don't know personally) so it might not directly help you land any new jobs but it is in my opinion it's a very good way to develop as a programmer.

No jokes: pick a language that is in the market, but has a different design philosophy than your background. Your background includes compiled static, and loose scripting, with strong library tooling, so you have diversity there, so a language in which you have to think differently is the right choice.

I recommend:

  1. Rust if you want something safe but that makes you work differently from java
  2. Go if you want a real mental challenge (the coding approach is very different from java)
  3. Lua if you want really see functional programming as a philosophy
  4. Python if you want scripting, and are tired of the web

Go if you want a real mental challenge

I don't mean to be rude, but I find this baffling; what do you mean by it? One of the primary design goals of Go is to be simple to learn (this is fairly well documented), and it's one of the few things I really have to give the language credit for. Rob Pike has specifically discussed wanting it to be accessible to recent CS graduates who have mostly used Java. I have never heard anyone before describe learning Go as a "challenge."

  1. Lua if you want really see functional programming as a philosophy

I'm pretty sure that Lua doesn't follow functional programming as a philosophy...

Give Clojure a go.

It's a modern variant of lisp that runs on the JVM and has deep interoperability with Java, so you can leverage your existing knowledge of Java libraries.

But as it's a lisp, it will have you thinking about problems in a very different way.

Can you name any real world usages for Clojure? I did some lisp once when I was a sprout and loved it, would be awesome to do it on the jvm now that I work with java every day.

It's a very flexible language so can find a niche almost anywhere. I know of fintech companies that use it extensively for their back end data processing systems, and I've seen some really interesting stuff done with Clojure and Apache Kafka. They're a good fit for each other - Clojure, as a lisp, is optimised for processing infinite lists of things and Kafka topics can be easily conceptualised as an infinite stream of data.

Also, when combined with Clojurescript, it provides a single language that can be used full-stack, so could drop in anywhere that you might otherwise use Node.

But I think one of the best things about it is the way it forces you to re-evaluate your approach to development. It's a completely functional language so you have to throw away any preconceptions about OO and finding new ways to resolve old problems is one of the things that should be a joy for most developers, even if it has no practical application.

IMHO it would fit use cases of java, mostly long running services. But it is a hosted language with different implementations on top of javascript, .net etc. So it might branch out other use cases like frontend dev. It has a small but active community. Although it might be most popular lisp nowadays.

If you are not familiar with lisp and aim is having fun while learning new things then clojure will fit nicely. It is so joyful once you get the initial weirdness because it will feel different. You just fire up a REPL, leave it running in background, hook your ide/editor to it and start sending evals. The application grows while it is running. I find the workflow quiet enjoyable.

Elm

In short, it's ruined my expectations of languages. It's a functional language, like the style of Haskell, and transpiles to html or js (its meant for web). There's very little that it allows for going wrong, and for things that could fail, it either tells you to port that out to JS and bring it back when you're done, or you have to handle a Result type or Maybe type.

It sounds strict, yes, but not having to deal with issues later is so nice.

1 more...

C or C++, specifically with the use of compiler explorer so you can get a feel for how code actually runs.

Common Lisp or Haskell to get a taste of something really different.

I’ll suggest Elixir. It’s a language that runs on the same virtual machine as Erlang, which has proven to be great for ultra-reliable and excellent at managing many, MANY concurrent processes.

Elixir itself builds upon this great foundation with a syntax similar to Ruby, but entirely functional. It’s a delightful language to read and write.

I’m a huge fan of Haskell and (for pragmatic purposes) Purescript. Purescript is hard to find much in the way of documentation but it is so similar to Haskell in that the steep learning curve is worth it, IMO. I rarely find a project that I couldn’t accomplish with one or the other or both.

Nothing I have done in my career has given me even close to the benefit I got from learning Haskell. I don’t get to use it professionally, but the patterns I learned to recognize in Haskell are everywhere.

2 more...

Rust, haskell, python, c++ are all interesting choices. I would argue that c# is too close to what you already know to be interesting.

If I were you though, I'd pick a project first, then decide what language makes sense for it.

If I were you though, I’d pick a project first, then decide what language makes sense for it.

Certainly the best approach is to use the best language for your project. Right now my project is to learn something new and exciting, I bet when I start learning the ropes I'll get some ideas!

This is my favourite list in here, but I'd throw a Lisp in too.

Lisp, Haskell, and Rust should all teach you something new and profound about programming.

How about COB-

No joke languages.

Oh...

Well... If you want to earn A LOT of money before mainframes are entirely sunset, and are perfectly happy maintaining code that's older than yourself and only working for very rigid banks... Then COBOL isn't actually that bad of a choice...

If you like your sanity, you should probably tear clear, though.

Kotlin is by far my fav language. I've been astonished by its capabilities used with the "Exposed" library

Yeah! It can even compile to JS and the JVM! Interestingly, it also supports the functional paradigm as you can see when programming with Compose.

I recently picked up Rust, still a beginner, but it's very nice. And the compiler errors and tips are top. Since I used only Python before, Rust is my first compiled language and I'm glad it was Rust. Options and Result's are also something I appreciate tbh. Other than for AI, simple stuff and maybe prototypes, I would use Rust over Python. Definitely recommend it. The borrow checker is a pain in the ass though. I'll also be using it later for embedded systems when I become more fluent with it. I am also currently making a big project with Rust that I haven't been able to do with Python.

C. Plain old low-level "portable assembly" C.

In particular I'd recommend a Game Boy game, because GBDK uses SDCC and is fairly low-bullshit. With scanline interrupts, you have a surprising amount of time to do clever visual effects, flexing the machines one-and-a-half background layers. The machine is sufficiently explained in about forty-five minutes via the Ultimate Game Boy Talk.

(NES is also an option, but - don't. I say this with my NES homebrew project open in the other monitor. It's a miracle this thing ever caught on. You need a decent understanding of the hardware, C, and 6502 assembly, just to put stuff onscreen efficiently. And then the fillrate still blows. The Game Boy can blast the whole tilemap in a fraction of a frame if you cheat hard enough.)

If you want more power, the GBA supports C and C++, and that little fucker runs Doom. It's intended as a super-flexible sprites-and-tilemaps affair, like an SNES with an upgraded graphics chip. (And a downgraded sound chip.) You can scale and rotate dozens of sprites at 60 Hz, atop two scaled-and-rotated backgrounds. Or use fullscreen bitmaps in 8-bit or 16-bit color. (Well, 15-bit.) The homebrew scene for the GBA started before the console even launched, because it has a pretty standard ARM chip and will do anything the Genesis could without breaking a sweat. There was nearly a voxel heightmap version of Banjo Pilot that looked pretty damn close to Diddy Kong Racing on N64.

I recommend C and retro consoles because they're suited to one another - and they offer control. You are in command of every single byte on these machines. C is the ideal language for that. It offers familiar high-level structures. It supports familiar syntax. But it runs very close to the metal, and if you want to get even closer, it will let you.

C++, or if you want to lean towards a more modern lang, C#. Kotlin is also a lot of fun

+1 for Kotlin. You'll pick it up fairly fast if you uave used Java.

Scala can also be compiled to JavaScript with really good interop with JS libraries, and to native with decent interop with C

Scheme, and work through SICP, watch the lectures along with the reading.

I prefer Chez Scheme but there's many implementations. Chez's fast and practical, C FFI, large standard library, nice REPL with editor.

Go. It'll be just different enough from what you have experience with to make you think about things differently (in a good way!) from now on. And it's also a fantastically well-designed language that's great for getting real work done. And it's lightning fast as languages go, and compiles to an actual executable. Really a pleasure to work with. It's my (no pun intended) go-to language for every new project I start. (Excluding what I write specifically for a paycheck. I don't have a choice there.)

Don't really want to invest in a language designed by Google.

Sorry. I missed that bit in your original post. But I get it.

I started looking into it largely because I have a lot of respect for the individuals (Rob Pike, Ken Thompson, Russ Cox, etc) who created Go, not because Go has anything to do with Google. And because I love everything they have to say about their approach to designing the language. But at the end of the day, it's true that they're employed by Google, and after the whole WEI thing, I can't say I can trust Google at all.

That said, right now I have no specific concerns.

That's what's so great about go. It's doesn't take a large investment to learn it.

I’m not crazy about Google’s part in Go, but man, I’ve been using Go a lot and I love it. It feels like a “modern C” that lets you focus on logic instead of memory allocation. I know it violates your requirements, but I’d suggest checking it out anyway! 🤷‍♂️

These come to mind:

  • Elixir to expand the way you think about problems (and maybe your career).
  • D to bring familiar conveniences closer to the metal.
  • C to understand (and maybe contribute to) a vast ocean of existing software.
  • Python for development productivity.

As the other person said, Python. Or if you want something lower level, how about Rust?

Rust doesn't even have to be lower level

Kotlin is the language to beat imo. Very expressive and full interop with Java. Structured concurrency so multithreading Is a breeze. Build mobile apps easily with it for Android (and in theory iOS but that's still alpha). Desktop apps too!

I see you mentioned JS, but not TS. If you haven't tried TypeScript, you 100% should! It helps a lot at scale.

Also, I really do recommend Rust. It's pretty awesome having the errors actually make sense, and it's not as complicated as the hype makes it out to be (until you get into async rust lol).

As others have mentioned, C# is also awesome.

We do use TS as well, yes!

Rust is definitely a language I'm considering. Syntax looks a bit scary, though!

Syntax isn't the scary part - it's the concepts. You need a decent understanding of the hardware to make sense of the language rules. Rust has a lot of high-level abstractions (like other modern languages and unlike C). But they don't deviate from what the hardware limitations dictate.

Rust syntax is totally fine really. It often feels like writing python

Download GODOT and learn the scripting language and the shader language. Make a game! Or at least neat shader art.

Bonus answer: Csound. Make funky noises with code.

I'm gonna be the weirdo recommending Ruby. I really like it as a language, and it's pretty fun to write. Plus it's got a lot of libraries so you can do fun projects like Discord chat bots.

I been meaning to learn Ruby to get around using Python. I like Ruby syntax better.

I have this one weird friend who does competitive one-line-programming in Ruby. It's supposedly the best one-liner language.

I can believe it. The way Ruby implements "everything is an object" gives it amazing flexibility. Though the one-liners for Ruby aren't as intricate and beautiful as Perl one-liners.

I absolutely hate ruby. I would almost rather write php. Ruby just feels like every decision they made is wrong, and designed to add confusion.

I feel like you and I wouldn’t get along

Maybe. I just do not understand the love for ruby. Literally all the ruby code I've ever seen is just awful. Which isn't necessarily a dig at the language, but it just seems like it makes it so easy to write terrible code.

Also, what's the deal with unless? "Do this unless ..." is so unintuitive it's almost like it was designed that way as a joke.

Clojure, it's a lisp that runs on the jvm and would be quite the shakeup for ya.

Alternatives

  • C#, because it's good
  • Rust, because it's different
  • a (purely) functional language, because it's different
  • Nushell, nice shell, and great for scripted data processing

DotNet is closest to Java, but hang on to your hat: the state of C# is at least half a decade ahead of Java, if not a full decade. It’s sophistication will make Java use feel like banging rocks together. DotNet Core can now run on all three primary platforms, and with some careful work, you can write a single program that can compile down to each platform and carry along its own required binaries, no pre-install of any framework needed.

My second recommendation would be Rust. Stupidly steep learning curve, but an absolutely game-changing one where safety and security is concerned. It’s my next objective, personally speaking.

Any other language I could recommend starts getting into speciality purposes, which makes general use more difficult or even wholly inappropriate.

For example, if you are dropping into DotNet for business applications, I would also recommend diving into F# for that functional goodness for building complex business rules and data handling. But building an entire app in F# can be jamming a round peg into a square hole under many circumstances, it’s appropriateness envelope does not cover as many cases as C# does. You want to use C# for boilerplate/frameworks, F# for the core bits where it is going to shine.

Have you ever wanted to do more with regular expressions? Then give Perl a try.

Do you want to awaken the Elder Gods, and consequently suffer a slow and inevitable descent into horror and madness? Then give Perl a try.

Truly efficient perl code is write-only.

While it's related to your job and not very new compared to your current stack, it's very worth it to learn typescript. It has a cool type system and makes frontend development sane.

I say that you should find some interesting project, possibly something related to some desktop environment like Gnome, KDE, sway, cosmic and so on. There are multiple fun/interesting projects around them. Then pick a small and manageable task, use that to learn the language that project uses.

I find Cosmic to be a very interesting desktop project, and they use Rust if that would be of interest.

Odin is quite a fun new language I just started learning. It is meant as a C replacement and comes with a decent standard library and third party library so there is a lot already built that you can use. It also is fully compatible with C and can use C libraries.

Just be warned that documentation is lacking and you will have to read the source code of the standard library from time to time or seek help from their discord.

Read up a bit on this now, and it definitely looks like something I want to try out! One of the beautiful thing about C is its simplicity, and it looks like Odin has been able to keep that, while introducing some nice convenience features that I often feel like I miss when writing C.

C# has been doing a lot of really cool things lately, and has first-class Linyx support.

Kotlin would be the most straightforward/useful professionally if you're primarily Java. Other Java stack options are Scala or (shudders) Clojure

What's wrong with clojure? (Serious question. I saw someone else recommend it in this thread)

I love Clojure+Clojurescript

Ada and COBOL are still where the big money is, and still will be for years to come.

Factor!

It's incredible and elegant and defies some common categorization.

I've put some of my favorite resources in the sidebar of https://programming.dev/c/concatenative and I'm happy to walk through any particular challenges/examples -- I've done about the first week of Advent of Code with it this year, and the most recent handful of Perl Weekly Challenges, and some basic Euler problems.

Re the sidebar: How are Nim and Roc partially concatenative?

I may be expressing it poorly and inaccurately, but what I mean is that in Nim you can re-order arguments and functions to start with some data followed by a series of transformations. The following two lines are equivalent:

parse_int(read_line(stdin))
stdin.read_line().parse_int()

Roc offers a similar flow with their |> operator. Here's a snippet from one of my Advent of Code 2022 solutions:

partOne =
    "input.txt"
    |> getData
    |> Task.await \data ->
        data
        |> getRangePairs
        |> List.keepIf pairHasStrictSubset
        |> List.len
        |> Num.toStr
        |> Stdout.line

That’s true, but if the transformations have more than one argument, they go after the name:

data.split(",").join(";")

as opposed to concatenative programming languages, where all arguments go before the name and there’s no visual indication of the structure:

data "," split ";" join

Also, there are more languages with this feature, for example D, VimScript or Koka.

That’s true, but if the transformations have more than one argument, they go after the name

Yup, I understand. That's why I've not put them in the concatenative section.

Also, there are more languages with this feature, for example D, VimScript or Koka.

Thanks, maybe I'll add them to the sidebar! I hadn't heard of Koka.

If you have a suggested heading/description to replace "partially concatenative" I'm interested. Function chaining? And I'm not sure but maybe execline is actually concatenative and needs to be moved out of that section.

I think “uniform function call syntax” is the established term for this particular feature.

Thanks. I know that's the case for Nim's flexibility, but I didn't think it applied to the pipe operator stuff like in Roc. I'll do some reading tonight to confirm.

Since you already know Java, you could jump straight to C++ with Bjarne's book "Programming - Principles and Practice Using C++": https://www.stroustrup.com/programming.html

You can then move to more modern C++ with his other book "A Tour of C++": https://www.stroustrup.com/tour3.html

And then if you're curious to know how software design is done in modern C++, even if you already know classical design patterns from your Java experience, you should get Klaus Iglberger's book: https://www.oreilly.com/library/view/c-software-design/9781098113155/

In parallel also watch the "Back to Basics" video series by CppCon (see their YouTube channel: https://www.youtube.com/@CppCon , just type "back to basics" in that channel's search bar).

Learning proper C++ should give you a much better understanding of the hardware while the syntax still remains elegant, and you get to add a new skill that's in very high demand.

Perhaps Elixir is worth a look.

I would second Elixir. Either that or Rust. Sure both are popular, but for good reason.

They are completely different from the languages you use.

You will be introduced to new paradigms.

As a person who used the same stack as you (albeit typescript instead of JavaScript), I think it would be a waste of time to learn C#. It is so close to Java, and learning it may make you hate having to use Java, because it seems a bit better put together. Even though it runs on Linux, and is a good language, I don’t think there is ever a reason to chose it over Java, because M$.

Ada particularly the SPARK subset. It's approach is quite different than most languages, focusing on minimising errors and correctness. It's fairly difficult but I like to use it to teach people to actually understand the problem and how to solve it before they ever write the code.

I love C#, but F# is also super fun and worth checking out.

If you haven't done any Clojure, may be Elixir?

When I first ventured into programming, I felt like a complete novice. With no prior experience, diving into the complex world of coding seemed daunting. That's when I stumbled upon full stack development service. These services offered a comprehensive solution, covering everything from front end to back end development. It was like having a guiding hand through the intricacies of programming. With their expertise, I was able to navigate the complexities of software development with confidence. Full stack development services became my stepping stone into the world of programming, helping me transform from a novice into a proficient developer.

  • modern PHP (version 8.x with some modern framework like Symfony)
  • Typescript
  • C#
  • C++ (this one's always fun, I recommend the Qt framework since you have a Java background - it would be easier than raw C++)

Qt is an amazingly good C++ framework that encourages a much safer approach to using the language that emphasizes const refs over pointer insanity.

Also, the library function are quite powerful.

If you want something that feels more quirky, go with Lisp.

I've been having a lot of fun with scheme lately (specifically guile, but I don't think it matters much). It's a very stripped down language compared to common lisp, so I felt it was easier to get started with.

I like Scala:

  • multi-paradigm, you can explore many ways of doing something, within one codebase - arguably the most complex language, if you want, but doesn't have to be: start simply, later scales robustly
  • compiles and interoperates with JS, JVM, native
  • Scala3 dropped brackets - easily readable like python
  • great tooling (recently) - compiler infers so much -> less puzzles / testing
  • developed mainly in europe, not controlled by big-tech

Fwiw, here's my interactive climate system model running in pure scala.

The languages I've been meaning to learn, and do something "meaningful" in, are:

  • nim
  • erlang (or whatever is the most sensible modern variant)
  • lisp (ditto)

COBOL

A strangely effective option for young whippersnappers who want to maximize employability and income stream in “boring” tech. You’re not gonna be standing up many greenfield projects using that language - and likely speaking, you might go an entire career without ever touching a codebase younger than you are - but if your passions run towards Janitorial/Plumbing work with regards to code, it might be right up your alley.

It's a coding language I recommend to anyone wanting to code in finance. Banks like it's reliability I guess

C# is good. I use Visual Studio on Windows, so I'm not familiar with the tooling in VS Code in Linux, but I've heard good things. .NET is a nice environment to work in, the runtime works on all the OSs, and you can even package it into a self-contained binary with a little finagling.

I think Rust and C# are the future.

Controversial opinion, but I think Python, Java, VB, and others will become legacy languages. They'll be around for 30-60 years, just like Cobol, but I expect things to settle around other languages.

I tried to get into Python, but always found it boring. Ruby was more my speed because it was inspired by Perl and that's the first language I learned. But Python will likely get you more job opportunities.

PHP is a really fun language syntactically and has a surprisingly good built-in library.

As a PHP Dev: Please avoid PHP unless you have to use it.

What would you recommend learning instead?

My team is currently exploring rust as an alternative because we have to do a lot of api calls and data crunching real fast. So rust?

As a php dev who actually writes clean code and doesn't blame people writing shitty code on a language: don't listen to this fella.

As a php dev who actually writes clean code while cleaning up after other people because Getting things done is more important: Don't give people the tools to write shitty code.

I know it's fashionable to shit on PHP but it's significantly better than it once was... it's honestly like a cleaner python that lets you use brackets.

Sure, could be/was a lot worse than today. Still, PHP gives one way too much rope to hang themselves with.

Hey, I grew up on C++... you'd be amazed how comparatively safe PHP is by comparison. I don't disagree though, but I do appreciate having features like var-vars around for when I need them.

Cleaner python? Hahaha that's hilarious

PHP was my favorite language like 20 years ago but I don't think I ever want to touch it again xP

If it was your favorite language twenty years ago then you'll hate it now - it supports functional programming and cleaned up (nearly) all the awful cruft.

Seriously - try PHP.

It's a much much nicer language than Java or JavaScript and unlike some of the latest languages (which are, arguably, even nicer) PHP has a massive library of third party packages that you can either use or just learn from.

And unlike Python, which is a general purpose language, PHP is purpose built for exactly the type of work you're doing.

Most PHP websites are wordpress, which deserves all of the crap people ditch on it, but all of that crap is wordpress not PHP, and there are other options. Start with this: https://phptherightway.com/pages/The-Basics.html

People shouldn’t be down voting you just because they disagree and hate php. I’ve read that it has come along way in the last 10 years or so. People really like Laravel too. I wouldn’t put it on my list of recommendations personally but I get why someone might.