Joy (Programming Language)

https://en.wikipedia.org/wiki/Joy_(programming_language)

by reedwolf • 6 years ago

98 42 6 years ago

en.wikipedia.org

reedwolf• 6 years ago

Example from C2[0]:

  (* x y percent approxEqual *)
  DEFINE approxEqual == 100.0 / rotate [0 =] [pop] [dup rolldown -   
  swap /] ifte >

[0] https://wiki.c2.com/?JoyLanguage

jayp1418• 6 years ago

I still find ada language more advanced than current ones

oddity• 6 years ago

What do you mean? They’re different branches on the tech tree. Saying one is more advanced than the other is strange.

msla• 6 years ago

Ada is just another Foogol, and is missing a lot of features from other branches of the language development world.

Jenz2• 6 years ago

‘[M]ore advanced’ meaning ‘better’?

ngcc_hk• 6 years ago

Very confusing as just have another Joy web framework. For this kind of new language, one may have to have a kind of FAQ for the reason why it exists at all. Why not just FORTH?

progre• 6 years ago

The language is 19 years old, it's not new.

yiyus2• 6 years ago

Why not just FORTH?

Joy comes from a totally different background, and has a very unique set of features. The fact that a purely functional point-free programming language finished looked quite similar to Forth in some aspects was just an accident (a happy accident, imo).

billfruit• 6 years ago

Though there too much fatigue from trying to give mind space for new languages popping up almost every day, but this seems an older language. While I am not going to try it out, I can give you some ideas like : "The concatenation of two programs denotes the composition of the functions denoted by the two programs."

Jenz2• 6 years ago

As one might expect, ‘Joy’ is a popular name. IIRC the Crystal language was also initially named Joy.

nivertech4• 6 years ago

It's a functional programming language where every function is of type stack -> stack.

I like concatenative languages[1] and especially pipelines[2], but IMO Forth-like stack-oriented languages are in the wrong direction, b/c they force programmer to manipulate arguments on a stack, which feels hackish.

And my first real physical computer was an RPN calculator. As a kid I wrote lots of programs for it.

Also b/c of their simple implementation, Forth-s and stack-based VMs are frequently used in the wrong domains, i.e. Bitcoin's Scripts and Ethereum's EVM.

APL-family languages are better in this regard, but they also feel hackish in the general case, especially when passing arguments to nested functions. Copying RTL-style from math notation is also wrong. You are typing LTR (at least in English), but the expressions are evaluated RTL. Here Forth, RPN, and UNIX pipelines got it right.

The interesting direction would be a programming language with following attributes:

  - Purely-functional
  - Statically typed with an algebraic type system
  - Concatenative [1]
  - Tacit / Pipelines [2]
  - Homoiconic
  - top-to-bottom, LTR

[1] https://en.wikipedia.org/wiki/Concatenative_programming_lang...

[2] https://en.wikipedia.org/wiki/Tacit_programming

vanderZwan4• 6 years ago

I think your list basically describes http://kittenlang.org/ which sadly has kind of halted in development because the sole dev working on it couldn't get anyone else on-board. Probably because it occupies a pretty rare niche of computer science interests.

nivertech4• 6 years ago

any relation to Cat [1]?

[1] https://web.archive.org/web/20150205081218/http://cat-langua...

thelazydogsback2• 6 years ago

I appreciate both Forth (and Lisp) and have both used and implemented several (mostly naive) versions of both, but IMHO with something OCaml/F#/Reason you get pretty close. Sure, it's not concatenative, but you can certainly code point-free if you like so rather than:

c(b(a(42), 2))

You can write either:

42 |> a |> b 2 |> c or a reverse pipeline: c <| b 2 <| a <| 42

with complete type-safety. Note quite as concise as:

42 a 2 b c

But I that's good for the most part. I think programming with higher-order curried functions and closures gives similar power but much more readability -- every time I've gone past the toy program stage with concatenative languages, my head ends up exploding -- but maybe I never had the appropriate epiphany.

With that said, I certainly appreciate the power of Forth and compile-time words -- amazing power for such a minimal system.

nivertech4• 6 years ago

agree,

I'm using pipelines in Elm, which is almost the same syntax as in OCaml (piping into the last argument).

I dislike "<|" b/c of the flexibility syndrome. It's frequently used in Elm in order to avoid parentheses.

Same with Elixir, but it's missing currying, so it does piping into the first argument.

Clojure has both thread-first and thread-last macros.

The problem with these approaches is that they are optional. Ideally the point-free programming will be the default, not an optional style.

I agree that pipelines in Elm and Elixir are much more readable than point-free code in Forth and APL ;)

Unlike the ML-family languages, in APL/J/K/q you can omit any combination of arguments:

  f:{x-y}
  
  f[1]  same as f[1; ]
  f[;1] same as f[ ;1]
  f     same as f[ ; ]

ken2• 6 years ago

I’m not sure what “feels hackish” means but it sounds suspiciously like a nonspecific complaint that is used when all the actual potential issues have been exhausted.

In programming, we’re always dealing with stacks. It’s just that they’re usually invisible. As someone dealing with an unexpected user crash in a modern/traditional language, the possibility of making them visible would be pretty helpful right about now! I’d kill for a crash dump that included a data stack, too.

andrewflnr2• 6 years ago

It's an aesthetic complaint. It has the word "feels" right in it. What do you expect?

With that said, as someone who hasn't programmed in Forth-likes but has read about them, I can guess at a more precise complaint: stack manipulation operations like dup, swap, roll, et al are pure noise relative to my business logic. They're implementation details constantly interfering with my intent. And yes, I'm sure if I find just the right factorization into tiny words I could avoid most of the explicit stack twiddling, but is that really a good use of time relative to writing in C? Or figuring out how to design a better language? Doubtful.

yiyus2• 6 years ago

In my opinion, the perfect programming language would have RTL evaluation like APLs but RPN is a superior input method. If I had some kind of IDE that allowed me to "build" APL expressions (and dfns) using RPN as I built algebraic expressions using my HP calculator, I would be a happy man.

Forth LTR feels good with small expressions (and many times, that's all you need), but as soon as you have something complex, stack shuffling makes difficult to keep a mental picture of what the program is doing. I have the same problem with complex tacit expressions, I need to "translate" it. But dfns (or k funcs) are trivial to read.

vincnetas3• 6 years ago

"In Joy, everything is a function that takes a stack as an argument and returns a stack as a result. "

But formal parameters are same things[1]. It's just a values pushed to stack before calling a function and values poped from stack on return. That's why you get stackoverflow exceptions in java when your recursion fails.

EDIT: [1]most of the time, in situations that i know about.

boomlinde2• 6 years ago

The difference is that in one case it's an implementation detail covered by an abstraction to make that fact irrelevant to the programmer, and in the other the language is fundamentally designed around the idea that the stack itself is exposed as a data structure to the programmer.

If you don't understand how the difference is significant, I suggest trying a language like Joy, Factor or Forth.

throwaway_pdp09• 6 years ago

I fully understand the difference but having read up on forth but never used it, I don't know if it's helpful in that sense. Exposing the stack fully is a weakness not a strength to me.

I also understand that this is a formalisation that supports concatenative programming but from a user point of view, does it fit human comprehension as well as, or better than, a more conventional language. Honest question, thanks.

vincnetas3• 6 years ago

  class Fun implements Function<Stack, Stack> {
  
    public Stack apply(Stack s) {
      return s;
    }

  }

So this is Joy in Java. But as my neighbor comment asks. How does this benefits a language as tool for humans to get job done (c). From my perspective it only brings you down the abstractions ladder.

toolslive2• 6 years ago

Joy is great (at least better than SQL) as an API to a database. IE, every query is a joy program. If you add get, set and (de)serialize as primitives, you have stored procedures, intermediate results, galore! Want to transform your result before you send it back to the client ? no problem, just add a transformer function.

mafm• 6 years ago

Can you add a link pointing at some examples?

toolslive2• 6 years ago

there's a bunch of research related to 'stack based query languages' google for SBQL.

Anyway, in the specific case of joy is more difficult to dig up. Here's an example (I know it, because I implemented it): https://github.com/openvstorage/arakoon/blob/lsl/src/system/...

    "script1_" true 
    "script2_" false
    0
    [POP; 1; ADD] 
    FOLD_RANGE

The above program has basically calculates the number of keys between "script1_" inclusive and "script2_" exclusive. It's really compact flexible and powerful.

Now, before you run off and think about implementing this yourself. First have a look at kitten: https://kittenlang.org/

co_dh• 6 years ago

The point of Forth/Joy is that the language is so simple, you don't need compiler. It is a minimum language.

kalium-xyz• 6 years ago

Michelson language has distinctly ruined my taste for language like this.

Gormisdomai• 6 years ago

The coolest part of this article imo is the binrec operator. Do other languages have something similar?

carapace• 6 years ago

I've been working with Joy for several years now, on an off, in a hobbyist way, and I've got to say, I think it's the most useful, simplest language.

(I've made implementations in Python and Prolog https://joypy.osdn.io/ )

amelius• 6 years ago

From many viewpoints a stack is a nuisance, for example memory management and context switching. Therefore I think that languages which use a stack are going in the wrong direction.

Joy (Programming Language)

Related Stories