razetime

array languages are used by several companies for their work. K for example is pretty popular in fintech. Some present companies provide services for array languages as well.

https://www.dyalog.com/case-studies/index.htm https://github.com/interregna/arraylanguage-companies

I don't remember twitter having a serious vibe. It's a mess of vibes. Tumblr is also a big mess, but more on the goofy side. I don't think it would change much even with a twitter diaspora.

It's a pretty ordinary position to take right now, I believe.

a site doesn't have to justify its existence by being an alternative to anything.

Seeing this snide and shallow comment, I think you could benefit from expanding your mind by learning J: http://www.jsoftware.com/help/learning/contents.htm

Let's change the first line:

One misconception is that languages like J are in the same caliber as less practical languages (esoteric languages like brainf*k) that use symbols more than words. The assumption is that these are mostly for recreational programming.

Making some crude assumptions here, I believe you've already invested a lot of time into studying python, or some other well known language. Understanding python or C gives you an idea of hundreds of other languages because they use similar keywords and structures to represent their code. English also helps a great deal in understanding these languages.

Now, looking at this, giving a language like APL or J a chance means that you have to spend time learning their kind of notation. If you spend your time looking at APL without making an effort to understand it, then you cannot be surprised that it looks like regex to you.

The event was based on the esoteric language Nuova, defined by its implementation.

J has much easier access to graphics with bindings to a window driver and OpenGL .

APL also has support for GUI apps (Windows only) using .NET, but graphics takes some additional effort: https://www.youtube.com/watch?v=iC9floP7POU

Here's some links relating to this style of code that you may find useful:

https://docs.google.com/document/d/1W83ME5JecI2hd5hAUqQ1BVF3...

https://github.com/tlack/b-decoded

https://chat.stackexchange.com/rooms/90748/conversation/ngn-...

They're not 1.5 paragraphs per line, but enough to give a taste of the implementation style.

Well, yes, there's other languages like Julia, MATLAB and such if you want familiar, approachable syntax for array programming. Nial (https://nial-array-language.org/), which is inspired by APL, mostly uses words instead of symbols, which you may find more intuitive.

In K, terseness is part of the package, and it is considered good, because you can see the innards of your code at a glance, there's lesser text to change if you mess up, so on, so forth. Some time investment in the language may or may not help with this.

I hope you have taken some time to understand K's philosophy and goals before making this comment. A tutorial exists here: https://github.com/razetime/ngn-k-tutorial if you'd like to understand why this solution is good.

J isn't really made to be pretty. It's made to be terse and simple to read once given enough learning effort, and it's made to be a consistent keyboard typable notation.

is this what the new Zed editor is planning on using?

K is the easiest popular array language due to its array model and its commitment to simplicity. Gets you into the habit of writing out strings of symbols instead of names, and although it holds your hand less, I'd say it's great as a beginner language. With the existence of new docs like the oK docs(https://github.com/JohnEarnest/ok/blob/gh-pages/docs/) and the wiki(https://k.miraheze.org/), it is getting much easier to learn K.

ngn/k is the most active in development. You can meet the developer and people who use ngn/k in the chatrooms listed here: https://k.miraheze.org/wiki/Online_Communities

Hello, one of the maintainers of the wiki here. The major changes are generally divided into:

K2-K4

K5-K6

K7-K9

From my knowledge. Each group has the same general primitives and syntax, and major changes happen between those eras. Since K's design allows removal and addition of features, this is very hard to document. This, combined with Arthur Whitney's rocky relationship with documentation makes most sources of changes anecdotal. Most changes to primitives have been documented in the wiki's primitive pages. I'll have to summarize them in the history pages.

K4 has good docs, and K6 has a well-written manual on oK's repository. The rest are a fill-in-the-blanks game which have to be fished from archive pages and a lot of trial and error. K9, the latest one is still undergoing changes, but there are ongoing efforts to make tutorials in kparc/kcc and estradajke/k9-simples on github.

There are many, many array programmers who choose to write in a literate style. Popular code examples written for toy challenges often tend to be smart one liners whose algorithms cannot be easily put in multiple lines, so they may look unreadable for people unfamiliar with the languages. A terse compact code style often works well with the language's design.

If you'd like some examples of traditionally literate array programming, you can see:

- tangentstorm's J streams: https://www.twitch.tv/tangentstorm

- tangentstorm's J repositories: https://github.com/tangentstorm?tab=repositories&q=&type=&la...

- Dyalog's APL repositories: https://github.com/orgs/Dyalog/repositories?q=&type=&languag...

Some array programmers inspired by Arthur Whitney write code like this. I wouldn't call it an abomination per se, it's a specific style meant for a specific person. They find that way of writing C to be nice. It's somewhat popular among people who implement K-like array languages.

A usual result of using array languages is a want to have that same terseness in other languages. Array languages usually deviate from the style and aesthetic of general programming languages. It may be jarring to look at, but as with anything, a little experience with using them can go a long way with understanding why many people work with something so "unreadable".

It's all up to preference, really. It took me a while to get around my muscle memory from general imperative programming by the time I started using languages like K competently. Getting that motivation is definitely hard.

This website has a few companies which use K: https://github.com/interregna/arraylanguage-companies

Iverson wanted consistent symbols and rules for math notation. So it's math first, then programming language next. Makes it extremely strong with describing algorithms, but gets a bit complicated for programming.

In general programming I like to use a keyboard layout which allows typing APL glyphs with Right Alt: https://github.com/abrudz/Kbd

APL's ASCII based relation, J is opensource(GPL, I think). [BQN](https://mlochbaum.github.io/BQN/) is a newer rationalized entry which is completely FOSS.

K is another array language which has a proprietary implementation. Tcl is a relatively popular proprietary language.

Obviously someone decided to program in a literal line noise language.

The general method of input most people use for APL is an IME with a shifting key, see: https://aplwiki.com/wiki/Typing_glyphs#By_method

I doubt there is one. I know of Dyalog's backend and web service frameworks, but I don't think there has been a use of APL's notation for HTML/CSS/JS programming.