My project is split up into multiple packages that...

# getting-started

[Ray Rahke]

My project is split up into multiple packages that I import into main. Pressing play in intellij runs my project, but when I manually do kotlinc Main.kt -include-runtime -d out.jar && java -jar out.jar, I get unresolved errors about my package imports.

[hfhbd]

Well, it depends on the error message you didn’t mention. If you get ClassNotFoundExceptions during runtime it’s because you didn’t add the classpath to the java call.

[Ray Rahke]

error: unresolved reference: mysubmodule
import mysubmodule

[hfhbd]

And IMHO you should not fight against the main conventions of the ecosystem. This makes everything harder.

[Ray Rahke]

that is hard when the conventions extend to being forced into a specific IDE that I dislike

[hfhbd]

Then you might need to add the jars/files to kotlinc.

[Ray Rahke]

and currently, all we're trying to do is run code, from the command line

[Ray Rahke]

is the convention in JVM/Kotlin to be so dependent on GUI tooling that running code without clicking big shiny icons is tricky to get working?

[hfhbd]

Gradle isn’t forced to a specific IDE, build servers don’t need an IDE ;)

[Ray Rahke]

But just having a normal development workflow, where I write code, execute it, test it, repeat, etc.

[Ray Rahke]

most of the guides I find online say "click this button in intellij"

[hfhbd]

I never use IntelliJs buttons but Gradle 🤷🏻‍♂️ and properly almost many users here too.

[Ray Rahke]

Then you might need to add the jars/files to kotlinc. (edited)

could you clarify what you mean by this.
I have this structure
src/
main.kt
foo/
A.kt
B.kt

[Ray Rahke]

in main, i do

import foo.A

fun main() {
  A()
}

[Ray Rahke]

(omitting the package declarations)

[Ray Rahke]

https://discuss.kotlinlang.org/t/kotlin-compiler-cannot-find-imports/2243/10

[hfhbd]

https://kotlinlang.org/docs/compiler-reference.html#classpath-path-cp-path

[Ray Rahke]

what would I put there

[Ray Rahke]

I obviously cannot explicitly enumerate my packages

[Ray Rahke]

my codebase is a pyramid of dozens of packages

[Ray Rahke]

i assume it can just recursively resolve imports

[Ray Rahke]

like all other languages

[Ray Rahke]

sudo kotlinc src -include-runtime -d out.jar && java -jar outjar
Error: Unable to access jarfile outjar

[Ray Rahke]

https://stackoverflow.com/questions/70726114/kotlinc-compile-multiple-files-dependencies-imports

[Ray Rahke]

this is my problem

[Ray Rahke]

both answers look equally useless though

[Ray Rahke]

one of the answers just says to do -cp main.jar:package_a
...but that is for a single package.

[Ray Rahke]

why does the big play button in intellij not require this

[Ray Rahke]

it intelligently resolves imports recursively.

[Joffrey]

> I obviously cannot explicitly enumerate my packages
In the JVM world you pass all your sources to the compiler, yes. Imports are not used for dependency resolution, they are used as a convenient syntax to avoid using qualified names

[Ray Rahke]

but the play button doesn't do that..

[Joffrey]

but the play button doesn't do that..

What do you mean?

[hfhbd]

It does under the hood

[Ray Rahke]

so why isn't there a command line utility that does that under the hood

[hfhbd]

You just invented a build tool like Maven or Gradle.

[Joffrey]

IntelliJ calls the Kotlin compiler with all your source files depending on how you configured it. If you use Gradle, then IntelliJ will know the source directories from the Gradle source sets configuration

[Ray Rahke]

i am using gradle right now

[Ray Rahke]

is there a gradle command i need to do

[hfhbd]

./gradlew :compileKotlin

[hfhbd]

or just ./gradlew assemble

[Ray Rahke]

after doing ./gradlew assemble, where does the jar go

[Ray Rahke]

trying to run it now

[Joffrey]

i assume it can just recursively resolve imports like all other languages

That's not how most JVM languages work, btw

[hfhbd]

build/libs/name.jar

[Ray Rahke]

just, in software, you modularize your code into sub folders with sub folders etc. that are all eventually imported back up into main where you run your code

[Ray Rahke]

i go python main.py, and it triggers that cascade of imports

[Ray Rahke]

or npm run dev

[Ray Rahke]

or rust run (i forget)

[hfhbd]

npm is also a build tool.

[Ray Rahke]

all i'm conveying is that when you execute a top-level file like main.whatever, and main.whatever references other files, some mechanism resolves those

[Ray Rahke]

npm run dev just triggers node runtime typically

[Ray Rahke]

image.png

[Ray Rahke]

java -jar build/libs/kts.jar                                                                                    
no main manifest attribute, in build/libs/kts.jar

[Ray Rahke]

(sorry for naming the project kts. it is not a .kts project)

[Joffrey]

all i'm conveying is that when you execute a top-level file like main.whatever, and main.whatever references other files, some mechanism resolves those

You don't execute a source file. You compile a set of source files, then you execute compiled files/classes/jars. In the JVM world, you can compile multiple parts independently. So you need to tell the compiler which files you're compiling together, and which dependencies need to be available to them.

Your examples are about running the app, which is different. And actually Python and JS are not compiled, so you can't really compare that to a compilation. Rust uses cargo as a build tool, so if you're comparing with this you should compare with Gradle commands, and you get pretty much the same convenience

[Ray Rahke]

im fine using a gradle command to compile and run the code

[hfhbd]

Yes, you need to specify the entry point. When running with the IntelliJ button, IntelliJ sets it for you.

[Ray Rahke]

so then something like

manifest {
    attributes["Main-Class"] = "MainKt"
}

[Ray Rahke]

?

[Joffrey]

To do that, use the application plugin in Gradle, so it knows it's not a library but an application you can run. You don't need to manually set manifest entries, Gradle will do it for you.

https://kotlinlang.org/docs/get-started-with-jvm-gradle-project.html#explore-the-build-script

plugins {
    kotlin("jvm") version "1.9.23"
    application
}

application {
    mainClass.set("MainKt") // The main class of the application
}

[hfhbd]

application.mainClass.set("MainKt")

[Joffrey]

I agree that it's annoying that the tutorial goes through IntelliJ, it gives a false sense that IntelliJ is necessary. I think it was made in an attempt to simplify the project initialization for beginners, but for users like you it seems counter productive

[hfhbd]

and if you want to run the jar without calling java, use ./gradlew run

[hfhbd]

and for tests ./gradlew test

[Joffrey]

Yep, all you really need for a JVM CLI application is a build.gradle.kts with:

plugins {
    kotlin("jvm") version "1.9.23"
    application
}

repositories {
    mavenCentral()
}

application {
    mainClass.set("MainKt")
}

Then place your source files in src/main/kotlin, with one of them called Main.kt with the main function.

Then you can compile and run your app using ./gradlew run. If you just want compilation or test you can run other Gradle tasks.

[Ray Rahke]

How can I change the folder structure target.
I have src/main.kt, not src/main/kotllin/Main.kt

[Ray Rahke]

plugins {
    kotlin("jvm") version "1.9.23"
    application
}
repositories {
    mavenCentral()
}
application {
    mainClass.set("MainKt")
}
dependencies {
    testImplementation(kotlin("test"))
}
sourceSets {
    main {
        kotlin.srcDirs("src/")
    }
    test {
        kotlin.srcDirs("test/")
    }
}

[Joffrey]

Yeah if you want to stray away from conventions, you're going to have to add more config in your Gradle build script. And I think you got it right, here

[Ray Rahke]

/gradlew run                                                                                                    3.66s
> Task :run FAILED
Error: Could not find or load main class MainKt
Caused by: java.lang.ClassNotFoundException: MainKt

FAILURE: Build failed with an exception.

[Ray Rahke]

main.kt

package <http://org.me|org.me>

import mod.Foo

fun main() {
    Foo()
}

[Joffrey]

You have a package <http://org.me|org.me> at the top, so your main class is not just MainKt but org.me.MainKt

[Ray Rahke]

great, all working now. thanks a lot

[Ray Rahke]

is it good practice to do package org.me at the top of main.kt?

[Joffrey]

Yeah it's often the case to have all your sources under at least some top level package name (usually a reverse domain name that you own). But it's not mandatory.

[Ray Rahke]

gotcha.

I apologies for my posts recently coming off abrasive. just not used to this setup / run process all being so difficult coming from primarily scripting languages, and have been struggling with actually getting to do anything with this language for days now so feeling exhausted. thanks for helping

[hfhbd]

You are welcome. BTW do you need a trailing slash in srcDirs?

[Ray Rahke]

I assumed it was necessary to indicate a folder vs file

[Joffrey]

Thanks for saying this, really appreciated. I'm happy to help. Note that you can avoid a part of this frustration if you try to follow more the conventions of the tools rather than tweak them to match the conventions you're used to from other ecosystems.

[Joffrey]

That said, I have to admit that Gradle can be intimidating when you're starting. We're trying to address that with Amper.