import terminal
import strutils
import unicode
import tables
import json
import os
import math
import sugar
import sequtils
import options
import punycode

import data/idna

when defined(posix):
  import posix

func ansiStyle*(str: string, style: Style): string =
  result &= ansiStyleCode(style)
  result &= str

func ansiFgColor*(str: string, color: ForegroundColor): string =
  result &= ansiForegroundColorCode(color)
  result &= str

func ansiReset*(str: string): string =
  result &= str
  result &= ansiResetCode

func maxString*(str: string, max: int): string =
  if max < str.runeLen():
    return str.runeSubstr(0, max - 2) & "$"
  return str

func fitValueToSize*(str: string, size: int): string =
  if str.runeLen < size:
    return str & ' '.repeat(size - str.runeLen)
  return str.maxString(size)

func isWhitespace*(c: char): bool {.inline.} =
  return c in {' ', '\n', '\r', '\t', '\f'}

func onlyWhitespace*(s: string): bool =
  for c in s:
    if not c.isWhitespace():
      return false
  return true

const C0Controls = {chr(0x00)..chr(0x1F)}
const Controls = (C0Controls + {chr(0x7F)})
const Ascii* = {chr(0x00)..chr(0x7F)}
const Letters = {'A'..'Z', 'a'..'z'}
const AllChars = {chr(0x00)..chr(0xFF)}
const NonAscii = (AllChars - Ascii)
const Digits = {'0'..'9'}
const HexDigits = (Digits + {'a'..'f', 'A'..'F'})

func isControlChar*(c: char): bool =
  return c in Controls

func isControlChar*(r: Rune): bool =
  case r
  of Rune(0x00)..Rune(0x1F): return true
  of Rune(0x7F): return true
  else: return false

func isC0ControlOrSpace*(c: char): bool =
  return c in (Controls + {' '})

func genControlCharMap*(): string =
  for c in low(char)..high(char):
    if c == '?':
      result &= char(127)
    else:
      result &= char((int(c) and 0x1f))

const controlCharMap = genControlCharMap()

func getControlChar*(c: char): char =
  return controlCharMap[int(c)]

func genControlLetterMap*(): string =
  for c in low(char)..high(char):
    if c == char(127):
      result &= '?'
    else:
      result &= char((int(c) or 0x40))

const controlLetterMap = genControlLetterMap()

func getControlLetter*(c: char): char =
  return controlLetterMap[int(c)]

func findChar*(str: string, c: char, start: int = 0): int =
  var i = start
  while i < str.len:
    if str[i] == c:
      return i
    inc i
  return -1

func findChar*(str: string, c: Rune, start: int = 0): int =
  var i = start
  var n = i
  while i < str.runeLen():
    var r: Rune
    fastRuneAt(str, n, r)
    if r == c:
      return i
    i = n
  return -1

func getLowerChars*(): string =
  result = ""
  for i in 0..255:
    if chr(i) in 'A'..'Z':
      result &= chr(i + 32)
    else:
      result &= chr(i)

const lowerChars = getLowerChars()

func tolower*(c: char): char =
  return lowerChars[int(c)]

func toAsciiLower*(str: string): string =
  result = newString(str.len)
  for i in 0..str.high:
    result[i] = str[i].tolower()

func genHexCharMap(): seq[int] =
  for i in 0..255:
    case chr(i)
    of '0'..'9': result &= i - ord('0')
    of 'a'..'f': result &= i - ord('a') + 10
    of 'A'..'F': result &= i - ord('A') + 10
    else: result &= -1

func genDecCharMap(): seq[int] =
  for i in 0..255:
    case chr(i)
    of '0'..'9': result &= i - ord('0')
    else: result &= -1

const hexCharMap = genHexCharMap()
const decCharMap = genDecCharMap()

func hexValue*(c: char): int =
  return hexCharMap[int(c)]

func decValue*(c: char): int =
  return decCharMap[int(c)]

func isAscii*(c: char): bool =
  return c in Ascii

func isAscii*(r: Rune): bool =
  return int(r) < 128

func hexValue*(r: Rune): int =
  if int(r) < 256:
    return hexValue(char(r))
  return -1

func decValue*(r: Rune): int =
  if int(r) < 256:
    return decValue(char(r))
  return -1

const HexChars = "0123456789ABCDEF"
func toHex*(c: char): string =
  result = newString(2)
  result[0] = HexChars[(uint8(c) shr 4)]
  result[1] = HexChars[(uint8(c) and 0xF)]

func equalsIgnoreCase*(s1: seq[Rune], s2: string): bool =
  var i = 0
  while i < min(s1.len, s2.len):
    if not s1[i].isAscii() or cast[char](s1[i]).tolower() != s2[i]:
      return false
    inc i
  return true

func equalsIgnoreCase*(s1, s2: string): bool {.inline.} =
  return s1.cmpIgnoreCase(s2) == 0

func isAlphaAscii*(r: Rune): bool =
  return int(r) < 256 and isAlphaAscii(char(r))

func isDigitAscii*(r: Rune): bool =
  return int(r) < 256 and isDigit(char(r))

func substr*(s: seq[Rune], i, j: int): seq[Rune] =
  if s.len == 0:
    return @[]
  return s[min(high(s), i)..min(high(s), j - 1)]

func substr*(s: seq[Rune], i: int): seq[Rune] =
  if i > high(s) or s.len == 0:
    return @[]
  return s[min(high(s), i)..high(s)]

func skipBlanks*(buf: string, at: int): int =
  result = at
  while result < buf.len and buf[result].isWhitespace():
    inc result

func until*(s: string, c: char): string =
  var i = 0
  while i < s.len:
    if s[i] == c:
      break
    result.add(s[i])
    inc i

func number_additive*(i: int, range: HSlice[int, int], symbols: openarray[(int, string)]): string =
  if i notin range:
    return $i

  var n = i
  var at = 0
  while n > 0:
    if n >= symbols[at][0]:
      n -= symbols[at][0]
      result &= symbols[at][1]
      continue
    inc at

  return result

const romanNumbers = [
  (1000, "M"), (900, "CM"), (500, "D"), (400, "CD"), (100, "C"), (90, "XC"), (50, "L"),
  (40, "XL"), (10, "X"), (9, "IX"), (5, "V"), (4, "IV"), (1, "I")
]

const romanNumbers_lower = romanNumbers.map((x) => (x[0], x[1].tolower()))

func romanNumber*(i: int): string =
  return number_additive(i, 1..3999, romanNumbers)

func romanNumber_lower*(i: int): string =
  return number_additive(i, 1..3999, romanNumbers_lower)

func japaneseNumber*(i: int): string =
  if i == 0:
    return "〇"
  var n = i
  if i < 0:
    result &= "マイナス"
    n *= -1

  let o = n

  var ss: seq[string]
  var d = 0
  while n > 0:
    let m = n mod 10

    if m != 0:
      case d
      of 1: ss.add("十")
      of 2: ss.add("百")
      of 3: ss.add("千")
      of 4:
        ss.add("万")
        ss.add("一")
      of 5:
        ss.add("万")
        ss.add("十")
      of 6:
        ss.add("万")
        ss.add("百")
      of 7:
        ss.add("万")
        ss.add("千")
        ss.add("一")
      of 8:
        ss.add("億")
        ss.add("一")
      of 9:
        ss.add("億")
        ss.add("十")
      else: discard
    case m
    of 0:
      inc d
      n = n div 10
    of 1:
      if o == n:
        ss.add("一")
    of 2: ss.add("二")
    of 3: ss.add("三")
    of 4: ss.add("四")
    of 5: ss.add("五")
    of 6: ss.add("六")
    of 7: ss.add("七")
    of 8: ss.add("八")
    of 9: ss.add("九")
    else: discard
    n -= m

  n = ss.len - 1
  while n >= 0:
    result &= ss[n]
    dec n

func parseInt32*(s: string): int =
  var sign = 1
  var t = 1
  var integer: int = 0
  var e: int = 0

  var i = 0
  if i < s.len and s[i] == '-':
    sign = -1
    inc i
  elif i < s.len and s[i] == '+':
    inc i

  while i < s.len and isDigit(s[i]):
    integer *= 10
    integer += decValue(s[i])
    inc i

  if i < s.len and (s[i] == 'e' or s[i] == 'E'):
    inc i
    if i < s.len and s[i] == '-':
      t = -1
      inc i
    elif i < s.len and s[i] == '+':
      inc i

    while i < s.len and isDigit(s[i]):
      e *= 10
      e += decValue(s[i])
      inc i

  return sign * integer * 10 ^ (t * e)

func parseInt64*(s: string): int64 =
  var sign = 1
  var t = 1
  var integer: int64 = 0
  var e: int64 = 0

  var i = 0
  if i < s.len and s[i] == '-':
    sign = -1
    inc i
  elif i < s.len and s[i] == '+':
    inc i

  while i < s.len and isDigit(s[i]):
    integer *= 10
    integer += decValue(s[i])
    inc i

  if i < s.len and (s[i] == 'e' or s[i] == 'E'):
    inc i
    if i < s.len and s[i] == '-':
      t = -1
      inc i
    elif i < s.len and s[i] == '+':
      inc i

    while i < s.len and isDigit(s[i]):
      e *= 10
      e += decValue(s[i])
      inc i

  return sign * integer * 10 ^ (t * e)

func parseFloat64*(s: string): float64 =
  var sign = 1
  var t = 1
  var d = 0
  var integer: float64 = 0
  var f: float64 = 0
  var e: float64 = 0

  var i = 0
  if i < s.len and s[i] == '-':
    sign = -1
    inc i
  elif i < s.len and s[i] == '+':
    inc i

  while i < s.len and isDigit(s[i]):
    integer *= 10
    integer += float64(decValue(s[i]))
    inc i

  if i < s.len and s[i] == '.':
    inc i
    while i < s.len and isDigit(s[i]):
      f *= 10
      f += float64(decValue(s[i]))
      inc i
      inc d

  if i < s.len and (s[i] == 'e' or s[i] == 'E'):
    inc i
    if i < s.len and s[i] == '-':
      t = -1
      inc i
    elif i < s.len and s[i] == '+':
      inc i

    while i < s.len and isDigit(s[i]):
      e *= 10
      e += float64(decValue(s[i]))
      inc i

  return float64(sign) * (integer + f * pow(10, float64(-d))) * pow(10, (float64(t) * e))

const ControlPercentEncodeSet* = (Controls + NonAscii)
const FragmentPercentEncodeSet* = (Controls + NonAscii)
const QueryPercentEncodeSet* = (ControlPercentEncodeSet + {' ', '"', '#', '<', '>'})
const SpecialQueryPercentEncodeSet* = (QueryPercentEncodeSet + {'\''})
const PathPercentEncodeSet* = (QueryPercentEncodeSet + {'?', '`', '{', '}'})
const UserInfoPercentEncodeSet* = (PathPercentEncodeSet + {'/', ':', ';', '=', '@', '['..'^', '|'})
proc percentEncode*(append: var string, c: char, set: set[char]) {.inline.} =
  if c notin set:
    append &= c
  else:
    append &= '%'
    append &= c.toHex()

proc percentEncode*(append: var string, s: string, set: set[char]) {.inline.} =
  for c in s:
    append.percentEncode(c, set)

func percentEncode*(c: char, set: set[char]): string {.inline.} =
  result.percentEncode(c, set)

func percentDecode*(input: string): string =
  var i = 0
  while i < input.len:
    let c = input[i]
    if c != '%' or i + 2 >= input.len:
      result &= c
    else:
      let h1 = input[i + 1].hexValue
      let h2 = input[i + 2].hexValue
      if h1 == -1 or h2 == -1:
        result &= c
      else:
        result &= char((h1 shl 4) or h2)
        i += 2
    inc i

#basically std join but with char
func join*(ss: openarray[string], sep: char): string =
  if ss.len == 0:
    return ""
  var n = ss.high - 1
  for i in 0..high(ss):
    n += ss[i].len
  result = newStringOfCap(n)
  result &= ss[0]
  for i in 1..high(ss):
    result &= sep
    result &= ss[i]

func clearControls*(s: string): string =
  for c in s:
    if c notin Controls:
      result &= c

func processIdna(str: string, checkhyphens, checkbidi, checkjoiners, transitionalprocessing: bool): Option[string] =
  var mapped = ""
  var i = 0
  while i < str.len:
    var r: Rune
    fastRuneAt(str, i, r)
    let status = getIdnaTableStatus(r)
    case status
    of IDNA_DISALLOWED: return none(string) #error
    of IDNA_IGNORED: discard
    of IDNA_MAPPED: mapped &= getIdnaMapped(r)
    of IDNA_DEVIATION:
      if transitionalprocessing: mapped &= getDeviationMapped(r)
      else: mapped &= r
    of IDNA_VALID: mapped &= r
  
  #TODO normalize
  var labels: seq[string]
  for label in str.split('.'):
    var s = label
    if label.startsWith("xn--"):
      try:
        s = punycode.decode(label)
      except PunyError:
        return none(string) #error
    #TODO check normalization
    if checkhyphens:
      if s.len >= 4 and s[2] == '-' and s[3] == '-':
        return none(string) #error
      if s.len > 0 and s[0] == '-' and s[^1] == '-':
        return none(string) #error
    var i = 0
    while i < s.len:
      if s[i] == '.':
        return none(string) #error
      var r: Rune
      fastRuneAt(str, i, r)
      #TODO check general category mark
      let status = getIdnaTableStatus(r)
      case status
      of IDNA_DISALLOWED, IDNA_IGNORED, IDNA_MAPPED:
        return none(string) #error
      of IDNA_DEVIATION:
        if transitionalprocessing:
          return none(string) #error
      of IDNA_VALID: discard
      #TODO check joiners
      #TODO check bidi
    labels.add(s)
  return labels.join('.').some

func unicodeToAscii*(s: string, checkhyphens, checkbidi, checkjoiners, transitionalprocessing, verifydnslength: bool): Option[string] =
  let processed = s.processIdna(checkhyphens, checkbidi, checkjoiners,
                                transitionalprocessing)
  if processed.isnone:
    return none(string) #error
  var labels: seq[string]
  for label in processed.get.split('.'):
    var needsconversion = false
    for c in label:
      if c notin Ascii:
        needsconversion = true
        break
    if needsconversion:
      try:
        let converted = "xn--" & punycode.encode(label)
        #TODO verify dns length
        labels.add(converted)
      exc<style>pre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */</style><div class="highlight"><pre><span></span><span class="p">&lt;</span><span class="nt">HTML</span><span class="p">&gt;</span>
<span class="p">&lt;</span><span class="nt">HEAD</span><span class="p">&gt;</span>
<span class="p">&lt;</span><span class="nt">TITLE</span><span class="p">&gt;</span>Stop Saying ``Computer Literacy&#39;&#39;!<span class="p">&lt;/</span><span class="nt">TITLE</span><span class="p">&gt;</span>
<span class="p">&lt;/</span><span class="nt">HEAD</span><span class="p">&gt;</span>
<span class="p">&lt;</span><span class="nt">BODY</span><span class="p">&gt;</span>
<span class="p">&lt;</span><span class="nt">H1</span><span class="p">&gt;</span>Stop Saying ``Computer Literacy&#39;&#39;!<span class="p">&lt;/</span><span class="nt">H1</span><span class="p">&gt;</span>
<span class="p">&lt;</span><span class="nt">CITE</span><span class="p">&gt;</span>Brian Harvey<span class="p">&lt;</span><span class="nt">BR</span><span class="p">&gt;</span>University of California, Berkeley<span class="p">&lt;/</span><span class="nt">CITE</span><span class="p">&gt;</span>

<span class="p">&lt;</span><span class="nt">P</span><span class="p">&gt;</span>[A version of this paper was published in <span class="p">&lt;</span><span class="nt">EM</span><span class="p">&gt;</span>Classroom Computer
News<span class="p">&lt;/</span><span class="nt">EM</span><span class="p">&gt;</span> in 1983.]


<span class="p">&lt;</span><span class="nt">P</span><span class="p">&gt;</span>As computers become more widely used in schools, educators have invented
many different ways to use them.  The different uses for computers
are based on quite diverse models of what the purposes of computer
education should be.  One very common approach is based on the notion
of ``computer literacy&#39;&#39;: the idea that there is some basic familiarity
with computers which <span class="p">&lt;</span><span class="nt">EM</span><span class="p">&gt;</span>all<span class="p">&lt;/</span><span class="nt">EM</span><span class="p">&gt;</span> students need in order to compete in
the job market, or to be informed citizens.  The purpose of this paper
is to question whether that notion is valid.

<span class="p">&lt;</span><span class="nt">H2</span><span class="p">&gt;</span>The Importance of Metaphor<span class="p">&lt;/</span><span class="nt">H2</span><span class="p">&gt;</span>

<span class="p">&lt;</span><span class="nt">P</span><span class="p">&gt;</span>Several educators have questioned the specific details of particular
``literacy&#39;&#39; plans, while accepting the overall concept.  ``Computer
literacy doesn&#39;t mean X,&#39;&#39; they say, ``it means Y.&#39;&#39;  For example,
Arthur Luehrmann says, ``[C]omputer literacy must also mean the ability
to <span class="p">&lt;</span><span class="nt">EM</span><span class="p">&gt;</span>do<span class="p">&lt;/</span><span class="nt">EM</span><span class="p">&gt;</span> computing, and not merely to recognize, identify, or be
aware of alleged facts about computing.&#39;&#39;  (Luehrmann, 1981)  His
argument is that a computer curriculum should give students actual
programming experience, not just reading about computers in a book.
But Luehrmann accepts the concept of computer literacy itself, the
idea that there is <span class="p">&lt;</span><span class="nt">EM</span><span class="p">&gt;</span>something<span class="p">&lt;/</span><span class="nt">EM</span><span class="p">&gt;</span> which every student must learn.
He questions only the details of just what this something is.

<span class="p">&lt;</span><span class="nt">P</span><span class="p">&gt;</span>What I would like to do is call into question the claim that there
is anything about computers which belongs in the school experience
of <span class="p">&lt;</span><span class="nt">EM</span><span class="p">&gt;</span>every<span class="p">&lt;/</span><span class="nt">EM</span><span class="p">&gt;</span> student.  I agree with Luehrmann that programming can
be a valuable experience.  But the word ``literacy&#39;&#39; means more than
that; it means that everyone must have the experience in order to
be able to function at all in society.

<span class="p">&lt;</span><span class="nt">P</span><span class="p">&gt;</span>Many people, hearing me make this argument, have complained that it
is foolish to argue about a word.  ``Call it something else,
then, and let&#39;s get on with deciding what it should be.&#39;&#39;  This complaint
misses the point, and indeed could be said to prove the point.  People
who have become accustomed to the ``literacy&#39;&#39; idea find it very difficult
even to entertain the question of whether there is any universally
required computer experience.

<span class="p">&lt;</span><span class="nt">P</span><span class="p">&gt;</span>The trouble is that the word ``literacy&#39;&#39; is a magic word, which conjures
up a very strong metaphor.  Literacy in its original sense, knowing
how to read, really <span class="p">&lt;</span><span class="nt">EM</span><span class="p">&gt;</span>is<span class="p">&lt;/</span><span class="nt">EM</span><span class="p">&gt;</span> universally required in our society.
Any educator who suggested eliminating reading from the curriculum
would be laughed at, if not tarred and feathered.  Merely to say the
phrase ``computer literacy&#39;&#39; definitively answers a question which
has not explicitly been asked.  It&#39;s like the classic ``When
did you stop beating your wife,&#39;&#39; but harder to recognize because
it is so widely used.

<span class="p">&lt;</span><span class="nt">P</span><span class="p">&gt;</span>One practical result of the literacy metaphor is that many decisions about
computer education have been made in a kind of panic.  Parents call up the
school committee to ask why their children are not being trained for the
vital computer job skill.  These parents may not know just what that skill
is, and neither does the school committee.  But they do know that the
private school down the road has computers.

<span class="p">&lt;</span><span class="nt">H2</span><span class="p">&gt;</span>What Everyone Needs to Know<span class="p">&lt;/</span><span class="nt">H2</span><span class="p">&gt;</span>

<span class="p">&lt;</span><span class="nt">P</span><span class="p">&gt;</span>It&#39;s quite true that more and more jobs involve the use of computers.
That&#39;s different from saying that these jobs involve computer
<span class="p">&lt;</span><span class="nt">EM</span><span class="p">&gt;</span>expertise<span class="p">&lt;/</span><span class="nt">EM</span><span class="p">&gt;</span>.  Let&#39;s look at some examples.

<span class="p">&lt;</span><span class="nt">P</span><span class="p">&gt;</span>A good example of a computer-using job
is that of selling hamburgers at McDonald&#39;s.
That machine behind the counter which looks like a cash register is
actually a computer terminal.  When you order a Quarter-pounder with
cheese, instead of ringing up whatever the price is, the counter person
pushes a button which says ``Quarter-pounder with cheese.&#39;&#39; 
The computer displays the price, but it also keeps track of how many
of this item are sitting under the heat lamps.  If they&#39;re running
short, the computer tells the cooks in the back to make more.  The
same computer can tell the manager to buy more hamburger buns at the
right time.  It&#39;s a pretty sophisticated system, and helps make McDonald&#39;s
a low-overhead operation.

<span class="p">&lt;</span><span class="nt">P</span><span class="p">&gt;</span>Now, what does the person behind the McDonald&#39;s counter need to know
about computers?  He only needs to know that when you ask for a
Quarter-pounder with cheese, he should push the button which says
``Quarter-pounder with cheese.&#39;&#39;  That&#39;s it.  Nothing about input
unit, output unit, processor, and memory; nothing about programming
either.

<span class="p">&lt;</span><span class="nt">P</span><span class="p">&gt;</span>Perhaps a more common example is that of computer word processing.
The word processor involves a much more intimate interaction with
the computer than selling hamburgers.  Still, the manufacturers of
word processing systems take pains to <span class="p">&lt;</span><span class="nt">EM</span><span class="p">&gt;</span>hide<span class="p">&lt;/</span><span class="nt">EM</span><span class="p">&gt;</span> the computer, to
make the way you operate the machine as much as possible like operating
an ordinary typewriter.  What skills does a word processing operator
need?  For the most part, exactly the same skills a secretary needed
before word processing: good spelling and punctuation, touch typing,
being able to read the boss&#39;s handwriting.  What the computer adds
is mostly a matter of pushing the ``paragraph&#39;&#39; button instead of
the carriage return and the tab.

<span class="p">&lt;</span><span class="nt">P</span><span class="p">&gt;</span>There are more specifically computer-related skills, of course, like
threading the fanfold paper into the printer.  But that&#39;s the sort
of thing which is done differently for each specific model, and which
is part of a very specific job training program.  It isn&#39;t what you&#39;d
teach in a ``computer literacy&#39;&#39; course for everyone.

<span class="p">&lt;</span><span class="nt">P</span><span class="p">&gt;</span>Perhaps the point really is that there are too many <span class="p">&lt;</span><span class="nt">EM</span><span class="p">&gt;</span>different<span class="p">&lt;/</span><span class="nt">EM</span><span class="p">&gt;</span>
computer-related skills to teach all of them to every student.  Using
a spreadsheet program, for example, is very different from using a
word processor.  Using a microprocessor-controlled automobile engine
tester is very different from either.  Neither ``this is the return
key&#39;&#39; nor actual programming will help much with any of those job
activities.

<span class="