FBlag

As a programming language enthusiast I often examine new (to me) languages, paradigms and concepts. Recently I played with J - sth. like APL with keyboard friendly syntax. If you are familiar with point-free functional programming, J isn't that complicated. More tedious is the used vocabulary (verbs, nouns, frets, agenda, gerunds...) for trivial things and the fact, that you can't use search engines - neither for "J" (-> "site:jsoftware.com"), nor for a function symbol (combination).

Mind bending are the many one-liners and examples in the documentation. And believe me, there isn't much more satisfaction as in unraveling the first lines of J code. ;)

As practical example on "hello world" level I used the Bifid Cipher:



Keep in mind, this is of course not the shortest or fastest or nicest implementation. It's just my first J program.

A short explanation for the curious

Read from right to left, @ is function composition and & binds a parameter.

pre - prepare our string

1. take a list of characters (the string), convert every character to uppercase (toupper) and look up (&i.) the characters in the ascii table (a.)

2. subtract 65 (ascii value of 'A') from every list item (-&65) (a 0..4 indexed cipher table to save some inc- (>:) and decrements (<:))

3. and decrement every item greater than 9 (]->&9) for the missing 'J'(!)

The last part needs some explanation. (]->&9) is a so called "monadic fork". We have three functions f (] "identity"), h (- "minus") and g (>&9 "greater than 9") and the constellation as monadic fork (f h g) x executes as h(f(x),g(x)). The comparison gives a list of 0s and 1s, "NB." is line comment:


enc - encode

1. Now you are familiar with forks, you can interpret (<.@%&5,5&|) also, didn't you? On the left side we divide every element by 5 (%&5) and round (<. "floor") to the next smallest integer. On the other side we compute the remainder of the division with 5 (| "mod") and append (,) that list to our left result.

2. with ((%&2@#,2:)$[) we reshape ($) our list to nx2, n is the length (#) of the list divided by 2 (%&2), (2:) is the constant function, giving back 2

3. and transpose (|:) it for our final conversion in pst


dec - decode

Decode is similar to encode.
1. div (<.@%&5) and mod (%&|) our list but merge (,@,.) the result

2. and again reshape the result to 2xn with n as half list length


pst - result to string

1. we have to rebuild our string, so we take the first row ([/) and multiply with 5 (5&*) and add (+) the result to our second (]/) row, to which we added 66 (66&+)

2. we have to decrement the values below 75 ('K') (]-<&75)

3. and lookup our values in the ascii table ({&a.)


Now we can compose and use our encode and decode functions:


Another example

Not enough? I see you are as fascinated as I am. The next example ist from j602/system/main/convert.ijs

3 : '... y' defines a verb, imagine it as a function with one argument y. (()`()@.()) is:

m@.n is a verb defined by the gerund m with an agenda specified by n ; that is, the verb represented by the train selected from m by the indices n . If n is boxed, the train is parenthesized accordingly. The case m@.v uses the result of the verb v to perform the selection.

Pure beauty! Here (2&=@(3!:0)) acts as a case or if expression. It returns a value which becomes the index of the left "list of functions" (take it with salt). 3!:0 returns the "type" (more salt!) of a parameter. If it is a character it returns 2, the following comparison (2&=) returns 1 and (a.&i) evaluates to the index of this character in the ascii table. Otherwise we assume it is a number and return the corresponding character.