In my experience one of the key differentiators as to viability is who is backing the software. Kx/Q or 8th don't even register on this TIOBE index, and are closed source, but are well crafted and perfectly viable because there is a profit making company behind them, and customers whose itch it scratches.

You can really tell when you're using an unviable language; big parts of it are broken, often in subtle ways that you can only find out about after heavy use, and the maintainer doesn't give a shit about your problems, even if your problems should be in the niche the language addresses. There are many open source languages which fit this description; some of which rank in the top-100 or even top-50 in this ranking system. By contrast, something like Awk with a relatively low rank may score poorly but will be viable as long as there are text files.

Good point Scott. A more difficult to capture metric would be "what software would you work with if you had the choice and could use whatever you wanted"? I really enjoy writing in array language (like K) and have actually had a blast learning 8th. So either of those would make me happier over the more common/traditional tools that I generally work with.

I'd forgotten about 8th. Who are the customers in that case?

I'm just writing software for fun with the free version and it is very enjoyable so far. It doesn't have a huge community, but there are definitely a number of active posters on the forum and the maintainer adds new features all the time and will fix most bugs in hours and is very accessible.

Before I say anything, it’s probably worth noting that I write it for a living. Is it bad that while I was reading this I felt like you might be talking about JS? Or are we talking much more broken?

JS is probably the most viable programming language there is. There was one "starts with letter J" language I was thinking of (along with a few others not starting with J); very fashionable and touted here which is egregiously unviable and broken though. It ain't J or Java.

Okay, good. I know it's popular to hate on JS, but I think it catches a lot of undue flack. I know it's not perfect, but I also know enough to have at least learned the reasons for most of its shortcomings. I mainly asked because it was my first language, so I often wonder if there really are greener fields out there and if yes, how much greener they actually are.

I was first exposed to it in detail prototyping a machine learning project for Brendan Eich, which is now a part of Brave's browser. JS has obvious defects, but it is amazingly handy and a very good design with good compromises. The tooling and community is excellent of course, though it is a real abuse of JS to try to write ML algorithms in it. But it could have been a language of data science instead of R, had it come in a different era.

It would be helpful for people looking to invest time in this language if you would just call it out. Or if you'd prefer, we can do it over some private messaging medium.

I suspect I know which, but not sure. Also would like to know more about your critiques.

Julia? I'm no expert, but it seems to be up and coming.

It's the same argument I would make in general: ubiquity does not signify popularity, and ubiquity does not signify quality. This is especially prevalent when a language becomes the 'de facto' sole option for a given environment.

cough JS cough

> For Haskell it's academics/researchers

Some real businesses use Haskell too.

Other than that, you have a point.

Most known languages have a few businesses that use them. That does not mean is enough to be commercially viable, though.

Isn't the definition of commercially viable that it be used commercially succesfully?

I think it would be more along the lines of:

"if all the existing volunteer mainteners for this language went down in a single airplane accident, would businesses who depend on this language step up and fund its maintenance and could they support that organically from the margins of their business?"

When the answer is yes you have a language that is going to live forever independent of whether it's a fad this year or not etc. Which is partly why I think some seriously out-of-fashion languages keep going surprisingly strongly. Meanwhile some pretty awesome languages just wither on the vine.

Not sure why you're getting downvoted, you have a point. Seems like a "no true Scotsman" fallacy:

"Yes they're used successfully in some companies, but they're not truly commercially viable".

anything can be used "commercially succesfully" given people putting enough work / being bright enough to use the tool. It's not a very useful metric taken like that.

Not really, too much work and the business will go under. Imagine Zuckerberg coding the first Facebook in ASM. It most likely would never have gotten of the ground.

it's not a binary question, it depends on who is asking. If someone is asking who has limited resources or time to invest and not access to a lot of engineers then the realm of what's commercially viable shrinks pretty quickly.

If you have someone who has the resources and time to experiment, then sure everything that is literally viable may be viable.

In general, it's probably somewhere in between. I wouldn't take one or two companies or even solely proprietary companies as a good example though. For the average person it probably matters most if a language has a rich and alive open ecosystem.

I was thinking commercially viable in this context meant for the dev learning it. If you learn Haskell what's your chance of getting a job with it as opposed to any of the other languages you know?

Hasura is written in Haskell - https://github.com/hasura/graphql-engine

And PostgREST, if we're counting out of the box useful web technologies.

Sure I don't want to diminish its use in business but my point was that its continued use by academics is what made it viable for some businesses. It likely would have died out if it relied on business (and other non-academic) users.

>For Ada it's the US government

Ada is used widely in safety critical software outside the US

Out of curiosity - what are some recent examples (both government and private)?

NVidia, it has decided to go with Ada/SPARK instead of Frama-C or Rust (the othe candidates) as official language for security critical firmware.

GenodeOS project, started to rewrite security critical modules from C++ into Ada/SPARK.

Add is used in a lot of areas outside Defense and Aerospace (which I assume is what people associate Ada with).

Air Traffic Management and Rail Signalling systems are probably the two biggest fields outside of Defense/Aerospace where Ada has commercial success.

A big barrier to entry was previously the high cost of the toolchain for commercial applications (that's somewhat changed). Which meant it was only economically feasible for large companies in very safety-critical contexts.

Look on Adacore's website. They have a decent amount listed iirc.

I actually don't personally know a single researcher using Haskell, unless you mean PL research, in which case I'd even say that Haskell isn't much of a hot topic these days.

James Clark used Haskell to design and implement an algorithm for validating Relax NG XML schemas (he co-designed Relax NG, and designed its predecessor TREX), to work the ideas out before re-implementing it in (many many more lines of tedious brittle) Java (JING). Haskel works wonderfully as a design and standard definition language, that way.

https://en.wikipedia.org/wiki/James_Clark_(programmer)

https://www.drdobbs.com/a-triumph-of-simplicity-james-clark-...

http://xml.coverpages.org/ni2002-02-14-c.html

https://news.ycombinator.com/item?id=14154049

DonHopkins on Apr 20, 2017 | parent | favorite | on: What programming languages are used late at night?

I got some insight into what's great about Haskell by reading James Clark's "An algorithm for RELAX NG validation":

http://www.thaiopensource.com/download/old/relaxng/20020531/...

>This document describes an algorithm for validating an XML document against a RELAX NG schema. This algorithm is based on the idea of what's called a derivative (sometimes called a residual). It is not the only possible algorithm for RELAX NG validation. This document does not describe any algorithms for transforming a RELAX NG schema into simplified form, nor for determining whether a RELAX NG schema is correct.

>We use Haskell to describe the algorithm. Do not worry if you don't know Haskell; we use only a tiny subset which should be easily understandable.

Text.XML.HXT.RelaxNG.Validation

http://hackage.haskell.org/package/hxt-relaxng-9.1.5.5/docs/...

>Validation of a XML document with respect to a valid Relax NG schema in simple form. Copied and modified from "An algorithm for RELAX NG validation" by James Clark.

Clark Updates Jing - A RELAX NG Validator in Java.

http://xml.coverpages.org/ni2002-02-14-c.html

>James Clark has announced a new version of Jing with significant changes and revised documentation. Jing version '2002-02-13' implements the final RELAX NG 1.0 Specification and also implements parts of RELAX NG DTD Compatibility, specifically checking of ID/IDREF/IDREFS. James has "almost completely rewritten the validator using an improved algorithm. In the old algorithm, the state of the validation was represented by a stack of sets of patterns; in the new algorithm, the state is represented by a single pattern... The new release includes a documented API for Jing; in fact there are two APIs, a native API and JARV. James has rewritten the description of derivative-based validation to correspond to what's been implemented and to incorporate feedback received on the previous version from Murata-san and Kawaguchi-san... The Jing implementation is available for download as a JAR file and as a Win32 executable for use with the Microsoft Java VM.

Yep, that's why Clojure struggling and has no future. Not strong in any domain and doesn't have any fundamental benefits over other dynamic programming languages like JS/Python/Ruby.

That is only if you try to program Clojure as if you were programming JS/Python/Ruby. In this case I can understand you may think this is funky, strange but otherwise useless language.

The trick with any Lisp is to "get it". Once you do there is no comparison between Lisps and any non-Lisp language.

Let's compare it in some useful way. If I was assembly developer for my entire life, "getting" C++ would be comparable to getting Lisp for any JS/Python/Ruby developer.

From my point of view JS/Python/Ruby is just a reiteration, variation on roughly similar, impaired subset of features that I can roll off in Lisp on my leisure. By definition, any language feature can be written in Lisp (well... more in Common Lisp than in Clojure which is hindered by its integration with Java environment) which is something that is really hard to grasp until you start rolling off your own language for any problem you try to solve (and one reason Lisp programmers are so much hated by other programmers).

Should have phrase that differently. This is a case of "worse is better". I know Clojure well and, IMO, it's the best language in the world for writing application/business logic. Many times, when programming in JS/Python, those just feel stupid to me. But that doesn't stop many programmers from writing impressive stuff and being super productive in JS/Python/Ruby, why? because they are great developers and can apply their knowledge to most languages.

Having said that, and going back to the original point, Clojure struggles and will continue to struggle because it doesn't have any strong hold in any domain, in contrast to JS/Python/Ruby. Each of these have big ecosystems of libraries, documentation, big market share in various domains and big job markets. So yeah, worse its better.

I dunno, I've programmed professionally in both Racket and Common Lisp and would only choose Racket if I was implementing a DSL or something (and I would never choose CL for anything). The heavyweight syntax and dynamic nature are really only worth it in programs that are modifying the AST very frequently. I think a statically type functional language such as OCaml, F#, or Scala are much more suited for general purpose programming. I might be weird, but if I'm dealing with a Lisp codebase that is over, say, 10 kloc, I get a distinct feeling of unease, though this applies to really any dynamic language as well. The productivity and performance benefits of an expressive type system cannot be understated.

If the only parenthetical language you know is Clojure, and you think that is what Lisp is about, you seriously have the wrong idea. That is the reason why you think that the gap between Lisp and Pyhon/JS/Ruby is so vast. But in fact those are Lisp-inspired languages that take their basic paradigm from Lisp.

Clojure seems to be a whole-program transformation away from having continuations or tail calls. It is hard to apply such whole-program transformations while using libraries.

Bothe are due to unfortunate decision to run Clojure on JVM and conform to Java calling convention.

Clojure is not designed to appeal masses, but to solve complex problems and keep things sane. And if you notice around, specialized industrial tools aren't pretty, but are sharp.

> Not strong in any domain and doesn't have any fundamental benefits over other dynamic programming languages like JS/Python/Ruby.

Don't get me wrong, but this can be said only by someone who never used it seriously or simply didn't get it. Reminds me on Scheme/Racket complains from students who took classes only for GPA or simply got in wrong university.

People have been saying Clojure is dying for years, but there's plenty of people using it to great effect. I'm more productive in Clojure than in any other language, and I have access to a wide array of Clojure and JVM libraries. The power it gives me lets me spit out solutions to problems much faster than less expressive languages like Python. Perhaps you haven't really programmed enough in Lisps to really get the point of them.

Outside Java it is my favourite JVM language, but I think it used to be more popular, I know a couple of business that started with Clojure in 2014 and I am not sure if they would still go with it nowadays.

Looking at your post history, you seem to be on a mission against Clojure... is there a backstory?

This is news to me as someone taking a break from a greenfield CLJS app to procrastinate on HN...