ZacSweers

The Problem

While doing some remote build cache fidelity testing in #66841, I found that our lint analysis tasks were consistently getting cache misses due to an esoteric intermediate proguard file contents change.

After a little digging, I found these files were generated by AGP as a "merged" file of all that project's generated proguard files. This was most notable in projects using Moshi, which generates proguard rules on the fly.

My hunch was that these files were being merged with non-deterministic order, as I couldn't find anything that ensured ordering and this input was purely a file contents check (so the same rules in different order would still constitute a miss).

I was able to verify this was the case via snagging merged proguard.txt files via github actions artifact uploads.

I filed this issue for it here: issuetracker.google.com/issues/266403349 (note it's been made private for some reason).

jprinet

tasks.withType<JavaCompile>().configureEach {
    doLast {
        this.inputs.files.map { it ->
            if(it.isFile) {
                FileSize(it.length(), it.path)
            } else {
                FileSize(0, "DIR - " + it.path)
            }
        }.sortedBy {
            it.size

ghale

def fingerprinter = services.get(org.gradle.internal.fingerprint.classpath.ClasspathFingerprinter)
tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach { task ->
    doFirst {
        ClassLoader classLoader = task.getClass().classLoader
        while (classLoader instanceof URLClassLoader) {
            def fingerprints = [] as Set
            def allFiles = [] as Set
            classLoader.getURLs().each {
                fingerprints.add(["${task.path}:${file(it.file).name}", "${fingerprinter.fingerprint(files(it.file)).hash}"])
                allFiles.add(file(it.file))

jrodbx

/**
 * 1) Change agpVersion
 * 2) Run './gradlew dumpSources'
 * 3) Check changeset into source control
 */
def agpVersion = 'UPDATE_THIS'

repositories {
  google()
  jcenter()

pablisco

inline fun <A> A.logWith(logger: Logger, block: Logger.(A) -> Unit) : A = 
    this.also { logger.block(it) }

// With interface injection
interface HasLog {
    val log: Logger
    fun <A> A.log(block: Logger.(A) -> Unit) : A =
        logWith(logger, block)
}

jjst

/**
  * Created by jjst on 21/03/16.
  */
object Floors {

  def main(args: Array[String]): Unit = {
    Console.println(floorNumber1("())"))
    Console.println(floorNumber2("())"))
    Console.println(floorNumber2(""))
  }

alxsimo

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.net.URL;

public class ResourceHelper {

  public String convertFileToString(File file) throws Exception {
    BufferedReader reader = new BufferedReader(new FileReader(file));
    StringBuilder sb = new StringBuilder();

mandybess

import android.support.annotation.CheckResult;
import android.support.annotation.NonNull;
import android.widget.AbsListView;

import com.jakewharton.rxbinding.view.ViewEvent;

public final class ListViewScrollEvent extends ViewEvent<AbsListView> {

    @CheckResult
    @NonNull

cb372

Category theory jargon cheat sheet

A primer/refresher on the category theory concepts that most commonly crop up in conversations about Scala or FP. (Because it's embarassing when I forget this stuff!)

I'll be assuming Scalaz imports in code samples, and some of the code may be pseudo-Scala.

Functor

A functor is something that supports map.

rock3r

#!/usr/bin/python

# License for any modification to the original (linked below):
# ----------------------------------------------------------------------------
# "THE BEER-WARE LICENSE" (Revision 42):
# Sebastiano Poggi and Daniele Conti wrote this file. As long as you retain 
# this notice you can do whatever you want with this stuff. If we meet some day,
# and you think this stuff is worth it, you can buy us a beer in return.

import argparse, sys, subprocess, tempfile