RobertFischer

So, I was reading Why You shouldn’t use lodash anymore and use pure JavaScript instead, because once upon a time, I shifted from Underscore to Lodash, and I'm always on the lookout for the bestest JavaScript stdlib. At the same time, there was recently an interesting conversation on Twitter about how some of React's functionality can be easily implemented in modern vanilla JS. The code that came out of that was elegant and impressive, and so I have taken that as a message to ask if we really need the framework.

Unfortunately, it didn't start out well. After copy-pasting the ~100 lines of code that Lodash executes to perform a find, there was then this shocking claim: .

RobertFischer

usage: deidentify [Options] <infile> <outfile>
or deidentify [Options] <infile>... <outdir>
or deidentify [Options] <indir>... <outdir>

De-identify one or several DICOM files according the Basic Application
Level Confidentiality Profile specified in DICOM Part 15.
-
Options:
    --expl-item-len    encode sequence items with explicit length; at
                       default, non-empty sequence items are encoded with

RobertFischer

#!/bin/bash -u

# 
# Run eslint on js and jsx files that are being committed, including doing a round of fixing up
# those files.
#
# Based on @dahjelle/pre-commit.sh and @jancimajek's one liner in that Gist.
#

NAMES=`git diff --diff-filter=d --cached --name-only -- '*.js' '*.jsx' | wc -l`

RobertFischer

{
  alphanumeric_field_needs_quotes: false,
  _leading_undderscores_ok: true,
  trailing_underscores_ok_: true,
  carriage_return_acts_like_comma: true
  "vanilla JSON keys also supported": true
  "a list with null element in at index 1": [0,,2,3,4,5]
  "a list with null element in at index 0": [,1,2,3,4,5]
  "a list with null final element": [0,1,2,3,4,]
  "empty list is interpreted as the empty list, not [null]": []

RobertFischer

"use strict";

const _ = require("lodash");
const defaultRules = require("@semantic-release/commit-analyzer/lib/default-release-rules");
const scope = require(`${__dirname}/package.json`).name;  // You may want to remove whatever's before a "/" in the name.

module.exports = _.map(
	(defaultRules),
	(defaultRule) => {
		return {

RobertFischer

public class Retry {
  
  private static final Logger log = Logger.getLogger(Retry.class);
  
  public static interface CallToRetry<T> {
    <T> T doIt() throws Exception;
  }
  
  public static T withRetry(int maxTimes, long initialWait, int waitMultiplier, CallToRetry<T> call) {
    if(maxTimes <= 0) {

RobertFischer

/*
Node itself is single-threaded.  There is some concurrency stuff that comes from calling out to 
C libraries and I/O, but it can be ignored unless you’re performance-tuning: in general, think of
your entire application as executing on one single thread.

Asynchronous actions in Node are all callback-based (“continuation passing style”, or CPS): at
any point when Node needs to perform something asynchronously (eg: I/O), the Node API will take 
a callback and invokes that callback with the results. The convention for those callbacks is that
the first argument is the error (if any), and the rest of the arguments are the results.

RobertFischer

Consider the following types in a schema:

type Foo {
	id:ID!
	weight:Number!
	foo:Number!
}

type Bar {

RobertFischer

enum Variant<T> {

  Foo(1), 
  Bar(true);
  
  private final T data;
  
  private Variant(T data) {
    this.data = data;
  }

RobertFischer

/**
* Merges together Colors and BrandingImages into a single 
* coherent branding structure.
* 
* Using the function `brandingFromRedux` in `mapStateToProps` will give you 
* a single object containing all the branding colors and images. If you return the
* object that we generate here (possibly with some other additions) as the `props` for 
* your component, then you can use whatever you want from the branding colors and images
* without having to think about defaulting or wiring up additional fields or whatever.
*