¶ Icon
¶ Programming Languages
Programming languages often feel like living entities. They grow, evolve, borrow ideas, shed limitations, and find new homes in the minds of curious programmers. Over the decades, we’ve seen languages rise meteorically, stumble quietly into obscurity, or settle into special niches where they flourish quietly but powerfully. Some become everyday tools for millions of developers, while others remain beloved by a smaller group of enthusiasts who appreciate the subtle elegance or unconventional philosophy embedded in their design. Icon, the focus of this course, belongs in that latter category: a language not always at the center of mainstream conversation, but one that rewards patience, curiosity, and a willingness to see programming from a different angle.
Icon is famously hard to categorize. Is it procedural? Yes. Is it functional? In some ways. Is it a language built around pattern matching? Absolutely—but not in the way you might expect. Does it embrace ideas from logic programming? Definitely. Yet none of these descriptions fully capture what makes Icon unique. The best way to think of Icon is this: it’s a language built around the notion that computation should be driven by the discovery of results rather than the rigid execution of instructions. Instead of forcing programmers to constantly check whether operations succeed or fail, Icon allows expressions to naturally generate values—or no values—and it’s this stream of possibilities, this effortless flow of alternatives, that becomes the real engine of computation.
This course, spanning one hundred articles, aims to ease you into that mindset. Not only will you learn Icon’s syntax and features, but you’ll also understand why the language was built as it was, how its creators approached the idea of computation, and how its model differs from the languages you may already know. More importantly, you’ll get a feel for how Icon encourages you to solve problems: by expressing what you want the program to find rather than painstakingly orchestrating each step of how it should find it. The difference may sound subtle now, but as you progress, you’ll see how Icon can make certain kinds of tasks—especially those involving searching, pattern matching, text analysis, or exploring combinations—remarkably intuitive.
The story of Icon begins in the late 1970s, growing from earlier languages like SNOBOL, which itself was a pioneer in string manipulation and pattern matching. Many languages today treat strings as largely passive: sequences to be parsed, sliced, or concatenated. SNOBOL and Icon take the opposite approach. Strings become dynamic, active elements of the language, capable of generating results, embodying hypotheses, and participating directly in the process of exploration. If you’ve ever struggled with messy parsing logic or deeply nested conditionals when trying to match and extract information from text, Icon’s approach may feel like a revelation. Instead of writing code filled with checks and guards, you describe the structure of what you want, and the language attempts to match it, yielding results along the way.
This idea extends beyond strings. In Icon, ordinary operations like addition, comparison, list indexing, or reading from files are woven into a general framework of goal-directed evaluation. This means that, rather than returning a single answer or a simple failure, many expressions can instead generate a sequence of possible values. A loop can iterate over these generated values naturally. A conditional can test the success or failure of the generation itself. A function might stop after finding the first value that meets your needs—or keep producing more until you tell it to stop. This seamless integration of success, failure, and multiple results is the heart of Icon’s charm.
If you're coming from languages like Python, Java, or C++, Icon may feel at first like a gentle but persistent invitation to loosen your grip on rigid procedural thinking. You may be used to carefully managing the flow of control: if this happens, go there; if that fails, handle the error. Icon, however, takes the responsibility of checking for failures out of your hands. Instead, it lets the flow of execution automatically depend on the success or failure of expressions. When an expression produces values, execution moves forward. When it fails to produce a value, execution automatically backs up—logically, not in terms of literal stack rewinding—and tries the next possible alternative. This form of implicit backtracking is not chaotic or unpredictable; rather, it’s orderly, deliberate, and deeply woven into the language’s semantics.
To a beginner, this can feel refreshing. To someone experienced, it can feel liberating. But to those accustomed to tightly controlled logic in other languages, it can even feel a little unsettling. That’s part of the journey. Throughout these articles, you’ll gradually become comfortable with the notion that failure is not an exception but a natural part of computation. In Icon, failure simply means “no result,” and because of that, operations are designed to cooperate gracefully with failure. The language isn’t built around throwing errors or forcing you to handle edge cases manually. Instead, it lets expressions govern the flow, and in doing so, creates a programming experience that often feels poetic.
One of the most striking differences you’ll encounter is Icon’s attitude toward types and data structures. Unlike languages that bombard you with explicit type declarations or force you into rigid data models, Icon is surprisingly flexible. It’s dynamically typed and offers built-in support for lists, sets, tables, and strings that go far beyond simple containers. Lists, for example, can behave like stacks or queues. Tables allow associative storage with missing values automatically filled in when needed. Sets provide efficient membership checking. All of these data structures integrate smoothly with Icon’s goal-directed paradigm, making operations like searching, filtering, or transforming collections feel natural.
But the true signature of Icon lies in its generators. Generators are expressions that produce multiple values over time, often transparently, without requiring special syntax. Many languages have generators or iterators of some kind, but in Icon, the concept is deeply ingrained. Consider a simple example: taking every element of a list that meets a certain condition. In other languages, you might write a loop, check each element manually, and build a new list. In Icon, the list itself can generate its elements; the condition can determine which values to keep; and a single expression can capture the essence of the operation. You don’t build the mechanism—you simply describe the relationship, and the language handles the iteration and filtering behind the scenes.
Another fascinating aspect is the built-in support for string scanning. Icon offers a scanning facility that lets you move through a string while maintaining an internal pointer that can advance, backtrack, and attempt matches, all without the programmer having to manually track indices or manage slicing. If you’ve ever written a parser or dealt with messy text data, you’ll appreciate the elegance of a feature that makes those tasks intuitive. Scanning ties naturally into Icon’s goal-directed philosophy, because attempting to match part of a string becomes just another operation that can succeed, fail, or generate multiple possibilities.
Throughout this course, you’ll encounter many examples showing how scanning, generators, and expressions that succeed or fail can work together in surprisingly powerful ways. You’ll see how a few lines of Icon can accomplish tasks that require dozens of lines in other languages. You’ll also learn when Icon’s strengths shine brightest: whenever the task involves exploring alternatives, matching patterns, searching through data, or generating possibilities. Icon may not be the language you reach for when building a massive web application or managing large-scale systems, but for the purposes it was designed for, its expressive power is remarkable.
Part of becoming fluent in Icon involves embracing its philosophy. You’ll quickly realize that programming in Icon is not about telling the machine step-by-step what to do. Instead, it’s about expressing what you want and letting the language pursue the possibilities. It’s like describing a goal and trusting that the underlying machinery knows how to chase it. This mindset can make your code concise, elegant, and surprisingly free of clutter. It also encourages you to think more abstractly about your tasks, focusing on what the solution means rather than how to implement it.
Over one hundred articles, we’ll explore every corner of the language: its syntax, data types, operations, generators, scanning facility, control structures, and idioms. We’ll write examples, walk through real use cases, and build programs that demonstrate the language’s unique capabilities. Whether you're new to programming or have years of experience, you’ll come away with a deep understanding of Icon’s worldview and how it fits into the larger landscape of programming languages.
Icon’s beauty lies in its simplicity of expression and its subtle depth. It rewards those who approach it patiently, with curiosity and a willingness to see computation differently. This course will guide you through that process, helping you build not just technical knowledge but a new way of thinking about programs.
¶ Icon
¶ Beginner Topics
1. Introduction to Icon: What is Icon and Why Should You Learn It?
2. Setting Up the Icon Development Environment
3. Your First Icon Program: "Hello, World!"
4. Understanding the Icon Syntax: Basic Structures and Statements
5. Variables and Constants in Icon: How They Work
6. Basic Data Types in Icon: Integers, Strings, and Booleans
7. Arithmetic Operators in Icon: Performing Simple Calculations
8. Strings in Icon: Concatenation, Substrings, and Interpolation
9. Input and Output in Icon: get and put Statements
10. Understanding Control Flow: if, else, and case
11. Using Loops in Icon: for, repeat, and while
12. Defining Functions in Icon: Syntax and Calling Functions
13. Introduction to Icon’s Expression-Oriented Syntax
14. Basic Error Handling in Icon: Using fail
15. Understanding and Using Variables in Expressions
16. Lists in Icon: Defining, Accessing, and Modifying Lists
17. Introduction to Icon's Procedures
18. Introduction to Lists in Icon: Basic Operations and Functions
19. Using do and while Loops for Iteration in Icon
20. Working with Random Numbers and Simple Simulation in Icon
¶ Intermediate Topics
21. Icon’s Pattern Matching: A Deep Dive into Expressions
22. Understanding and Using choose in Icon
23. Using select and do Expressions for Control Flow
24. The Power of Icon’s Lists: Advanced List Operations
25. Functions as First-Class Objects in Icon
26. Working with Multiple Results in Icon: & and Multiple Outputs
27. Understanding Icon’s Garbage Collection System
28. Introduction to Icon’s Fail Expressions: What and How to Use Them
29. Managing Program Flow with skip and fail
30. Complex Expressions in Icon: Using Expressions Inside Other Expressions
31. Working with Data Structures in Icon: Arrays and Lists
32. Understanding Recursion in Icon
33. Introduction to Pattern Matching and Templates in Icon
34. Creating and Using Multiple Conditions in Icon
35. Working with Iterators and Generators in Icon
36. Using Icon’s every and all for Conditional Iteration
37. Building Functions with Multiple Outputs and Return Values
38. Creating Complex Expressions with Nested Loops and Conditions
39. File Handling in Icon: Reading and Writing Files
40. Parsing Data in Icon: Using Expressions for String Parsing
41. Implementing Simple Algorithms in Icon
42. Understanding and Using the pass Statement
43. Using unique for List Manipulation in Icon
44. Building Simple Applications with Icon
45. Introduction to Recursion and Its Application in Icon
46. Using Symbolic Variables in Icon
47. Debugging Icon Programs: Tools and Techniques
48. Introduction to Modules in Icon
49. Using unless and while for Control Flow
50. Introduction to Error Handling and Debugging in Icon
¶ Advanced Topics
51. Understanding Icon’s Built-In Procedures and Libraries
52. Icon’s Advanced Pattern Matching: How to Use It Efficiently
53. Creating Complex Data Structures in Icon
54. Icon's generator Keyword: Understanding Its Power
55. Advanced List Manipulation: Filtering and Mapping in Icon
56. Object-Oriented Programming in Icon (using Procedures and Lists)
57. Using Dynamic Variables for Complex Programs in Icon
58. Efficient Use of Memory in Icon: Tips and Tricks
59. Working with Complex Data Types in Icon
60. Icon’s Control Structures: Advanced Techniques for Flow Control
61. Creating Advanced Algorithms with Icon's Recursion Features
62. Integrating External Libraries with Icon
63. Icon for Graphical User Interfaces (GUI): Using the Tk Toolkit
64. Building Interactive Applications with Icon
65. Understanding and Using trace for Debugging in Icon
66. Understanding the every Expression for Repeated Evaluation
67. Writing Parallel Programs in Icon
68. Introduction to Icon's String Manipulation Techniques
69. Working with Multidimensional Arrays in Icon
70. Creating and Using Custom Procedures in Icon
71. Managing State and Variables in Large Icon Programs
72. Icon's Advanced Exception Handling: Working with fail and skip
73. Using Icon for Data Transformation and ETL Processes
74. Writing Efficient Code in Icon: Best Practices and Optimization
75. Icon for Web Scraping: Parsing HTML and XML
76. Using Icon with Databases: SQLite and File Systems
77. Advanced Iteration in Icon: Using choose for Search Operations
78. Event-Driven Programming in Icon: Building Event Handlers
79. Writing Icon Programs for Real-Time Applications
80. Understanding Icon’s Flow Control with select, do, and while
81. Working with Structured Data: JSON and XML Parsing in Icon
82. Building Multi-Threaded Applications in Icon
83. Using Icon’s restore and save for Program State Management
84. Writing Cross-Platform Applications with Icon
85. Working with Regular Expressions in Icon
86. Using Icon's Internal Functions for Efficient Data Handling
87. Advanced Recursion Techniques: Tail Recursion and Beyond
88. Building Interactive Web Applications with Icon
89. Using Icon for Network Programming and Socket Communication
90. Implementing AI Algorithms with Icon: Search, Heuristics, and Trees
91. Data Visualization in Icon: Graphs, Charts, and Plotting
92. Integrating Icon with Other Languages: C, Python, and More
93. Building a Basic Web Server with Icon
94. Using Icon for Natural Language Processing (NLP) Tasks
95. Managing Complex Projects in Icon: Modularization and Code Reuse
96. Using Icon for Scientific Computing: Numerical Methods and Simulations
97. Creating a HCI with Icon: Handling User Input and Output
98. Using Icon’s command Feature for Shell Programming
99. Extending Icon with Custom Built-In Procedures
100. The Future of Icon: Trends, Libraries, and Ecosystem