repack | based toolkit to build your React Native application | Frontend Framework library

Instead of operating on ij array, and convert its values to indices in source arrays, use dask to operate on the actual source arrays. It will be substantially faster.

I created source arrays as:

1. The source (Numpy) array to create x:

request.method is always upper-case.

You'll need

Look at this code:

That error is apparently coming from this line of code in the asar package's lib/filesystem.js:

Having many files open can be a heavy load on the disk operating system, the number of file handles (limited!), and "moving the write head around" should one do things concurrently.

About the statics

The code shows experience (also concerning Java), maybe also from a language like C. Because the use of static is unusual. you could in main do a new Main().executeMyThings(); and drop static elsewhere.

Measures to take

• Do not use text but binary data, not Writer/Reader, but OutputStream/InputStream. This prevent a Unicode conversion back and forth. Also you risk data loss, when a Windows UTF-8 file on Linux.

• Use ArrayList rather LinkedList as for many items it is likely to behave better.

• You might want to collect file paths instead of BufferedWriters. Every BufferedWriter is not only a OS resource, but maintains a buffer (memory). It might even be more performant, writing the head line, closing and reopening it in append mode. The headline could be written be with Files.writeString.

• System.out is costly. A ConsoleLogger might be safer would be safer with concurrency, but costs too.

• readByteSize misses the line break, 2 for Windows files.

• A BufferedWriter can be created with a larger/smaller buffer size.

I ended up using the exec-maven-plugin and Java jar utility to add the UI files. See code below (the ui files are in the /tmp/resources directory):

RFC tutorial on RTP / RTCP protocol seems very confusing to me. I cannot find any state transition diagram for this protocol like this.

That protocol is media-oriented like RTSP ; the signaling protocol is responsible of state transition handling look at the couple SIP/RTP.

It doesn't clear the difference between NTP and RTP Timestamp. It says it is useful for calculating round trip time.

RTP Timestamp is used for intra-flow synchronization and NTP reference for inter-flows synchronization.

Can't it be calculated with the RTP timestamp alone?

Yes, NTP is used when several flows need to be synchronized but if there is only one flow then RTP timestamp is enough. In summary, an rtp audio cmmunication does not need NTP but a rtp audio+video communication needs NTP in order to do lips-synch.

The source will send a SR Report if and only if it recently sent a RTP packet otherwise it's a RR packet. How much the time interval is it actually to determine that if the sender has sent a packet recently?

This is related to the 5% overhead: The control traffic bandwidth is in addition to the session bandwidth for the data traffic. It is RECOMMENDED that the fraction of the session bandwidth added for RTCP be fixed at 5%.

what does the mixer do exactly? Does it take all the RTP packets coming from multiple sources and then at the application layer read it and repack them to multiple RTP packets with only SSRC being changed now? what if the packets type are different

A mixer is quite complex but in essence you get it right, multiple flows are decoded and re-encoded to one flow ; so the mixer must be able to manage codec stuff inside payload if packets type are different.

I have taken some time to parse your code.

In the large function, you use s3fs to interact with your cloud storage, and this works well with xarray.

However, in your main code, you use boto3 to list and open S3 files. These files retain a reference to the client object, which maintains a connection pool. That is the thing that cannot be pickled.

s3fs is designed to work with Dask, and ensures the picklebility of the filesystem instances and OpenFile objects. Since you already use it in one part, I would recommend using s3fs throughout (but I am, of course biased, since I am the main author).

Alternatively, you could pass just the file names (as strings), and not open anything until within the worker function. This would be "best practice" - you should load data in worker tasks, rather than loading in the client and passing the data.

OLD VERSION:

At this moment I found only .re(".+") to get all (more or less) as list