Running 100 virtual devices (5Hz event rate) with SCADA event bus together with visualization service on almost zero CPU and less than 500 Mb RAM? Achievement unlocked today with Controls-kt.

Hello, everybody! The first public preview of the experimental Kotlin Notebook plugin for IntelliJ IDEA is finally available! Now you can explore, prototype, visualize, and document your code – all in the same environment. Please check out the blog post for full details: https://blog.jetbrains.com/kotlin/2023/07/introducing-kotlin-notebook/ Join the #notebooks channel for staying in touch! Thread in Slack Conversation

@Ilya Muradyan does notebook kernel do any magic with the classpath? For some reason, I can't access ktor server package. The CIO Jar is properly added to the classpath, but I can't access it.

there is currently an ongoing discussion in the scijava ecosystem about which solution to target for the next dev cycle (JVM, Python, JavScript and WebAssembly). GraalVM, Kotlin Multiplatform, Rust or Julia I'm obviously rooting for Kotlin, but if someone more expert (I'm looking at you, @altavir, for example) wanna jump in, he's more than welcome to do it

Personally, I think this is a golden chance to get Kotlin into the Scijava community

An important announcement about KScience projects. Since 2019 we were hosting our projects in a JetBrains Space instance. Sadly, we were notified that we can no longer use it after September 15 because our team association with MIPT, which is under USA sanctions (though our projects are fully open source and not associated with MIPT in any way). It means a lot of additional work on infrastructure for us, but more importantly it means a disruption of supply chain for our projects. For example development artifacts were hosted in Space. We will work on replacing our tooling with simpler instruments, but it will take time. Also we do not have any funding for our projects, so we will have to prioritize other work. So, here is the summary: • Development builds (I mean maven repositories) for Plotly-kt, KMath, VisionForge, DataForge-core, Controls-kt and other projects could stop working. We will restore them in a new repository, but it will take time. • Github projects are still mirrored to https://github.com/SciProgCentre. The primary repository is at https://git.sciprog.center/kscience. Gitea does not support two-side mirroring. So there could be hiccups with synchronization. • Issue tracking will be gradually moved to https://sciprog.center/youtrack/issues/KS?u=1 (YouTrack license is frozen as well, but we have a stand-alone version). If by any chance there are people, who want to support KScience infrastructure (with all sponsor benefits), please contact me.

Kandy: the new Kotlin plotting library by JetBrains | The Kotlin Blog We are excited to introduce Kandy, a new Kotlin plotting library by JetBrains. It provides a new, powerful DSL for creating charts of various kinds. The first public preview version is ready for you t

The latest dev version of plotly-kt includes a Compose-Desktop example: https://github.com/SciProgCentre/plotly.kt/tree/master/examples/compose-demo. Sadly, CEF component is still bugged as hell. If anybody wants to fix CEF integration, MRs are welcome.

I'm porting to kotlin this code

snap_descriptors_np = extract_compute_np(
    lmp,
    "bgrid",
    0,
    2,
    (nz, ny, nx, self.fingerprint_length),
    use_fp64=use_fp64,
)
lmp.close()

# switch from x-fastest to z-fastest order (swaps 0th and 2nd dimension)
snap_descriptors_np = snap_descriptors_np.transpose([2, 1, 0, 3])

where

extract_compute_np

returns a flat doubleArray representing an ndarray of

[nz, ny, nx, self.fingerprint_length]

now, I have to swap the 0 and 2nd dimensions and I'm trying to do this:

Array(nx) { x ->
    Array(ny) { y ->
        Array(nz) { z ->
            val ofsX = x * (ny * nz * fingerprintLength)
            val ofsY = y * (nz * fingerprintLength)
            val ofsZ = z * fingerprintLength
            DoubleArray(fingerprintLength) { doubles[ofsX + ofsY + ofsZ + it] }
        }
    }
}

but it looks like it's wrong, anyone spots the problem?

We made a molecular dynamics simulations package, that works like a meta framework on top of applications like lamps. It's called moleKule and it's available to work with right now. I'm actually looking for some collaboration to help us make it better and bigger. Https://GitHub.com/independent-society-of-knowledge/MoleKule

Does Kmath have a documentation team or is there a solid plan for documenting the code?

@Amir H. Ebrahimnezhad you mentioned CERN data, we put a lot of effort to create an interface to CERN ROOT.

As for molecule dynamics. I will look into the code later, but it is a great Idea. I have plans to implement some generic physics extension like units of measure (there is Measured - https://github.com/nacular/measured library, but I want something more specific). We currently create some of those extensions inside Controls-kt since we work on integrating physics simulations into device controls.

@altavir Yea that's one of main things I want to get from that binder we talked about.

CERN ROOT interop is a major issue. We have working prototype that is already working in NICA accelerator at Dubna (together with https://github.com/SciProgCentre/visionforge visualization).

Where's the problem?

It is just a quite poorly designed format. The only project that managed to read it at least partially is Uproot.

When binding to native libraries one can also use https://github.com/whyoleg/ffi-kotlin by @Oleg Yukhnevich. I have not tried it myself, but it should simplify things a lot.

We have used Jextract, Java Native Access and Kpoet for that project.

# Here's a simple example provided for MoleKule, a package for molecular dynamics!

fun main() {

    // a basket for your atoms
    val env = Environment()

    // add to it like any of these methods
    env.add(atomOf(AtomicMass.C, Point(0, 0, 0), 1))
    env.add(H2(Point.randomOrientation * 10))

    // use sequence api to your advantage, or reinvent them yourselves
    Grid3D(20, 20, 20)
        .points
        .map { it * 1.5 } // scale
//        .map { it.rotateZ(45.toRad()) } // rotate
        .map { it + (Point.xHat * 12) } // translate
        .filter { it isInside sphereShape  } // filter
        .map { atomOf(AtomicMass.C, it,1) } // generate
        .forEach { env.add(it) } // add


    
    env.toLammpsInputFile("Hello.data")
    // visualize a bit, it helps
    KoolVisualizer()
        .withDefaultConfig()
        .addPlugin(AxisPlugin())
        .addPlugin(BoxViewerPlugin(env.enclosingBox))
        .init()
        .addEnvironment(env)
        .runAndWaitUntilExit()

}

val sphereShape = Sphere(Point(22,12,12), 10)


class H2(origin: Point) : Molecule(type = 3) {
    init {
        val eps = Point.xHat * 0.3
        val h1 = Atom(origin - eps, AtomicMass.H.mass, 4)
        val h2 = Atom(origin + eps, AtomicMass.H.mass, 4)
        atoms.addAll(listOf(h1, h2))

        // bonds.add()
    }
}

https://doi.org/10.1134/S1547477124701358 Kotlin-multiplatform goes for big science.

@altavir Have you developed anything regarding diagram generation in particle physics?

Is it even good to do so? I'm planning to make things along the way of my project at university

VisionForge has a lot of experimental places in terms of API, but it is pretty stable in terms of its work.

@Serhii Terentiev brought to me a nice scientific project in Kotlin: https://github.com/milaboratory/mixcr. If I am not mistaken, @Bolotin Dmitriy is one of the main contributors. At least the one I could find by github userpics. Nice work.

DataForge version 0.10.0 has been released: https://git.sciprog.center/kscience/dataforge-core/releases/tag/v0.10.0 It is not used a lot outside SPC projects so it probably is not that interesting. But it is important stepping stone for next VisionForge release, that also includes Plotly-kt release.

@Adrian Trapletti I had to make a fork of https://github.com/atraplet/clarabel4j to back-port it for Java 21 since our deployment environment does not allow non-LTS JVM. It is currently private, but if there is some interest, I can make it public in future. In therory, we can do something like multi-release jar, but I am not sure it worth the effort.

@Adrian Trapletti Have you tried to interface directly with Rust code with https://gitlab.com/trixnity/uniffi-kotlin-multiplatform-bindings? I have not tried it myself. But one of my guys tried and he said it works perfectly.

📈 VisionForge version [0.5.0 is released](https://github.com/SciProgCentre/visionforge/releases/tag/v0.5.0) and available both on https://repo.kotlin.link and maven-central. There are not a lot of new features, but it is a huge release in terms of inner logic refactoring and simplification. It will allow faster and simpler development in future. The major external change is that [Plotly-kt](https://github.com/SciProgCentre/plotly.kt) is now part of [VisionForge](https://github.com/SciProgCentre/visionforge/tree/master/plotly-kt). Plotly plot is now inherits

Vision

class from VisionForge and Plotly-kt server uses

VisionForge

server mechanics. The package is chanced from

plotlykt-...

to

plotly-kt-...

and version now follows VisionForge versioninng. Meaning that from

space.kscience:plotlykt-core:0.7.2

we are going to

space.kscience:plotly-kt-core:0.5.0

. Notebook versions are still not fully functional because Notebooks do not work properly with Kotlin 2.x. It will be fixed in the future (as soon it is fixed in notebook kernel).