satendrakumar

import play.sbt.PlayRunHook
import sbt._
import java.net.InetSocketAddress

object Angular2 {
  def apply(log: Logger, base: File, target: File): PlayRunHook = {

    object Angular2Process extends PlayRunHook {

      private var watchProcess: Option[Process] = None

satendrakumar

import java.io._

object Loop1 extends App {
 //Java way 
  val inputStream: BufferedInputStream = new BufferedInputStream(new FileInputStream("input.csv"))
  val outputStream = new BufferedOutputStream(new FileOutputStream("output.csv"))
  val buffer = new Array[Byte](32 * 1024)
  var bytesRead: Int = inputStream.read(buffer)
  while (bytesRead > 0) {
    println("writing.......")

satendrakumar

object FoldLeft extends App {

  def reverse(list: List[Int]): List[Int] =
    list.foldLeft[List[Int]](Nil)((acc, element) => element :: acc)

  def dedupe(list: List[Int]): List[Int] = {
    list.foldLeft[List[Int]](Nil)((acc, element) => if (acc.contains(element)) acc else acc :+ element)
  }

satendrakumar

import java.io.{BufferedReader, File, InputStreamReader}
import javax.annotation.concurrent.NotThreadSafe

import org.apache.hadoop.io.{LongWritable, Text}
import org.apache.hadoop.mapred.{FileSplit, TextInputFormat}
import org.apache.spark.broadcast.Broadcast
import org.apache.spark.rdd.HadoopRDD
import org.apache.spark.{SparkConf, SparkContext}

@NotThreadSafe

satendrakumar

//Producer 
import java.util.Properties
import java.util.concurrent.Future

import org.apache.kafka.clients.producer.{ProducerRecord, RecordMetadata}
import org.apache.kafka.common.serialization.StringSerializer

satendrakumar

import org.apache.spark.sql.{DataFrame, SQLContext}
import org.apache.spark.{SparkConf, SparkContext}

case class Demo(id: Int, name: String, info: Map[String, String], inner: Inner)

case class Inner(firstName: String)

object ParquetReadWrite extends App {

satendrakumar

import javax.inject.Inject

import com.google.inject._

import scala.collection.JavaConversions._


object DemoApp extends App {

satendrakumar

  

def withRetry[T](retryCount: Int)(t: => T): T =
    try
      t
    catch {
      case NonFatal(th) =>
        th.printStackTrace()
        if (retryCount >= 0) {
          println("Retrying............... [remaining count: [${retryCount-1}`]")

satendrakumar

import play.api.libs.json._


object JsonFormatter {
  
 implicit val residentReads = Json.reads[Resident]
  
}

case class Resident(name: String, age: Int, role: Option[String])

satendrakumar

akka {
  actor {
    default-dispatcher {
    
      fork-join-executor {

        parallelism-factor = 8

        parallelism-min = 16