djspiewak

How to GPG as a Scala OSS Maintainer

tl;dr Generate a GPG key pair (exercising appropriate paranoia). Send it to key servers. Create a Keybase account with the public part of that key. Use your keypair to sign git tags and SBT artifacts.

GPG is probably one of the least understood day-to-day pieces of software in the modern developer's toolshed. It's certainly the least understood of the important pieces of software (literally no one cares that you can't remember grep's regex variant), and this is a testament to the mightily terrible user interface it exposes to its otherwise extremely simple functionality. It's almost like cryptographers think that part of the security comes from the fact that bad guys can't figure it out any more than the good guys can.

Anyway, GPG is important for open source in particular because of one specific feature of public/private key cryptography: signing. Any published software should be signed by the developer (or company) who published it. Ideally, consu

lrytz

Shortcut for Syntax Highlighting in Keynote

The idea is based on a gist by @jimbojsb.

You can use Pygments or Highlight.

Install Pygments

brew install python

cvogt

import scala.slick.lifted.{TableQuery => _}
import scala.slick.ast._
import scala.slick.driver._
import scala.language.implicitConversions
 
/** Extends QueryInvoker to allow overriding used SQL statement when executing a query */
trait OverridingInvoker extends JdbcDriver{
  // get the extended QueryInvoker into the .simple._ implicits
  override val Implicit: Implicits = new Implicits
  override val simple: Implicits with SimpleQL = new Implicits with SimpleQL

shajra

import concurrent.{ExecutionContext, Future => SFuture, Promise}                 
import util.Try                                                                                                 
                                                                                                                
import _root_.scalaz.\/                                                                                         
import _root_.scalaz.concurrent.{Task => ZTask}                                                                 
                                                                                                                
                                                                                                                
object Task {                                                                                                   
                                                                                                                
  def fromScala[A]