Jvm Languages Puns

I'm on Ultimate - https://i.imgur.com/ZNvclOt.png

E.g. It seems to compile very slowly, where a squiggly under an improper change can sometimes take a minute to appear.

Seems a known IJ issue: https://intellij-support.jetbrains.com/hc/en-us/community/posts/115000770044-Typescript-inspections-sometimes-unreliable-and-or-slow

My colleagues use Visual studio, and it's sounding promising, but IJ at this point is second nature to me and I don't wish to give it up. Any plugins or other addendums I could use to make TS in it less painful?

CASC Logo

CASC / CASC Doc

I am a senior high student from Taiwan, and I just created a programming language calls CASC, it's inspired by V Lang, and most important, it's heavily focus on concise syntaxes and enhancing language features. Although it is still in alpha development phase, but hope you guys like this project, welcome to collaborate or support this project!

Hello, I am a JVM developer, primarily Scala. I'd like to try and build a game or even a game engine. While learning Rust or Zig is somewhat appealing, I want to explore the possibility of using Scala. (A) because I think the reactive streaming libraries I am familiar with would make it really fun to develop a reactive simulation engine and (B) because I already know it.

Short explanation: the primary issue with using a JVM language for games is the massive amount of allocations and usage of `Object` that would inevitably occur. The memory requirement would just be too massive. The "flyweight" pattern is a way to avoid that by creating one object for each type of object and keeping the values for all the instances as primitive/pure data values inside. for example, when creating a text editor, instead of having an object instance per character to store its font, font size, color, whether it's bold/italicized/underlined etc, you have one Character object holding array for each attribute with the value as a primitive.

I am interested if anyone has used this pattern to write demanding game engines on the JVM and how that turned out.

As we start to move to having to support 2 CPU architectures do you think JVM languages will see a resurgence in popularity to cope with the different architectures?

How does Clojure manage to simplify JVM/build setup so much? I recently wrote an API for a project in Kotlin and quite enjoyed the experience ... until I tried to deploy it. The endless permutations of Gradle/Kotlin/IntelliJ/source/JVM settings sent my head reeling. Days were lost trying to make it all work together but I never did manage to generate an artifact which had the correct classpath and manifest settings. When I spent some time with Clojure a few years ago I remember Leininngen configuration being a breeze yet Clojure is still a JVM language.

I am interested in doing a little minecraft modding. Although I am very familiar with java, I wanted to take the opportunity to use something like Clojure or Scala instead. Is this feasible?

This may be less of a question about minecraft in particular and more about interop between java and other JVM languages. Regardless, is there anyone who could point me in the right direction?

He was asked about this yesterday on Nicolai Parlog's 25h Java birthday stream:

Clip 1
Clip 2
Clip 3

What would be your motivations to switch or stay?

Hello folks,

I'm currently working on my toy project Kawa: https://github.com/mojo2012/kawa-lang/blob/master/README.md

It's a programming language for the JVM (or GraalVM/Truffle) that tries to be as consistent as possible, but also tries to encompass all the features one would expect from a modern OOP-language:

• First-class support for methods and closures
• Null-safe navigation
• Builder pattern syntax
• Named and position methods arguments
• Map/List syntax support
• Micro-thread/async-support (based on GraalVM isolates?)

I'm using ANTLR for the grammar. Currently I'm trying to figure out how to use Truffle for the AST creation - unfortunately the documentation is very poor :-( So help here is highly appreciated.

This is my first try on implementing a programming language, so only god knows where this will lead me. The motivation behind this is that imho Java falls behind when it comes to proper (syntactical) support of nowadays features like mentioned above. Languages like kotlin on the other hand feel bloated (keyworderism) and inconsistent (aka "ugly").

In a way I like groovy, but the lack of good IDE support is a show-stopper.

Let me know if anyone of you is interested in collaborating (be it actual coding or just feedback).

And keep in mind: this is a fun project!

(Shameless self-promotion, but it's an article that took me a while to write.)

I've compiled a list of some neat features that exist in other JVM languages, but not in Java. You can read all about it at this link, but here's a quick preview:

Standard Dialects in Prompto

Multiple "dialects" of the same language which can losslessly be translated into the other dialects:

// "Objy" OOP-like syntax
method main() {
    print("15 + 3.5");
    print("= 28.5");
}

and

// "Monty" Python-like syntax
def main(options:Text<:>):
    print("15 + 3.5")
    print("= 28.5")

and

// "Engly" English-like syntax
define main as method doing:
    print "15 + 3.5"
    print "= 28.5"

Ateji PX Parallel Blocks

Easily run operations in parallel with the [] delimiters and || separator:

public class HelloWorld {
  public static void main(String[] args) {
    [ System.out.println("Hello"); || System.out.println("World"); ]
  }
}

The above could print Hello followed by World or World followed by Hello, depending on the order in which the parallel blocks finish.

Also, parallel loops:

// increment an array
for||(int i : N) array[i]++; 

// sum all elements of the upper-left corner of matrix in parallel
int sum = `+ for|| (int i:N, int j:N, if i+j<N) matrix[i][j];

Implicit programming in Scala

The compiler can infer and automatically pass parameters based on type signatures, which is great, but can be dangerous! (With great power comes great something something...)

scala> "hey".exclaim()
<console>:12: error: value exclaim is not a member of String
       "hey".exclaim()
             ^

scala> implicit class Exclaimable (s: String) {
     |   def exclaim(): String = s + "!"
     | }
defined class Exclaimable

scala> "hey".exclaim()
res1: String = hey!

And that's just a taste! Check out the article and let me know what you think!

PRF is a Java-based framework that allows researchers to build prototypes of test-based generate-and-validate automatic program repair techniques for JVM languages by simply extending it with their patch generation plugins. The framework also provides other useful components for constructing automatic program repair tools, e.g., a fault localization component that provides spectrum-based fault localization information at different levels of granularity, a configurable and safe patch validation component that is 11+X faster than vanilla testing, and a customizable post-processing component to generate fix reports.

https://reddit.com/link/jlavrx/video/oplnoivegcw51/player

Many languages compile to the JVM, and we also have many static analysis frameworks that are capable of consuming JVM bytecodes as input. The question is, could we use the existing analysis infrastructure framework to analyze any kind of bytecode that these languages, other than Java, would generate? To know more about how we answered this question, watch our teaser video at https://youtu.be/uccHcxViubI (cc included) and the full video at https://youtu.be/bot2QnP0iOc (cc included).

https://reddit.com/link/jl6to5/video/3msi70nj6bw51/player

I want to do a lot with code, and I know python so I started Java since I can get better at OOP and I can use a language that is faster. I want to expand after Java, and I discovered JVM languages. By learning Java, is it easier to learn a JVM language? Are there any great ones?

Also, if anybody has a language tree which shows good languages to learn after learning other ones, that would be nice.

Thanks!

I often hear that the CLR is language neutral while the JVM was designed specifically for Java. Does this mean that it's easier to implement a language that targets the CLR as opposed to the JVM? If so, then what are some features of the CLR that make it more "language neutral" than the JVM? This is ignoring Graal, Truffle, and related technologies (https://en.wikipedia.org/wiki/GraalVM).

Is command scala both

• a REPL interpreter for Scala language and
• a non-REPL (java like) interpreter for JVM bytecode?

How is scala implemented? I saw scala is a shell script.

• When using as a non-REPL (java like) interpreter for JVM bytecode, is scala implemented as a wrapper around java and adding runtime packages to java's -cp option?
• When using as a REPL interpreter for Scala language, is scala implemented in term of scalac and java with runtime packages specified to -cp?

How is scala used? Does Scala official website have documentation for the option arguments of command scala, similar to the one https://docs.scala-lang.org/overviews/compiler-options/index.html for compiler scalac? I have been searching for a while but can't locate it.

Thanks.