@leonid Is it possible to push nightly build of io-2 to some repository? I want to play around with it in experimental branch of the project. but if I just build it locally, I can't attach it as dependency. Also I do not know, how stable is the branch.

@leonid I got really tired of bugs in old IO, so I've forked it and deplyed in our work repository. So I am now rewriting our code using io-2 and I have some comments already.

Bytes

interface provides input by

input

method. The problem is that it could leak an Input that could survive closing of parent

Bytes

and will be invalid. I propose to replace it with consumer function like described here: https://github.com/Kotlin/kotlinx-io/issues/71 Also

Bytes

has

size

function. I can't see a way to change size after creation, so I propose to change it to value and use

lazy

delegate to compute it on first call.

I have been poking io-2 for some time and I came to conclusion that sooner or later we will need to introduce suspension into it in orde to read and write dynamic inputs and outputs like inputstreams and channels. So we have two solutions: either wrap everything in callbacks and then introduce binding to coroutines or make all read and write operations suspendable from the start. The actual suspension will be done during buffer fetch/flush, so it should not affect performance much. So far I think that making everything suspendable looks better.

If I implement Input, I need to fill Buffer. What are guarantees about Buffer state. Do I need to flip it? Can I use it from start or I need to respect current position?

@Oleg Yukhnevich we just had a discussion about using rsockets for distributed control systems in #science. Multiplatform version looks promising. I can't take another project right now, but please fill free to ask questions here. I have some experience with io, coroutines and multiplatform.

@Vsevolod Tolstopyatov [JB] Hi, may be you can share some info about some release dates of 0.2 version? at least, month, two, or half a year? before/after kotlin 1.4?

We played a bit with my IO fork and it does not seem to work as well as expected (at least @Zelenyi regularily finds some failing test cases). I like the API, but the problem is that

Bytes

is not a suted to be a temporary data container due to its volatility. I still do want to be able to copy part of input to a temporary storage object which later could be read from as Input and written to output as a whole. We can certainly do it via

ByteArray

, but it means additional copy on any such operation. Instead I am thinking about following thing: we can add additional Binary reading operation into `Input`: By default it reads byte array of given length, but when read from a random-access entity like file or

ByteArray

it is overwritten by method that does not copy array, but instead creates a

Binary

which references initial structure and holds offset and size. Thus it could be read and written without additional copy.

Is there a plan to support `inotify`/`FindFirstChangeNotification` in kotlinx.io?

So I noticed

Buffer

now uses a

ByteArray

instead of

CPointer<ByteVar>

. Is

<http://kotlinx.io|kotlinx.io>

still going to provide an abstraction for off-heap memory or should I be looking into implementing my own?

Hi, how do we access

<http://kotlinx.io|kotlinx.io>

from a

commonMain

sourceset in a MPP project?

is the planned

sockets

module going to be async? If so, is it planned for these async sockets to support TCP/IP backpressure via suspending functions?

@e5l I will need to revisit IO soon and will try to bring my fork more in direction of primary repository. Ther is still one important question about usage of

Bytes

though. Will it be possible to use bytes for multi-read operations? The major problem for me so far was that once input is called on

Bytes

, it becomes invalid. If this is still the case, I will still need to introduce

Binary

for lazy multi-read and I think that the API should be somehow changed to avoid rereading

Bytes

object.

Hi! I realise ktor doesn't need

<http://kotlinx.io|kotlinx.io>

anymore and there's an

io-2

going to be published soon, but can we get one more version of the original

kotlinx-io

for 1.3.70?

I realize this is a bit far off, but I think this would be of value for people to see. Async/IO for native might be trivialized some if we bind to libevent https://github.com/libevent/libevent

Has anyone been able to use jitpack to get this since there aren't any io-2 builds?

Since it's planned for

Bytes

to go internal, do we plan to have any equivalent to

ByteString

from okio? Input doesn't seem to entirely fit the bill

@e5l There is a request for native flavor of IO library. It seems like appropriate targets are not generated unless

idea.active

flag is set in the system. Could you explain what does it mean?

So, is this library going to go into development again soon? I believe one of the main things holding it up was the serialization library work, which has now reached full 1.0 release. The io library got mentioned (very briefly) during the 1.4 event, so I know it isn't forgotten.

Is it alive? https://github.com/Kotlin/kotlinx-io

@e5l I am tired of tryitng to support my kotlinx-io fork, so I am trying to migrate to ktor-io. Some things are uggly but manageable, but I've just spent almost the whold day with the following problem: it seems that

readBytes

method does not actually advance the input read pointer. Is it intentional?

Hi I started a small Pr to update the project dependencies to the kotlin version 1.5.30. I am only having a few question, regarding errors that came up with Annotations - I leave them below this thread 🙂

Sorry if that has been asked before but is there an mpp version of a ByteBuffer? or is it just using Bytechannel ?

Hi all! I observe a lot of fragmentation and duplication of effort around buffers. As there is no standard APIs for multiplatform buffers, you have to do a lot of work if you want to share a buffer across a stack of libraries. For instance, one of my use-cases is to: (1) receive a packet from a

ktor-network

socket, (2) parse a message using

google-flatbuffers

which contains a packed scalar array, (3) that is itself fed to

multik

to make a multi-dimensional array of it. Along all this processing line, it is possible to have a single byte array backing multiple buffers and not have to copy any bytes. However, it is a lot of work currently because there is no standard buffer API. For instance,

google-flatbuffers

is defining their own Buffer API to support this no-copy principle: https://github.com/google/flatbuffers/blob/master/kotlin/flatbuffers-kotlin/src/commonMain/kotlin/com/google/flatbuffers/kotlin/Buffers.kt In the above-mentioned use-case for instance, I have to implement my own

com.google.flatbuffers.kotlin.ReadBuffer

above `ktor-io`'s

<http://io.ktor.utils.io|io.ktor.utils.io>.core.ByteReadPacket

, etc Isn't it time that people from Okio, Ktor and others get together to define a standard Buffer API and revive

kotlinx-io

?? (Sorry for the kinda rant but it is a little irritating...)