Venkatesh-Prasad Ranganath rvprasad

## AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.example.dummy">

    <application
        android:label="@string/app_name"
        tools:targetApi="31"
        android:name=".MyApplication">
        <provider

## synchronized_collection_issue.jsh
Collection<Integer> ss = Collections.synchronizedSet(new HashSet<Integer>());
new Thread() {
  public void run() {
    for (int x = 0; x < 1000; x++) {
      ss.addAll(IntStream.range(x*1000, (x + 1)*1000)
          .boxed()
          .collect(Collectors.toList()));
    }
  }
}.start()

## update_packages_to_new_r_version.r
library(gtools)

installed <- c()

update <- function(p) {
  pd <- packageDescription(p, fields=c('Built'))
  pd <- gsub(";.*", "", pd)
  if (!is.na(pd) && pd != 'R 4.0.4') {  # mention the target versions here
    for (d in getDependencies(p)) {
      update(d)

## hostfile
localhost slots=9

## python_performance1.py
import random
import statistics
from timeit import default_timer as timer

def time_function(f, data):
    times = []
    for _ in range(0, 20):
        start = timer()
        f(data)
        times.append(timer() - start)

## modification_time_based_file_organizer.py
import argparse
import glob
import hashlib
import logging
import os
import pathlib
import re
import shutil
import sys
import time

## test_mulitprocessing_shared_memory.py
# Python -- v3.8

from multiprocessing import Process, Queue, managers
import time


def worker(id, data, queue, *args):
    tmp1 = time.time()
    if args:
        for i in range(args[0], args[1]):

## variance.kt
class Producer<out T: Any>(val e:T) {
  fun read(): T = e
}

class Consumer<in T: Any>() {
  private lateinit var e: T
  fun write(v: T): Unit { e = v }
}

fun main() {

## howManyLongsCanWeLoad.scala
import scala.collection.mutable.ArrayBuffer
import scala.util.Random

object M {
  def main(args: Array[String]) {
    val t = new ArrayBuffer[Long]()
    while (true) {
      t += Random.nextLong
      if (t.length % 10000 == 0) {
        System.gc()

## parallelStreamAndAsSequence.kts
import kotlin.streams.asSequence
import kotlin.system.measureTimeMillis

val k = 500000000L

println(measureTimeMillis {
    java.util.stream.LongStream.range(1, k)
    .parallel()
    .asSequence()
    .map { it.toString().length.toLong() }
	<?xml version="1.0" encoding="utf-8"?>
	<manifest xmlns:android="http://schemas.android.com/apk/res/android"
	xmlns:tools="http://schemas.android.com/tools"
	package="com.example.dummy">

	<application
	android:label="@string/app_name"
	tools:targetApi="31"
	android:name=".MyApplication">
	<provider
	Collection<Integer> ss = Collections.synchronizedSet(new HashSet<Integer>());
	new Thread() {
	public void run() {
	for (int x = 0; x < 1000; x++) {
	ss.addAll(IntStream.range(x1000, (x + 1)1000)
	.boxed()
	.collect(Collectors.toList()));
	}
	}
	}.start()
	library(gtools)

	installed <- c()

	update <- function(p) {
	pd <- packageDescription(p, fields=c('Built'))
	pd <- gsub(";.*", "", pd)
	if (!is.na(pd) && pd != 'R 4.0.4') { # mention the target versions here
	for (d in getDependencies(p)) {
	update(d)
	import random
	import statistics
	from timeit import default_timer as timer

	def time_function(f, data):
	times = []
	for _ in range(0, 20):
	start = timer()
	f(data)
	times.append(timer() - start)
	import argparse
	import glob
	import hashlib
	import logging
	import os
	import pathlib
	import re
	import shutil
	import sys
	import time
	# Python -- v3.8

	from multiprocessing import Process, Queue, managers
	import time


	def worker(id, data, queue, *args):
	tmp1 = time.time()
	if args:
	for i in range(args[0], args[1]):
	class Producer<out T: Any>(val e:T) {
	fun read(): T = e
	}

	class Consumer<in T: Any>() {
	private lateinit var e: T
	fun write(v: T): Unit { e = v }
	}

	fun main() {
	import scala.collection.mutable.ArrayBuffer
	import scala.util.Random

	object M {
	def main(args: Array[String]) {
	val t = new ArrayBuffer[Long]()
	while (true) {
	t += Random.nextLong
	if (t.length % 10000 == 0) {
	System.gc()
	import kotlin.streams.asSequence
	import kotlin.system.measureTimeMillis

	val k = 500000000L

	println(measureTimeMillis {
	java.util.stream.LongStream.range(1, k)
	.parallel()
	.asSequence()
	.map { it.toString().length.toLong() }