When comparing J vs Rust, the Slant community recommends Rust for most people. In the question“What are the best (productivity-enhancing, well-designed, and concise, rather than just popular or time-tested) programming languages?”Rust is ranked 7th while J is ranked 49th. The most important reason people chose Rust is:

Since Rust is statically typed, you can catch multiple errors during compile time. This is extremely helpful with debugging, especially compared with dynamically typed languages that may fail silently during runtime.

Pro

J also supports multiline functional definitions similar to BASIC/Pascal. Including error handling.

Pro

Compiled language speed from interpreted language.

Each built in operator is a C/asm function, and special code further optimizes some operator combinations. Result is optimized C speed from quick parsing. Array orientation parses and compiles a function once, and applies it to all array items.

Pro

Language reference has simple one page index

Pro

No operator precedence rules

(... within each of the 3 operator classes) makes reading code easier. Very simple parsing rules.

Pro

Every function is an operator

3 classes of operators (verbs, adverbs, and conjunctions) with verbs the most basic function that take either 1 or 2 (infix) parameters. Operators allow function composition with a minimum of parentheses.

Pro

Catch errors at compile-time

Since Rust is statically typed, you can catch multiple errors during compile time. This is extremely helpful with debugging, especially compared with dynamically typed languages that may fail silently during runtime.

Pro

Threads without data races

Unique ownership system guarantees a mutable data to be owned and mutated by only one thread at a time, so there's no data race, and this guarantee is checked at compile time statically. Which means easy multi-threading.

Of course, immutable data can be shared among multiple threads freely.

Pro

Generics support

You don't have to write same array and dictionary classes hundreds and thousands times for strong type check by compiler.

Pro

Compiles to machine code allowing for extra efficiency

Rust uses LLVM as a backend, among other things this allows Rust code to compile down to machine languages. This allows developers to write programs that run as efficiently as possible.

Pro

Built-in concurrency

Rust has built-in support for concurrency.

Pro

Support for macros

When you identify a part of your code which gets repeated often, which you cannot abstract using functions or classes, you can use Rust's built-in Macros.

Pro

Supports cross compilation for different architectures

Since Rust 1.8 you can install additional versions of the standard library for different targets using rustup/multirust.For example:

$ rustup target add x86_64-unknown-linux-musl

Which then allows for:

$ cargo build --target x86_64-unknown-linux-musl

Pro

Makes developers write optimal code

Rust is a modern programming language written around systems. It was designed from the ground up this way. It's language design makes developers write optimal code almost all the time, meaning you don't have to fully know and understand the compiler's source code in order to optimize your program.

Furthermore, Rust does not copy from memory unnecessarily, to give an example: all types move by default and not copy. Even references to types do not copy by default. In other words, setting a reference to another reference destroys the original one unless it's stated otherwise.

Pro

Easy to write understandable code

While not as verbose as Java, it still is much more verbose than languages like Go and Python. This means that the code is very explicit and easy to understand.

Pro

Zero-cost futures or Async IO

Cons

Con

Syntax is pure madness

quicksort=: (($:@(<#[), (=#[), $:@(>#[)) ({~ ?@#)) ^: (1<#)

Con

Hard to find learning resources or libraries

Because it's still a relatively new language, Rust does not enjoy a following as large as other languages/environments. Rust development has also been rather volatile for a long time during the beginning of the development of the language adding to this issue.

Because of the small community, it's harder to find useful libraries for projects or any other kind of resource.

Con

Asynchronous I/O is not (yet) a part of the core language

The issue of asynchronous I/O is still being discussed as a language feature, and not yet in the implementation phase. See the RFC on GitHub here.