fronx

summary of: declarations of whiteness: the non-performativity of anti-racism

original text

1. whiteness is only invisible to white people.
2. ahmed is critical of whiteness studies. looking at the effects of whiteness on non-whites as described by black feminists (audre lorde) would be a better starting point than others.
3. the risk of making whiteness the subject of study, even for anti-racist purposes, is that it might increasingly be seen as an object isolated from its effects (‘an essential something’)
4. related risk: keeping whiteness as the center of study
5. another risk: narcissism: appreciating whiteness either in contrast to non-whiteness, or by looking at, and identifying with, whiteness itself (self-reflexive gaze)
6. [unclear] the continuing expression of anxiety about whiteness becoming an object makes it an object [how so?] and may produce an ‘anxious whiteness’ as a side effect

fronx

import pygame, sys
from pygame.locals import *

def to_color(a, a_max, b, b_max):
    return (255,
            int(float(a)/a_max*255),
            int(float(b)/b_max*255))

def pixel(x, y, size):
    return (x * size, y * size, size, size)

fronx

data Useless a = Useless deriving Show

instance Functor Useless where
  fmap f (Useless) = Useless

main = do
  print $ fmap (*2) Useless

fronx

{-# LANGUAGE ScopedTypeVariables #-}
module InputNumber where

import Text.Read

-- let's make fmap look more like a wire
(<~) :: Functor f => (a -> b) -> f a -> f b
(<~) = fmap

-- this one allows us to feed values from left to right

fronx

module PairFunctors where

data Fst b a = Fst (a, b)
  deriving Show
data Snd a b = Snd (a, b)
  deriving Show

instance Functor (Fst b) where
  fmap f (Fst (x, y)) = Fst (f x, y)

fronx

CoderDojo Berlin

CoderDojo ist ein Club für Kinder und Jugendliche im Alter von 5 bis 17 Jahren, die programmieren lernen und Spaß haben wollen. Freiwillige Mentor_innen helfen den Kindern, ihre Ideen umzusetzen. Dabei lernen sie spielerisch die Grundlagen des Programmierens. Und auch wenn sie die Grundlagen schon kennen, gibt es noch mehr als genug neue Konzepte zu lernen.

Wann / Wo

Wir treffen uns einmal im Monat, jedesmal woanders. Den nächsten Termin und Ort findest du immer hier: http://bit.ly/coderdojoberlin

Ablauf

fronx

instance (Num a, Show a) => Show (FnShow a) where
  show (FnShow1 fnStr fn) =
    concat (map showFn [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    where showFn n = fnStr ++ " " ++ show n ++ " = " ++ show (fn n) ++ "\n"
  show (FnShow2 fnStr fn) =
    concat (map showOp [0, 1, 2, 3])
    where showOp n = show (FnShow1 (fnStr ++ " " ++ show n) (fn n))
  show (FnShow3 fnStr fn) =
    concat (map showOp [0, 1, 2, 3])
    where showOp n = show (FnShow2 (fnStr ++ " " ++ show n) (fn n))

fronx

{-# LANGUAGE FlexibleInstances #-}

module Unityped where

import Prelude hiding ((*), (==), (++), print, show, concat)
import qualified Prelude as P
import Data.List hiding ((++))

data D = B Bool
       | N Int

fronx

{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}

import Prelude hiding ((*))
import qualified Prelude as P

class Mul a b c | a b -> c where
  (*) :: a -> b -> c

fronx

module NestedLists where

data NestedList a = Nest [NestedList a] | Item a
  deriving Show

nestedList = Nest [ Item 1
                  , Item 2
                  , Nest [ Item 3
                         , Nest [ Item 4
                                , Item 5