xacid: (Default)
вот както пообщаешся например даже на собеседовании с коллегой-программистом и даже если вердикт не в пользу то все равно остается какое-то позитивное ощущения - хотя бы что нибудь новое узнаешь например

но как только с менеджером каким нибудь поговоришь - всегда как правило остается какоето ощущение чего то неприятного и даже гадкого как будто испачкался

причем издалека пока смотришь на этих клоунов - вроде бы все взрослые и даже серьезные люди - но как только поближе увидишь их (при общении непосредственном) всегда обычно недоумение в результате - что блин за детский сад, вечно какие-то обиды, подозрения, лицемерие и тому подобная подростковая психопатия

я видел конечно и исключения (редкие впрочем) - и адекватных менеджеров и наоборот неадекватных программистов но общее правило вот какое-то такое по опыту

причем как правило у всех этих менеджеров итоговый результат (опять таки за редким исключением) всегда один и тот же - все полимеры просраны полностью

вот просто даже интересно уже становится - кто им вообще верит и доверяет чтото делать? вот как их на профпригодность отбирают? похоже что никак не отбирают ...
xacid: (Default)
В моей жизни сегодня случилось наверное одно из самых страшных событий - умерла мама, самый близкий человек.
xacid: (Default)
разобрал его на части смазал снова собрал - поскрипывает но таки работает
получилось так - сделал ему три самопальных простых до ужаса zero-copy rdd
первая читает что надо откуда надо вторая нарезает чанки
третья разбирает записи на кусочки и собирает в паркет
без чанков в паркет загнать ну никак нельзя
зафорычил - удалось его заставить проглотить чанки в полмиллиона записей
на миллионе давится - но это у меня хип нельзя больше 8 гигов сделать - просто нету рамы больше
для начала имхо пойдет в продакшен

да, и что характерно - традиционно ниодна сраная мутабельная операция и даже переменная не возникла
xacid: (Default)
дивиться шо кляти москали називають нашою лямбдою

http://lambda-architecture.net

спарк

Feb. 6th, 2017 11:46 pm
xacid: (Default)
даю на работе спарку стрим чтобы он его в паркет загнал
а он гад (спарк) читает его ВЕСЬ в память в массив чтобы РАСПАРАЛЛЕЛИТЬ

Fact

Feb. 1st, 2017 12:53 am
xacid: (Default)
Read more... )

  val main = "(x -> y -> z -> y * ( x + y * z))"
  println(showAndEval(main, 1, 2, 10))

  val fact =
    """
      | let
      |   fact = x ->
      |     if(x)
      |       x * (fact (x - 1))
      |     else 1
      | in fact 20
    """.stripMargin

  println(showAndEval(fact))
}

//Success(( x -> y -> z -> y * ( x + y * z ) ) 1 2 10 = 42)
//Success(let fact = x -> if(x) x * ( fact ( x - 1 ) ) else 1 in fact 20  = 2432902008176640000)

Sympl

Jan. 26th, 2017 03:15 am
xacid: (Default)
Read more... )
  trait ExprAst[F[_]] extends Expr[F ~> Id] {
    def alg[A](f: F[A]): Expr[A]
    object ExprAst {
      type Ast = F ~> Id
      case class Oper(a: Ast, f: String, b: Ast) extends Ast {
        def apply[A](fa: F[A]): Id[A] = alg(fa).oper(a(fa), f, b(fa))
      }
      case class Parens(a: Ast) extends Ast {
        def apply[A](fa: F[A]): Id[A] = alg(fa).parens(a(fa))
      }
    }
    import ExprAst._
    def parens(a: Ast): Ast = Parens(a)
    def oper(a: Ast, f: String, b: Ast): Ast = (a, f) match {
      case (Oper(a1, op1@("+" | "-"), b1), op2@("*" | "/")) =>
        oper(a1, op1, oper(b1, op2, b))
      case _ => Oper(a, f, b)
    }
  }

  trait ExprParser[F[_]] extends ExprAst[F] with AParser {
    self: Parser =>
    import ExprAst._
    def operChar = CharPredicate('~', '!', '@', '#', '$', '%',
      'ˆ', '&', '*', '-', '+', '/', '?', '<', '>', ':', '.', ',')
    def Parens(p: => Rule1[Ast]): Rule1[Ast] =
      rule('(' ~ sp ~ p ~ sp ~ ')' ~> (parens _))
    def Oper: Rule1[String] = rule(atomic(capture(operChar.+)))
    def Expr: Rule1[Ast] = rule(Operand ~
      oneOrMore(sp ~ Oper ~ sp ~ Operand ~> (oper _)))
    def Operand: Rule1[Ast]
  }
Read more... )
xacid: (Default)
import org.parboiled2._

object Tagless extends scala.App {

  trait Term[T] {
    def ref(n: String): T
    def lam(n: String, t: T): T
    def app(f: T, a: T): T
  }

  trait Expr[T] {
    def oper(a: T, f: String, b: T): T
    def parens(a: T): T
  }

  trait Literal[T] {
    def int(i: Int): T
  }

Read more... )
  type Id[A] = A

  trait ~>[F[_], G[_]] {
    def apply[A](fa: F[A]): G[A]
  }

  trait FTerm[F[_]] extends Term[F ~> Id] {
    def alg[A](f: F[A]): Term[A]
    def ref(n: String) =
      Lambda[F ~> Id](alg(_).ref(n))
    def lam(n: String, t: F ~> Id) =
      Lambda[F ~> Id](x => alg(x).lam(n, t(x)))
    def app(f: F ~> Id, a: F ~> Id) =
      Lambda[F ~> Id](x => alg(x).app(f(x), a(x)))
  }

  trait FExpr[F[_]] extends Expr[F ~> Id] {
    def alg[A](f: F[A]): Expr[A]
    def oper(a: ~>[F, Id], f: String, b: ~>[F, Id]) =
      Lambda[F ~> Id](x => alg(x).oper(a(x), f, b(x)))
    def parens(a: ~>[F, Id]): ~>[F, Id] =
      Lambda[F ~> Id](x => alg(x).parens(a(x)))
  }

  trait FLiteral[F[_]] extends Literal[F ~> Id] {
    def alg[A](f: F[A]): Literal[A]
    def int(i: Int) = Lambda[F ~> Id](alg(_).int(i))
  }

  trait FSym extends FTerm[Sym]
    with FExpr[Sym] with FLiteral[Sym] {
    def alg[A](f: Sym[A]): Sym[A] = f
  }

  type SymAst = Sym ~> Id

  case class FSymParser(input: ParserInput)
    extends Parser with FSym with SymParser[SymAst]
Read more... )
  val main = "(x -> y -> z -> y * ( y * z + x))"
  val answer = parser(main)

  println(answer.map(ShowSym(_)))
  println(answer.map(SymVM(_, 1, 2, 10)))

  println(parser(main + " 1 2 10").map(x =>
    ShowSym(x) + " = " + SymVM(x)))

}
xacid: (Default)
import org.parboiled2._

object Tagless extends scala.App {

  trait SpParser {
    self: Parser =>
    def sp: Rule0 = rule(quiet(zeroOrMore(' ')))
  }

  trait Forall[F[_]] {
    def apply[T: F]: T
  }

  trait Term[T] {
    def ref(n: String): T
    def lam(n: String, t: T): T
    def app(f: T, a: T): T
  }

  trait TermParser[T] extends Term[T] with SpParser {
    self: Parser =>
    import CharPredicate._
    def Name: Rule1[String] = rule(atomic(capture(Alpha ~ (AlphaNum).*)))
    def Term: Rule1[T] = rule(App | NonApp)
    def App: Rule1[T] = rule(NonApp ~ oneOrMore(' ' ~ sp ~ NonApp ~> (app _)))
    def NonApp: Rule1[T] = rule(Lam | Ref)
    def Lam: Rule1[T] = rule(Name ~ sp ~ "->" ~ sp ~ Term ~> (lam _))
    def Ref: Rule1[T] = rule(Name ~> (ref _))
  }

  trait ATerm[F[_] <: Term[_]] extends Term[Forall[F]] {
    def forall[T: F]: Term[T]
    def ref(n: String): Forall[F] = new Forall[F] {
      def apply[T: F]: T = forall[T].ref(n)
    }
    def lam(n: String, t: Forall[F]): Forall[F] = new Forall[F] {
      def apply[T: F]: T = forall[T].lam(n, t[T])
    }
    def app(f: Forall[F], a: Forall[F]): Forall[F] = new Forall[F] {
      def apply[T: F]: T = forall[T].app(f[T], a[T])
    }
  }

Read more... )
  val main = "(x -> y -> z -> y * ( y * z + x))"
  val answer = parser(main)

  println(answer.map(ShowSym(_)))
  println(answer.map(SymVM(_, 1, 2, 10)))

  println(parser(main + " 1 2 10").map(x =>
    ShowSym(x) + " = " + SymVM(x)))

}

Simple

Jan. 20th, 2017 12:41 am
xacid: (Default)
import org.parboiled2._

object Simple extends App {

  trait LambdaCalculus[T] {
    def ref(n: String): T
    def lam(n: String, t: T): T
    def app(f: T, a: T): T
  }

  trait Expr[T] {
    def oper(a: T, f: String, b: T): T
    def parens(a: T): T
  }

  trait Literals[T] {
    def int(i: Int): T
  }

  trait Sym[T] extends LambdaCalculus[T]
    with Expr[T] with Literals[T]

  trait Ast {
    def apply[T: Sym]: T
  }

  trait SymAst extends Sym[Ast] {
    import Ast._

    def ref(n: String): Ast = Ref(n)
    def lam(n: String, t: Ast): Ast = Lam(n, t)
    def app(f: Ast, a: Ast): Ast = App(f, a)
    def oper(a: Ast, f: String, b: Ast): Ast = Oper(a, f, b)
    def parens(a: Ast): Ast = Parens(a)
    def int(i: Int): Ast = IntV(i)
  }
Read more... )

  val main = "(x -> y -> z -> y * ( x + y * z))"
  val answer = parser(main)

  println(answer.map(ShowSym(_)))
  println(answer.map(SymVM(_, 1, 2, 10)))

  println(parser(main + " 1 2 10").map(x =>
    ShowSym(x) + " = " + SymVM(x)))

}

Profile

xacid: (Default)
xacid

August 2017

S M T W T F S
  123 45
67891011 12
13 141516171819
20212223242526
2728293031  

Syndicate

RSS Atom

Most Popular Tags

Style Credit

Expand Cut Tags

No cut tags
Page generated Sep. 19th, 2017 05:14 pm
Powered by Dreamwidth Studios