Permuted Index for The Icon Analyst

The issue in which the article appeared is given at the right.



      Program Visualization in  3D                                          44
        Graphics Corner (gamma  adjustment)                                 47
                       Looking  Ahead                                       12
    Programming Tips (avoiding  allocation)                                 48
                        String  Allocation                                   9
                       Dynamic  Analysis                                    30
                       Dynamic  Analysis                                    33
                       Dynamic  Analysis                                    37
                    T-Sequence  Analysis                                    66
                        Static  Analysis of Icon Programs                   27
                       Dynamic  Analysis of Icon Programs                   28
                       Dynamic  Analysis of Icon Programs                   29
                 Launching the  Analyst                                      1
             Face Lift for the  Analyst                                     13
      Sending E-Mail About the  Analyst                                     56
             Final Year of the  Analyst                                     61
             Last Issue of the  Analyst                                     66
                                Analyst Directions                          54
                           New  Analyst Features                            44
                      Expanded  Analyst Format                              37
                                Analyst on Disk?                            40
                                Analyst on Diskettes                        42
                      The Icon  Analyst on the Web                          46
                                Analyzing Character Patterns                50
              From the Library  (anatomy of a graphics procedure)           42
                                Anatomy of a Program (calculator)           12
                                Anatomy of a Program (L-systems)            25
                                Anatomy of a Program -- Numerical Carpets   45
                           The  Anatomy of a Program (recognizer)           10
                                Anatomy of a Program (timing)               18
                                Anatomy of a Program (timing)               19
                                Animation -- Image Replacement              55
                                Animation -- Making Movies                  56
                                Animation -- Mutable Colors                 52
                                Animation -- Reversible Drawing             51
                                Answers to Expression Evaluation Quiz       54
                                Answers to Quiz                             56
                                Answers to Quiz                             57
                                Answers to Quiz on Sequences                55
                                Answers to Structure Quiz                   53
                                Answers to the Quiz                         36
                                Answers to the Trivia Quiz                  26
                                Applications of String Invocation           29
                           New  Area Code                                   29
                  Command-Line  Arguments                                   11
  From the Library -- Rational  Arithmetic                                  57
                         Shaft  Arithmetic                                  57
   From the Library -- Complex  Arithmetic                                  58
                                Arrays                                      14
                        Sparse  Arrays                                      16
                                Assault on Mount Versum                     47
                                Assault on Mount Versum                     48
              Programming Tips  (assignment)                                24
  Programming Tips (reversible  assignment)                                 30
                     Augmented  Assignment Operations                        8
                                Augmented Assignment Operations              8
              Programming Tips  (avoiding allocation)                       48
                                Backtracking and Bounded Expressions        54
                        Versum  Base Seeds                                  34
                                Befriending a Sequence                      66
                                Benchmarking Expressions                     1
                                Benchmarking Expressions                     2
                        Versum  Bimorphs                                    39
                                Bogus Expressions                           30
                                Bogus Expressions                            9
              Backtracking and  Bounded Expressions                         54
              Programming Tips  (breaking loops)                            23
              Programming Tips  (buffered I/O)                              12
                                Building a Visual Interface                 34
                                Building a Visual Interface                 35
                                Building a Visual Interface                 36
                                Building a Visual Interface                 37
              Programming Tips  (building lists)                             9
                    Debugging:  Built-In Facilities                         41
                                Built-In Generators                         53
                       Writing  Bullet-Proof Programs                       10
                        Tricky  Business                                    61
                        Tricky  Business                                    66
                        Tricky  Business (image grammars)                   50
                        Tricky  Business (preprocessor definitions)         44
                        Tricky  Business (variables and names)              47
                       Loading  C Functions                                 36
          Anatomy of a Program  (calculator)                                12
    Programming Tips (packaged  calls)                                      20
                     Exploring  Carpet Space                                47
tomy of a Program -- Numerical  Carpets                                     45
                     Numerical  Carpets Update                              46
              From the Wizards  (case expressions)                          18
              From the Wizards  (case expressions)                          25
              Programming Tips  (case expressions)                           3
        Data Representation: A  Case Study                                  11
                     A Weaving  Case Study                                  54
            Graphics Corner --  Changing Image Colors                       53
                                Character Patterns                          48
                                Character Patterns                          49
                     Analyzing  Character Patterns                          50
                                Cheap Tricks                                26
                 Transposition  Ciphers                                     63
                                Classical Cryptography                      59
                    T-Sequence  Collation                                   65
                                Color in X-Icon                             22
                                Color in X-Icon                             23
                      Weavable  Color Patterns                              58
                      Weavable  Color Patterns                              59
                     Draftable  Color Patterns                              60
             Creating Weavable  Color Patterns                              61
            Designing Weavable  Color Patterns                              62
                                Color-and-Weave                             66
          Animation -- Mutable  Colors                                      52
phics Corner -- Changing Image  Colors                                      53
                                Command-Line Arguments                      11
               Inside the Icon  Compiler                                    12
                      The Icon  Compiler                                     8
    Type Inference in the Icon  Compiler                                     9
           From the Library --  Complex Arithmetic                          58
             An Imaginary Icon  Computer                                     8
                   Visualizing  Concatenation                               38
              From the Library  (concentration game)                        47
              From the Wizards  (concise expressions)                        3
                                Constant Square-Root Palindromes            63
                                Constructing T-Sequences                    65
                       Graphic  Contexts in X-Icon                          21
                                Continued Fractions                         60
                                Continued Fractions for Quadratic Irrational61
            Programmer-Defined  Control Operations                          22
            Programmer-Defined  Control Operations                          23
    Quiz -- Programmer-Defined  Control Operations                          55
 Library -- Programmer-Defined  Control Operations                          56
       From the Wizards (radix  conversion)                                  4
                      Graphics  Corner -- Changing Image Colors             53
                      Graphics  Corner -- Custom Palettes                   58
                      Graphics  Corner -- Custom Palettes                   60
                      Graphics  Corner (drawing images)                     49
                      Graphics  Corner -- Exploring for Tiles               54
                      Graphics  Corner (fun with image strings)             50
                      Graphics  Corner (gamma)                              46
                      Graphics  Corner (gamma adjustment)                   47
                      Graphics  Corner -- Image Permutations                64
                      Graphics  Corner (more fun with image strings)        51
                      Graphics  Corner (repeat patterns)                    44
                      Graphics  Corner (seamless tiling)                    45
                      Graphics  Corner -- Transparency                      52
                                Correction                                  55
                                Corrections                                 35
                                Corrections                                  7
                                Creating Weavable Color Patterns            61
                     Classical  Cryptography                                59
             Periodic Sequence  Curios                                      64
                                Curiosity or Problem?                       29
                                Custom Dialogs                              41
            Graphics Corner --  Custom Palettes                             58
            Graphics Corner --  Custom Palettes                             60
                                Data Representation: A Case Study           11
                                Dealing with Windows in X-Icon              20
             itweak -- An Icon  Debugger                                    46
                                Debugging:  Error Messages                  40
                      Gedanken  Debugging                                    5
                                Debugging: Built-In Facilities              41
                                Debugging: Library Support                  43
                                Debugging: Tracing                          42
                                Decimal Fractions                           62
       Programming Tips (table  default)                                     6
 Tricky Business (preprocessor  definitions)                                44
                        Versum  Deltas                                      49
                        Versum  Deltas                                      50
                                Designing a Visual Interface                33
                                Designing Weavable Color Patterns           62
                                Dialogs                                     40
                        Custom  Dialogs                                     41
                     Icon Made  Difficult                                   20
                                Digit Patterns in Primes                    55
                       Analyst  Directions                                  54
                    Analyst on  Disk?                                       40
                    Analyst on  Diskettes                                   42
                                Dobby Looms and Liftplans                   55
                         Weave  Draft Representation                        56
                                Draftable Color Patterns                    60
                          Name  Drafting                                    57
                       Message  Drafting                                    60
                       Profile  Drafting                                    65
                       Weaving  Drafts                                      53
                          Name  Drafts Revealed                             58
   From the Library (symmetric  drawing)                                    29
       Animation -- Reversible  Drawing                                     51
               Graphics Corner  (drawing images)                            49
                                Drawing in X-Icon                           17
                                Drawups                                     56
                                Dynamic Analysis                            30
                                Dynamic Analysis                            33
                                Dynamic Analysis                            37
                                Dynamic Analysis of Icon Programs           28
                                Dynamic Analysis of Icon Programs           29
              Welcome to a New  Editor                                      34
              Programming Tips  (efficiency)                                15
              Programming Tips  (element generation)                         8
                       Sending  E-Mail About the Analyst                    56
                    Procedural  Encapsulation                               10
              From the Library  (encoding values)                           34
              From the Library  (encoding values)                           39
                                Equivalent Versum Sequences                 32
                    Debugging:  Error Messages                              40
                    Expression  Evaluation                                   2
ibrary (interactive expression  evaluation)                                 41
            Quiz -- Expression  Evaluation                                  53
         Answers to Expression  Evaluation Quiz                             54
                                Evaluation Sandwiches                        6
                      A String  Evaluator                                    9
                      Handling  Events in X-Icon                            19
               String Scanning  Examples                                     5
                                Exercises                                   12
                  Solutions to  Exercises                                   13
                                Exercises                                   20
                  Solutions to  Exercises                                   20
                                Exercises                                   54
                  Solutions to  Exercises                                   55
                                Expanded Analyst Format                     37
                       Modular  Expansion                                   66
                                Exploring Carpet Space                      47
            Graphics Corner --  Exploring for Tiles                         54
                                Exploring Sequences Interactively           56
                                Expression Evaluation                        2
 From the Library (interactive  expression evaluation)                      41
                       Quiz --  Expression Evaluation                       53
                    Answers to  Expression Evaluation Quiz                  54
              Programming Tips  (expression syntax)                         11
                  Benchmarking  Expressions                                  1
        From the Wizards (case  expressions)                                18
                  Benchmarking  Expressions                                  2
        From the Wizards (case  expressions)                                25
     From the Wizards (concise  expressions)                                 3
        Programming Tips (case  expressions)                                 3
                         Bogus  Expressions                                 30
              Writing Scanning  Expressions                                  4
      Backtracking and Bounded  Expressions                                 54
                         Bogus  Expressions                                  9
                                Face Lift for the Analyst                   13
           Debugging: Built-In  Facilities                                  41
             Versum Numbers as  Factors                                     45
                                Factors of Versum Numbers                   40
                                Factors of Versum Numbers                   43
                   New Analyst  Features                                    44
                        Reader  Feedback                                    12
                        Reader  Feedback                                    14
                                Feedback                                     4
                                Feedback?                                   47
      From the Wizards (record  fields)                                     44
                                File System Navigation Using VIB            48
              From the Library  (filtering)                                 38
                                Final Year of the Analyst                   61
                                Finding Repeats                             57
                                Floats                                      59
              Expanded Analyst  Format                                      37
                       Pattern  Forms Revisited                             52
                                Fractal Sequences                           61
                     Continued  Fractions                                   60
                       Decimal  Fractions                                   62
                     Continued  Fractions for Quadratic Irrationals         61
                             A  Framework for Monitoring                    39
               Graphics Corner  (fun with image strings)                    50
         Graphics Corner (more  fun with image strings)                     51
                                Function Tracing                            44
                 Modeling Icon  Functions                                   11
     From the Wizards (tracing  functions)                                   2
                     Loading C  Functions                                   36
rom the Library (concentration  game)                                       47
               Graphics Corner  (gamma)                                     46
               Graphics Corner  (gamma adjustment)                          47
                                Gedanken Debugging                           5
                                Generalizing T-Sequence Operands            65
                                Generating Sequences                        54
                                Generating Versum Numbers                   51
     Programming Tips (element  generation)                                  8
   Programming Tips (recursive  generators)                                 13
                 Random Number  Generators                                  28
                                Generators                                   3
                      Built-In  Generators                                  53
           From the Library --  Generators                                  55
                                Getting Started with Icon                    1
                                Getting to the System                       10
                          Icon  Glossary                                    35
                          Icon  Glossary                                    36
                          Icon  Glossary                                    37
                          Icon  Glossary                                    39
        Tricky Business (image  grammars)                                   50
                                Graphic Contexts in X-Icon                  21
                        Turtle  Graphics                                    24
From the Library -- PostScript  Graphics                                    52
                                Graphics Corner -- Changing Image Colors    53
                                Graphics Corner -- Custom Palettes          58
                                Graphics Corner -- Custom Palettes          60
                                Graphics Corner (drawing images)            49
                                Graphics Corner -- Exploring for Tiles      54
                                Graphics Corner (fun with image strings)    50
                                Graphics Corner (gamma)                     46
                                Graphics Corner (gamma adjustment)          47
                                Graphics Corner -- Image Permutations       64
                                Graphics Corner (more fun with image strings51
                                Graphics Corner (repeat patterns)           44
                                Graphics Corner (seamless tiling)           45
                                Graphics Corner -- Transparency             52
From the Library (anatomy of a  graphics procedure)                         42
                                Handling Events in X-Icon                   19
                                Handling Images in X-Icon                   24
          Getting Started with  Icon                                         1
                  Multi-Thread  Icon                                        14
                           The  Icon Analyst on the Web                     46
                    Inside the  Icon Compiler                               12
                           The  Icon Compiler                                8
         Type Inference in the  Icon Compiler                                9
                  An Imaginary  Icon Computer                                8
                  itweak -- An  Icon Debugger                               46
                      Modeling  Icon Functions                              11
                                Icon Glossary                               35
                                Icon Glossary                               36
                                Icon Glossary                               37
                                Icon Glossary                               39
                                Icon Made Difficult                         20
                    Monitoring  Icon Programs                               15
            Static Analysis of  Icon Programs                               27
           Dynamic Analysis of  Icon Programs                               28
           Dynamic Analysis of  Icon Programs                               29
              Writing Portable  Icon Programs                                3
                 Understanding  Icon's Linker                               59
       Programming Tips (local  identifiers)                                25
                                Idiomatic Programming                       14
                                Idiomatic Programming                       15
     Understanding T-Sequences  II                                          64
olving Square-Root Palindromes  II                                          65
   Graphics Corner -- Changing  Image Colors                                53
               Tricky Business  (image grammars)                            50
            Graphics Corner --  Image Permutations                          64
                  Animation --  Image Replacement                           55
     Graphics Corner (fun with  image strings)                              50
Graphics Corner (more fun with  image strings)                              51
   From the Library (structure  images)                                     25
      Graphics Corner (drawing  images)                                     49
                         Woven  Images                                      56
                      Handling  Images in X-Icon                            24
                            An  Imaginary Icon Computer                      8
                                Imagine Our Surprise                        64
                          Type  Inference in the Icon Compiler               9
              From the Wizards  (initialization)                            30
              Programming Tips  (inserting in tables)                        1
                                Inside the Icon Compiler                    12
                         Large  Integers                                     4
              From the Library  (interactive expression evaluation)         41
           Exploring Sequences  Interactively                               56
            Designing a Visual  Interface                                   33
             Building a Visual  Interface                                   34
             Building a Visual  Interface                                   35
             Building a Visual  Interface                                   36
             Building a Visual  Interface                                   37
                        Visual  Interfaces                                  31
                  Multiple VIB  Interfaces                                  42
                            An  Introduction to X-Icon                      13
                        String  Invocation                                  28
        Applications of String  Invocation                                  29
    Programming Tips (buffered  I/O)                                        12
tinued Fractions for Quadratic  Irrationals                                 61
                    About This  Issue                                       50
                          Last  Issue of the Analyst                        66
                                itweak -- An Icon Debugger                  46
                           The  Kaleidoscope                                38
                           The  Kaleidoscope                                39
                                Kaleidoscopic Visualization                 43
                     A Weaving  Language                                    51
                     A Weaving  Language                                    52
                          Lost  Languages -- Rebus                          18
                          Lost  Languages -- Seque                          19
                          Lost  Languages -- SL5                            17
                                Large Integers                               4
              Programming Tips  (last pattern)                               2
                                Launching the Analyst                        1
                     Procedure  Libraries                                    7
                      From the  Library (anatomy of a graphics procedure)   42
                      From the  Library -- Complex Arithmetic               58
                      From the  Library (concentration game)                47
                      From the  Library (encoding values)                   34
                      From the  Library (encoding values)                   39
                      From the  Library (filtering)                         38
                      From the  Library -- Generators                       55
                      From the  Library (interactive expression evaluation) 41
                      From the  Library (options)                           32
                      From the  Library (organization)                      24
                      From the  Library -- PostScript Graphics              52
                      From the  Library -- Programmer-Defined Control Operat56
                      From the  Library -- Rational Arithmetic              57
                      From the  Library (sorting)                           50
                      From the  Library (structure images)                  25
                    Debugging:  Library Support                             43
                      From the  Library (symmetric drawing)                 29
                          Face  Lift for the Analyst                        13
               Dobby Looms and  Liftplans                                   55
                                Lindenmayer Systems                         26
                                Lindenmayer Systems                         27
                                Lindenmayer Systems                         28
                                Line Termination                            48
    Programming Tips (scanning  lines)                                      19
          Understanding Icon's  Linker                                      59
    Programming Tips (building  lists)                                       9
                                Loading C Functions                         36
              Programming Tips  (local identifiers)                         25
                                Looking Ahead                               12
                         Dobby  Looms and Liftplans                         55
    Programming Tips (breaking  loops)                                      23
                                Lost Languages -- Rebus                     18
                                Lost Languages -- Seque                     19
                                Lost Languages -- SL5                       17
          Anatomy of a Program  (L-systems)                                 25
                  Animation --  Making Movies                               56
                      A String  Manipulation Problem                        44
                       Pattern  Matching                                     5
               Procedures with  Memory                                      21
               Procedures with  Memory                                      22
                                Memory Monitoring                            1
                                Memory Monitoring                            2
                                Memory Utilization                           4
               Versum Sequence  Mergers                                     33
                                Message Drafting                            60
             Debugging:  Error  Messages                                    40
                                Meta-Variant Translators                    23
                  Pattern-Form  Metrics                                     51
                                Modeling Icon Functions                     11
                                Modeling String Scanning                     6
                                Modular Expansion                           66
                        Memory  Monitoring                                   1
                        Memory  Monitoring                                   2
               A Framework for  Monitoring                                  39
                                Monitoring Icon Programs                    15
               Graphics Corner  (more fun with image strings)               51
                           The  Morse-Thue Sequence                         65
                    Assault on  Mount Versum                                47
                    Assault on  Mount Versum                                48
           Animation -- Making  Movies                                      56
                     Returning  Multiple Values                             21
                                Multiple VIB Interfaces                     42
                                Multi-Thread Icon                           14
                  Animation --  Mutable Colors                              52
                                Name Drafting                               57
                                Name Drafts Revealed                        58
Tricky Business (variables and  names)                                      47
                   File System  Navigation Using VIB                        48
              Programming Tips  (nth result)                                 4
                        Random  Number Generators                           28
                        Random  Numbers                                     26
                        Versum  Numbers                                     35
             Factors of Versum  Numbers                                     40
             Factors of Versum  Numbers                                     43
             Generating Versum  Numbers                                     51
                        Versum  Numbers as Factors                          45
                        Random  Numbers Revisited                           31
                        Random  Numbers Revisited                           38
       Anatomy of a Program --  Numerical Carpets                           45
                                Numerical Carpets Update                    46
       Generalizing T-Sequence  Operands                                    65
    Programmer-Defined Control  Operations                                  22
    Programmer-Defined Control  Operations                                  23
    Programmer-Defined Control  Operations                                  55
    Programmer-Defined Control  Operations                                  56
          Augmented Assignment  Operations                                   8
                                Operations on Sequences                     55
                 Procedure and  Operator Values                             29
              From the Library  (options)                                   32
              From the Library  (organization)                              24
                     Version 8  Overview                                     1
              Programming Tips  (packaged calls)                            20
                                Packet Sequences                            63
     Graphics Corner -- Custom  Palettes                                    58
     Graphics Corner -- Custom  Palettes                                    60
                        Versum  Palindromes                                 34
                   Square Root  Palindromes                                 62
          Constant Square-Root  Palindromes                                 63
           Solving Square-Root  Palindromes                                 64
           Solving Square-Root  Palindromes II                              65
        Programming Tips (last  pattern)                                     2
                                Pattern Forms Revisited                     52
                                Pattern Matching                             5
                                Pattern-Form Metrics                        51
       Graphics Corner (repeat  patterns)                                   44
                     Character  Patterns                                    48
                     Character  Patterns                                    49
           Analyzing Character  Patterns                                    50
                Weavable Color  Patterns                                    58
                Weavable Color  Patterns                                    59
               Draftable Color  Patterns                                    60
       Creating Weavable Color  Patterns                                    61
      Designing Weavable Color  Patterns                                    62
                         Digit  Patterns in Primes                          55
                                Periodic Sequence Curios                    64
                                Periodic Sequences                          57
      Graphics Corner -- Image  Permutations                                64
                     Syntactic  Pitfalls                                     2
                       Quiz --  Pointer Semantics                           56
                                Pointer Semantics                            6
                                Polyalphabetic Substitution                 60
                                Polygraphic Substitution                    62
                       Writing  Portable Icon Programs                       3
           From the Library --  PostScript Graphics                         52
                        Versum  Predecessors                                37
              Programming Tips  (preprocessor)                              27
               Tricky Business  (preprocessor definitions)                  44
                        Versum  Primes                                      46
             Digit Patterns in  Primes                                      55
                  Curiosity or  Problem?                                    29
                    The Versum  Problem                                     30
                    The Versum  Problem                                     31
         A String Manipulation  Problem                                     44
           A Small Programming  Problem                                     53
                                Procedural Encapsulation                    10
Library (anatomy of a graphics  procedure)                                  42
                                Procedure and Operator Values               29
                                Procedure Libraries                          7
              Programming Tips  (procedure returns)                         26
              Programming Tips  (procedure values)                           5
                                Procedures with Memory                      21
                                Procedures with Memory                      22
                                Profile Drafting                            65
                  Anatomy of a  Program (calculator)                        12
                  Anatomy of a  Program (L-systems)                         25
                  Anatomy of a  Program -- Numerical Carpets                45
                                Program Readability                          3
              The Anatomy of a  Program (recognizer)                        10
                                Program Size                                39
                                Program Termination                          6
                  Anatomy of a  Program (timing)                            18
                  Anatomy of a  Program (timing)                            19
                                Program Visualization                       16
                                Program Visualization in 3D                 44
                                Programmer-Defined Control Operations       22
                                Programmer-Defined Control Operations       23
                       Quiz --  Programmer-Defined Control Operations       55
           From the Library --  Programmer-Defined Control Operations       56
                     Idiomatic  Programming                                 14
                     Idiomatic  Programming                                 15
                       A Small  Programming Problem                         53
                                Programming Tips                            62
                                Programming Tips (assignment)               24
                                Programming Tips (avoiding allocation)      48
                                Programming Tips (breaking loops)           23
                                Programming Tips (buffered I/O)             12
                                Programming Tips (building lists)            9
                                Programming Tips (case expressions)          3
                                Programming Tips (efficiency)               15
                                Programming Tips (element generation)        8
                                Programming Tips (expression syntax)        11
                                Programming Tips (inserting in tables)       1
                                Programming Tips (last pattern)              2
                                Programming Tips (local identifiers)        25
                                Programming Tips (nth result)                4
                                Programming Tips (packaged calls)           20
                                Programming Tips (preprocessor)             27
                                Programming Tips (procedure returns)        26
                                Programming Tips (procedure values)          5
                                Programming Tips (ProIcon)                   7
                                Programming Tips (recursive generators)     13
                                Programming Tips (reversible assignment)    30
                                Programming Tips (scanning lines)           19
                                Programming Tips (string scanning)          10
                                Programming Tips (structures)               32
                                Programming Tips (table default)             6
                                Programming Tips (tables)                   40
                                Programming Tips (values in rotation)       37
          Writing Bullet-Proof  Programs                                    10
               Monitoring Icon  Programs                                    15
       Static Analysis of Icon  Programs                                    27
      Dynamic Analysis of Icon  Programs                                    28
      Dynamic Analysis of Icon  Programs                                    29
         Writing Portable Icon  Programs                                     3
           Programs that Write  Programs                                     4
                                Programs that Write Programs                 4
              Programming Tips  (ProIcon)                                    7
       Continued Fractions for  Quadratic Irrationals                       61
                         Sigma  Quest                                       62
         Answers to the Trivia  Quiz                                        26
                        Trivia  Quiz                                        26
                                Quiz                                        36
                Answers to the  Quiz                                        36
          Answers to Structure  Quiz                                        53
swers to Expression Evaluation  Quiz                                        54
                    Answers to  Quiz                                        56
                    Answers to  Quiz                                        57
                                Quiz -- Expression Evaluation               53
                    Answers to  Quiz on Sequences                           55
                                Quiz -- Pointer Semantics                   56
                                Quiz -- Programmer-Defined Control Operation55
                                Quiz -- Structures                          52
              From the Wizards  (radix conversion)                           4
                                Random Number Generators                    28
                                Random Numbers                              26
                                Random Numbers Revisited                    31
                                Random Numbers Revisited                    38
           From the Library --  Rational Arithmetic                         57
                       Program  Readability                                  3
                                Reader Feedback                             12
                                Reader Feedback                             14
                      From Our  Readers                                     11
             Lost Languages --  Rebus                                       18
      The Anatomy of a Program  (recognizer)                                10
              From the Wizards  (record fields)                             44
                                Records                                     41
                                Recurrence Relations                        59
              Programming Tips  (recursive generators)                      13
                                Reflections                                 24
                    Recurrence  Relations                                   59
               Graphics Corner  (repeat patterns)                           44
                       Finding  Repeats                                     57
            Animation -- Image  Replacement                                 55
                   Weave Draft  Representation                              56
                          Data  Representation: A Case Study                11
                                Residue Sequences                           58
         Programming Tips (nth  result)                                      4
                                Result Sequences                             7
                                Returning Multiple Values                   21
   Programming Tips (procedure  returns)                                    26
                   Name Drafts  Revealed                                    58
              Programming Tips  (reversible assignment)                     30
                  Animation --  Reversible Drawing                          51
                Random Numbers  Revisited                                   31
                Random Numbers  Revisited                                   38
                 Pattern Forms  Revisited                                   52
                        Square  Root Palindromes                            62
   Programming Tips (values in  rotation)                                   37
                    Evaluation  Sandwiches                                   6
                                Satin                                       59
      Programming Tips (string  scanning)                                   10
                        String  Scanning                                     3
               Modeling String  Scanning                                     6
                        String  Scanning Examples                            5
                       Writing  Scanning Expressions                         4
              Programming Tips  (scanning lines)                            19
               Graphics Corner  (seamless tiling)                           45
                   Versum Base  Seeds                                       34
               Quiz -- Pointer  Semantics                                   56
                       Pointer  Semantics                                    6
                                Sending E-Mail About the Analyst            56
             Lost Languages --  Seque                                       19
                The Morse-Thue  Sequence                                    65
                 Befriending a  Sequence                                    66
                      Periodic  Sequence Curios                             64
                        Versum  Sequence Mergers                            33
             Equivalent Versum  Sequences                                   32
                    Generating  Sequences                                   54
            Answers to Quiz on  Sequences                                   55
                 Operations on  Sequences                                   55
                      Periodic  Sequences                                   57
          Variations on Versum  Sequences                                   57
                       Residue  Sequences                                   58
                       Fractal  Sequences                                   61
                        Packet  Sequences                                   63
                       Spectra  Sequences                                   66
                        Result  Sequences                                    7
                     Exploring  Sequences Interactively                     56
                           New  Services for Subscribers                    43
                                Shadow-Weave Wallpaper                      56
                                Shaft Arithmetic                            57
                                Sigma Quest                                 62
                       Program  Size                                        39
             Lost Languages --  SL5                                         17
                             A  Small Programming Problem                   53
                                Solutions to Exercises                      13
                                Solutions to Exercises                      20
                                Solutions to Exercises                      55
                                Solving Square-Root Palindromes             64
                                Solving Square-Root Palindromes II          65
                                Sorting                                     49
              From the Library  (sorting)                                   50
              Exploring Carpet  Space                                       47
                                Sparse Arrays                               16
                                Spectra Sequences                           66
                                Square Root Palindromes                     62
                      Constant  Square-Root Palindromes                     63
                       Solving  Square-Root Palindromes                     64
                       Solving  Square-Root Palindromes II                  65
                       Getting  Started with Icon                            1
                                Static Analysis of Icon Programs            27
                                String Allocation                            9
                             A  String Evaluator                             9
                                String Invocation                           28
               Applications of  String Invocation                           29
                             A  String Manipulation Problem                 44
              Programming Tips  (string scanning)                           10
                                String Scanning                              3
                      Modeling  String Scanning                              6
                                String Scanning Examples                     5
                                String Synthesis                             7
                                String Synthesis                             8
raphics Corner (fun with image  strings)                                    50
   Corner (more fun with image  strings)                                    51
                         Weave  Structure                                   55
              From the Library  (structure images)                          25
                    Answers to  Structure Quiz                              53
              Programming Tips  (structures)                                32
                       Quiz --  Structures                                  52
   Data Representation: A Case  Study                                       11
                A Weaving Case  Study                                       54
              New Services for  Subscribers                                 43
                Polyalphabetic  Substitution                                60
                   Polygraphic  Substitution                                62
            Debugging: Library  Support                                     43
                   Imagine Our  Surprise                                    64
              From the Library  (symmetric drawing)                         29
                                Syntactic Pitfalls                           2
  Programming Tips (expression  syntax)                                     11
                        String  Synthesis                                    7
                        String  Synthesis                                    8
                Getting to the  System                                      10
                          File  System Navigation Using VIB                 48
                   Lindenmayer  Systems                                     26
                   Lindenmayer  Systems                                     27
                   Lindenmayer  Systems                                     28
              Programming Tips  (table default)                              6
Programming Tips (inserting in  tables)                                      1
              Programming Tips  (tables)                                    40
                          Line  Termination                                 48
                       Program  Termination                                  6
                                Text in X-Icon                              18
                                Text-List Vidgets                           46
                                Tie-Ups                                     59
                                Tie-Ups and T-Sequences                     61
aphics Corner -- Exploring for  Tiles                                       54
     Graphics Corner (seamless  tiling)                                     45
          Anatomy of a Program  (timing)                                    18
          Anatomy of a Program  (timing)                                    19
                   Programming  Tips                                        62
                   Programming  Tips (assignment)                           24
                   Programming  Tips (avoiding allocation)                  48
                   Programming  Tips (breaking loops)                       23
                   Programming  Tips (buffered I/O)                         12
                   Programming  Tips (building lists)                        9
                   Programming  Tips (case expressions)                      3
                   Programming  Tips (efficiency)                           15
                   Programming  Tips (element generation)                    8
                   Programming  Tips (expression syntax)                    11
                   Programming  Tips (inserting in tables)                   1
                   Programming  Tips (last pattern)                          2
                   Programming  Tips (local identifiers)                    25
                   Programming  Tips (nth result)                            4
                   Programming  Tips (packaged calls)                       20
                   Programming  Tips (preprocessor)                         27
                   Programming  Tips (procedure returns)                    26
                   Programming  Tips (procedure values)                      5
                   Programming  Tips (ProIcon)                               7
                   Programming  Tips (recursive generators)                 13
                   Programming  Tips (reversible assignment)                30
                   Programming  Tips (scanning lines)                       19
                   Programming  Tips (string scanning)                      10
                   Programming  Tips (structures)                           32
                   Programming  Tips (table default)                         6
                   Programming  Tips (tables)                               40
                   Programming  Tips (values in rotation)                   37
                    Debugging:  Tracing                                     42
                      Function  Tracing                                     44
              From the Wizards  (tracing functions)                          2
                  Meta-Variant  Translators                                 23
                       Variant  Translators                                  7
            Graphics Corner --  Transparency                                52
                                Transposition Ciphers                       63
                         Cheap  Tricks                                      26
                                Tricky Business                             61
                                Tricky Business                             66
                                Tricky Business (image grammars)            50
                                Tricky Business (preprocessor definitions)  44
                                Tricky Business (variables and names)       47
                                Trivia Quiz                                 26
                Answers to the  Trivia Quiz                                 26
                                T-Sequence Analysis                         66
                                T-Sequence Collation                        65
                  Generalizing  T-Sequence Operands                         65
                   Tie-Ups and  T-Sequences                                 61
                 Understanding  T-Sequences                                 63
                  Constructing  T-Sequences                                 65
                 Understanding  T-Sequences II                              64
                                Turtle Graphics                             24
                                Twills                                      58
                                Type Inference in the Icon Compiler          9
                                Understanding Icon's Linker                 59
                                Understanding T-Sequences                   63
                                Understanding T-Sequences II                64
             Numerical Carpets  Update                                      46
        File System Navigation  Using VIB                                   48
                        Memory  Utilization                                  4
            Returning Multiple  Values                                      21
        Procedure and Operator  Values                                      29
    From the Library (encoding  values)                                     34
    From the Library (encoding  values)                                     39
   Programming Tips (procedure  values)                                      5
              Programming Tips  (values in rotation)                        37
               Tricky Business  (variables and names)                       47
                                Variant Translators                          7
                                Variations on Versum Sequences              57
                                Version 8 Overview                           1
              Assault on Mount  Versum                                      47
              Assault on Mount  Versum                                      48
                                Versum Base Seeds                           34
                                Versum Bimorphs                             39
                                Versum Deltas                               49
                                Versum Deltas                               50
                                Versum Numbers                              35
                    Factors of  Versum Numbers                              40
                    Factors of  Versum Numbers                              43
                    Generating  Versum Numbers                              51
                                Versum Numbers as Factors                   45
                                Versum Palindromes                          34
                                Versum Predecessors                         37
                                Versum Primes                               46
                           The  Versum Problem                              30
                           The  Versum Problem                              31
                                Versum Sequence Mergers                     33
                    Equivalent  Versum Sequences                            32
                 Variations on  Versum Sequences                            57
  File System Navigation Using  VIB                                         48
                      Multiple  VIB Interfaces                              42
                                Vidgets                                     32
                     Text-List  Vidgets                                     46
                   Designing a  Visual Interface                            33
                    Building a  Visual Interface                            34
                    Building a  Visual Interface                            35
                    Building a  Visual Interface                            36
                    Building a  Visual Interface                            37
                                Visual Interfaces                           31
                       Program  Visualization                               16
                 Kaleidoscopic  Visualization                               43
                       Program  Visualization in 3D                         44
                                Visualizing Concatenation                   38
                  Shadow-Weave  Wallpaper                                   56
                                Weavable Color Patterns                     58
                                Weavable Color Patterns                     59
                      Creating  Weavable Color Patterns                     61
                     Designing  Weavable Color Patterns                     62
                                Weave Draft Representation                  56
                                Weave Structure                             55
                             A  Weaving Case Study                          54
                                Weaving Drafts                              53
                             A  Weaving Language                            51
                             A  Weaving Language                            52
       The Icon Analyst on the  Web                                         46
                                Welcome to a New Editor                     34
                  Dealing with  Windows in X-Icon                           20
                      From the  Wizards (case expressions)                  18
                      From the  Wizards (case expressions)                  25
                      From the  Wizards (concise expressions)                3
                      From the  Wizards (initialization)                    30
                      From the  Wizards (radix conversion)                   4
                      From the  Wizards (record fields)                     44
                      From the  Wizards (tracing functions)                  2
                                Woven Images                                56
                 Programs that  Write Programs                               4
                                Writing Bullet-Proof Programs               10
                                Writing Portable Icon Programs               3
                                Writing Scanning Expressions                 4
            An Introduction to  X-Icon                                      13
                    Drawing in  X-Icon                                      17
                       Text in  X-Icon                                      18
            Handling Events in  X-Icon                                      19
       Dealing with Windows in  X-Icon                                      20
           Graphic Contexts in  X-Icon                                      21
                      Color in  X-Icon                                      22
                      Color in  X-Icon                                      23
            Handling Images in  X-Icon                                      24



Icon Analyst

Icon home page