Skip to content

Instantly share code, notes, and snippets.

Daniel Spiewak djspiewak

Block or report user

Report or block djspiewak

Hide content and notifications from this user.

Learn more about blocking users

Contact Support about this user’s behavior.

Learn more about reporting abuse

Report abuse
View GitHub Profile
View o.O.txt
[error] 147 | case Right(fb) => Completed(fb)
[error] | ^^
[error] | Not found: fb
View o.O.scala
[error] 147 | case Right(fb) => Completed(fb)
[error] | ^^
[error] | Not found: fb
View tables.json
{
"62aece90-ed59-4066-a038-3314cac47126": {
"name": "Campaigns Daily Stats",
"description": {
"table": {
"steps": [
{
"act": {
"tag": "attachAll",
"value": {
View greasing-the-skids.md

Greasing the Skids: Building Remote Teams

In the wake of the virus that-must-not-be-named (which most people misname anyway), it seems like everyone and their cat has posted some sort of opinion or how-to on making remote work, work. This is a good thing! Working remotely, particularly full-time, is hard! I've done it for my entire career (aside from an odd 14 month office period in the middle that we shall not speak of), but more relevantly, for the past two years I've been responsible for building, managing, and enabling an entirely remote team, distributed across nine timezones. Remote teams don't just happen by installing Slack and telling everyone to work on their couch: they require a lot of effort to do correctly and efficiently. But, done right, it can be a massive multiplier on your team efficiency and flexibility.

Here's how we do it. I'm going to attempt to structure this post more towards management than engineering, and so I apologize in advance if I assume terminology or knowledge which

View ManagedVersions.scala
package slamdata
import sjsonnew.IsoString
import sjsonnew.shaded.scalajson.ast.unsafe.JValue
import sjsonnew.support.scalajson.unsafe.{Converter, Parser, PrettyPrinter}
import java.nio.file.Path
final class ManagedVersions private (path: Path) {
View interruptable.scala
def interruptable[F[_]: Concurrent: ContextShift](force: Boolean)(thunk: => A): F[A] = {
val fa: F[A] = Concurrent[F] cancelable { cb =>
val t = new Thread(() => cb(Right(thunk)))
t.setDaemon(true)
t.setName("interruptable-thingy-todo")
t setUncaughtExceptionHandler {
case (t, NonFatal(e)) =>
cb(Left(e))
View slamdata-backend.json
[
"slamdata-backend",
"https://github.com/slamdata/slamdata-backend",
[
{
"id": "impl",
"artifact": {
"organization": "com.slamdata",
"name": "slamdata-backend-impl",
"revision": "50.0.8-e49ff7a",
View foldDistributesOverSequence.scala
def foldDistributesOverSequence[A: Monoid](fga: F[G[A]]) = {
implicit val mga: Monoid[G[A]] = Applicative.monoid[G, A]
fga.fold <-> fga.sequence.map(_.fold)
}
View ConcurrentLaws.scala
/*
* Copyright 2020 Daniel Spiewak
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
View evaluator-architecture.md

Query Evaluator Architectural Abstractions

The architecture of all query evaluators can be described in the following fashion. The types in each case may be more or less precise, representations may vary and be more or less first-class, constraints may be statically or dynamically represented, but to a first-order, the architectures all look like this.

Overall Architecture

At the highest level, we can consider a query evaluator to be a function:

type Evaluator = Query => F[DataOut]
You can’t perform that action at this time.