Rebecca Skinner rebeccaskinner

This is a common approach by groups who perpetuate hate speech- to exclaim with faux outrage that any limits on hate speech are tantamount to the dissolution of free speech at the behest of ostensibly powerful minority groups. I won't go so far as to accuse you of being a member of hate groups, but your response certainly echoes the propaganda that they spread, especially in forums like HN.

The fact is that society has always drawn lines about what speech and behavior is and isn't acceptable in different venues and circumstances. Facebook's choice to censor hate speech is no different from a bar, restaurant, or department store asking someone to leave for shouting the N-word at fellow shoppers. It's a private non-governmental entity making a choice about how they want their users to act on their platform.

Furthermore, free speech claims in favor of hate speech ignore the real material costs in human lives that facilitating hate speech incurs. While I greatly value free speech personally, I also greatly

	data Length = forall x. Length { unLength :: [x] }

	instance Eq Length where
	(==) (Length []) (Length []) = True
	(==) (Length (_:xs)) (Length (_:ys)) = Length xs == Length ys
	(==) _ _ = False

	instance Ord Length where
	compare (Length []) (Length []) = EQ
	compare (Length (_:_)) (Length []) = GT

	{-# HLINT ignore "Use lambda-case" #-}
	{-# OPTIONS_GHC -Wno-unrecognised-pragmas #-}
	{-# LANGUAGE DerivingStrategies #-}
	{-# LANGUAGE DataKinds #-}
	{-# LANGUAGE TypeOperators #-}
	{-# LANGUAGE TypeFamilies #-}
	{-# LANGUAGE ScopedTypeVariables #-}
	{-# LANGUAGE TypeApplications #-}
	{-# LANGUAGE RecordWildCards #-}
	{-# LANGUAGE FlexibleInstances #-}

	{-# LANGUAGE NoStarIsType #-}
	{-# LANGUAGE AllowAmbiguousTypes #-}
	{-# LANGUAGE FlexibleContexts #-}
	{-# LANGUAGE ScopedTypeVariables #-}
	{-# LANGUAGE PolyKinds #-}
	{-# LANGUAGE TypeFamilies #-}
	{-# LANGUAGE TypeOperators #-}
	{-# LANGUAGE DataKinds #-}
	{-# LANGUAGE UndecidableInstances #-}
	{-# LANGUAGE ConstraintKinds #-}

	module FindMax where
	import System.Environment (getArgs)
	import GHC.Arr
	import Control.Monad
	import Control.Monad.ST
	import Text.Printf

	-- \| The multiplier that we use when calculating occurrences is the
	-- maximum number in the array, plus one. We can only use the modulo
	-- offset algorithm when the largest number in the input list is less

	{-# LANGUAGE OverloadedStrings #-}
	{-# LANGUAGE ImportQualifiedPost #-}
	{-# LANGUAGE ForeignFunctionInterface #-}
	module ByteRing where
	import Foreign.Ptr
	import Foreign.C.Types
	import Foreign.C.String
	import Foreign.ForeignPtr
	import System.Posix.Types
	import System.Posix.Internals

	module Main where
	import Data.List (transpose)
	import qualified Data.Vector as Vec
	import Data.Matrix hiding (transpose)

	-- Start with some sample starting bucket to test our program. It
	-- contains a set of buckets each of which will have some number of
	-- balls in them. The example here has 0 or 1 balls in each bucket,
	-- but we could theoretically have any number >= 0.
	sampleStartingBucket :: [Int]

	func main() {
	config, err := getArgs()
	if err != nil {
	fmt.Println(err)
	fmt.Println(showHelp())
	os.Exit(1)
	}

	var (
	getEndpoint = fmt.Sprintf("%s/oldusers/%s", config.endpoint, config.username)

	package main

	import (
	"fmt"
	"io/ioutil"
	"os"
	"os/exec"
	"strings"
	"time"
	)

	module DynamicNetworkGraph
	class NetworkFlow
	Fields = [:srcAddr,:dstAddr,:srcPort,:dstPort,:protocol,:start,:end,:packets,:transferred,:status]
	attr_accessor :srcAddr
	attr_accessor :dstAddr
	attr_accessor :srcPort
	attr_accessor :dstPort
	attr_accessor :protocol
	attr_accessor :start
	attr_accessor :end