eginez

I was reviewing some documents on the graalvm and its truffle languages and it occured to me that one could write a go ast to LLVM IR emitter. Go has pretty good support for ast operations, thus it looked feasable at least. Obviously next thing I did was to check and see if someone had already done this. And yes.There is a project doing exactly that.

The support for the language is not all there yet and honestly I don't think this is the most sustainable approach but it was fun to play with it. I got some minimal go(tre) code running through graal's lli pretty fast

Ingredients

• Install GraalVM, and then set your PATH so that you get the GraalVM binaries
• llvm (brew install llvm)
• go install github.com/zegl/tre/cmd/tre

taylorwood

(ns polydact.core
  (:import (clojure.lang IFn)
           (org.graalvm.polyglot Context Value)
           (org.graalvm.polyglot.proxy ProxyArray ProxyExecutable ProxyObject)))

(set! *warn-on-reflection* true)

(comment
  (do
    (def context

beders

(defn create-function-call [param expr]
  "Create an sexp for calling expr with a first argument provided by a promise.
  If expr is a list (already in form suitable for a function call), insert the first argument at second position,
  otherwise turn expr into a function call expression, unless the function is an fn, which is simply returned.

  println -> (fn [param] (println param))

  (* 2)   -> (fn [param] (* param 2))
  

vladimirdolzhenko

Guava, Graal and Partial Escape Analysis

Recently java 10 release happened - in fact, Graal was available earlier, but now it is more easy to access and use it - Congratulations, you're running #Graal! - just add a couple options:

-XX:+UnlockExperimentalVMOptions -XX:+UseJVMCICompiler

What does it can provide for us and what kind of enhancements we can expect to get, and more over - what dirty-hacks could be dropped ?

Let's explore an example - looks a bit synthetic but based on a real production code.

swlkr

(ns switch
  (:require [clojure.pprint :as pprint]))

(defn project-clj-map [filename]
  (->> (slurp filename)
       (read-string)
       (drop 1)
       (partition 2)
       (map vec)
       (into {})))

timvisee

Falsehoods programmers believe about time

This is a compiled list of falsehoods programmers tend to believe about working with time.

Don't re-invent a date time library yourself. If you think you understand everything about time, you're probably doing it wrong.

Falsehoods

• There are always 24 hours in a day.
• February is always 28 days long.
• Any 24-hour period will always begin and end in the same day (or week, or month).

longkerdandy

package com.github.longkerdandy.matrix.backend.id;

import java.util.Random;

/**
 * Fancy ID generator that creates 20-character string identifiers with the following properties:
 *
 * 1. They're based on timestamp so that they sort *after* any existing ids.
 *
 * 2. They contain 72-bits of random data after the timestamp so that IDs won't collide with other

ethagnawl

;; https://groups.google.com/d/msg/clojure/cBCf_ftFSw4/xBG_SfMeMBAJ

(doseq [[idx item] (map-indexed vector a-lazy-seq)]
  (do-stuff! item idx))

awalterschulze

all:
	make build
	make objdump

build:
	go build -gcflags -m main.go

objdump:
	go tool objdump -s "main.main" main | grep CALL

longcao

import java.io.InputStream

import org.apache.spark.sql.execution.datasources.jdbc.JdbcUtils
import org.apache.spark.sql.{ DataFrame, Row }

import org.postgresql.copy.CopyManager
import org.postgresql.core.BaseConnection

val jdbcUrl = s"jdbc:postgresql://..." // db credentials elided
val connectionProperties = {