mattdesl

NFT Thoughts, Essays, Writings

I'm collecting here a few essays on the net about tokenization in the art world. This list is likely biased and by no means exhaustive.

• Not Another JPG by M Plummer-Fernández (April 09, 2021)
• What does it mean to buy a GIF? by Jack Rusher (March 20, 2021)
• Podcast: Skepticism & Optimism around art NFTs (June 2, 2021)
• Token Gesture by Tina Rivers Ryan (May, 2021)
• Podcast: Two Art Historians Discuss NFTs, Part 2 (July 13, 2021)
• [Custodianship, Copyright, and Provenance: on the non-monetary value of NFTs by Nathaniel Stern](https://nathanielstern.com/text/2021/custodianship-copyright-and-provenance-on-the-non-monetary-value-of

li0nel

# Use Let's Encrypt certbot to order a free certificate
certbot certonly --non-interactive --manual \
  --manual-auth-hook "./auth-hook.sh UPSERT your_domain.com" \
  --manual-cleanup-hook "./auth-hook.sh DELETE your_domain.com" \
  --preferred-challenge dns \
  --config-dir "./letsencrypt" \
  --work-dir "./letsencrypt" \
  --logs-dir "./letsencrypt" \
  --agree-tos \
  --manual-public-ip-logging-ok \

kourge

export enum Event1 {
    SIGN_IN_WALL = 'Sign In Wall' as any,
    SIGN_UP = 'Sign Up' as any,
}

{
    const x = Event1.SIGN_UP; // type = Event1
    const y: number = x;
    // Verdict: approach is succint, but incorrectly allows type widening to number.
}

DrBoolean

const daggy = require('daggy')
const {compose, curry, map, prop, identity, intersection, union} = require('ramda');
const inspect = (x) => { if(!x) return x; return x.inspect ? x.inspect() : x; }

// F-algebras


// Fix
// ============
// Fx is a simple wrapper that does almost nothing. It's much more useful in typed languages to check that we have a recursive f (Fix f)

robotlolita

function id(a) {
  return a
}

function compose(f, g){ return function(x) {
  return f(g(x))
}}

function partial(f, x) {
  return function(y) {

jlongster

  // Simple wrapper to use bootstrap's grid system to position elements side-by-side
  var VerticalFieldsElement = React.createClass({
    render: function() {
      return dom.div(
        { className: 'clearfix' },
        React.Children.map(this.props.children, function(child) {
          if(!child) {
            return child;
          }

jackrusher

;; Some fun with the etymological wordnet database 
;; <http://www1.icsi.berkeley.edu/~demelo/etymwn/>
;; you'll need the database from that link and this table
;; <https://gist.github.com/jackrusher/b42152c40cb56b466085>
;; to eval the code in this gist within your own environment.

(defn fixup-name [name]
  (-> name
      clojure.string/lower-case
      (clojure.string/replace #": " "-")

timrwood

(function (root, factory) {
	"use strict";
	if (typeof define === 'function' && define.amd) {
		define(['moment'], factory);
	} else if (typeof exports === 'object') {
		module.exports = factory(require('moment'));
	} else {
		factory(root.moment);
	}
}(this, function (moment) {

hiredman

#!/usr/bin/java -jar clojure-1.7.0-master-SNAPSHOT.jar    

(let [pom-uber-jar                                                                                                                                                      
      (str "http://thelibraryofcongress.s3.amazonaws.com/"                                                                                                              
           "pomegranate-0.0.13-SNAPSHOT-jar-with-dependencies.jar")                                                                                                     
      cl (java.net.URLClassLoader. (into-array [(java.net.URL. pom-uber-jar)]))                                                                                         
      cx (.getContextClassLoader (Thread/currentThread))]                                                                                                               
  (push-thread-bindings {clojure.lang.Compiler/LOADER cl})                                                             

jackrusher

(def date-parsers [nil (java.text.SimpleDateFormat. "yyyy") (java.text.SimpleDateFormat. "yyyy-M") (java.text.SimpleDateFormat. "yyyy-M-dd")])

(def grains [:decade :year :month :day]) ;; what's decade doing?

(map #(let [[_ year month day] (re-find #"(\d{2,4})[-_]([\dx]{2})[-_]([\dx]{2})" %)
            date (first (split-with (partial not= "xx") [(if (= (count year) 2) (str "19" year) year) month day]))]
        [(.parse (parsers (count date)) (clojure.string/join "-" date)) (grains (count date))])
     ["thefilehasaname__1939-xx-01.mp3"
      "thefilehasaname__39_01_01.mp3"
      "thefilehasaname__39-01-01.mp3"