A Guideline for OULIPIAN Programming

1) What is OULIPO?

OULIPO, an acronym for "Ouvroir de Littérature Potentielle" (Workshop of Potential Literature), is a French literary movement. It's grounded in the idea that the application of specific constraints can act as a catalyst for creativity in literature.

The movement was founded in 1960 by the writer Raymond Queneau and the mathematician François Le Lionnais. It emerged as a sub-group of a larger avant-garde group, the Collège de 'Pataphysique, which was dedicated to the exploration of 'pataphysics – the science of imaginary solutions and the laws governing exceptions.

2) Prominent Personalities in OULIPO

François Le Lionnais: A mathematician who his vision was instrumental in forging the unique identity of OULIPO, where mathematical concepts were interwoven with literary creation. Le Lionnais advocated for the use of structured constraints in literature, believing that these limitations could unlock new realms of creativity. His influence extended beyond the formation of the group; he inspired a generation of writers to explore the rich interplay between mathematical structures and literary expression. Le Lionnais' legacy is reflected in OULIPO's continued exploration of the boundaries between science and art.

Raymond Queneau: Celebrated for his wit and creative flair, Queneau was a novelist and poet. He is best known for "Exercises in Style," a unique work where he narrates a single story in 99 different ways, showcasing a remarkable range of stylistic approaches.

Georges Perec: Perec gained acclaim for his novel "La Disparition" (known in English as "A Void"), a distinctive work that entirely omits the letter 'e'. This novel is a prime example of OULIPO's emphasis on linguistic constraints and creative wordplay.

Jacques Roubaud: A mathematician and poet, Roubaud's work is characterized by a unique fusion of mathematical structures and poetic form. His contributions to OULIPO demonstrate a deep engagement with the potential of mathematical constraints to enhance literary expression.

Other notable members include Italo Calvino, Marcel Duchamp, and Harry Mathews.

3) Understanding Constraints

Types of Constraints

• Lipograms: Writing that excludes one or more letters. Perec's "La Disparition" is a famous example, omitting the letter 'e'.
• Palindromes: Texts that read the same forwards and backwards.
• N+7 Method: A process where every noun in a text is replaced with the seventh noun following it in a dictionary. This often leads to surprising and whimsical results.
• Snowball: A poetic form where each line is a single word, and each successive word is one letter longer. This creates a 'snowballing' effect as the poem progresses.
• Univocalism: This involves writing a text that uses only one vowel, while all other letters of the alphabet can be used normally. This constraint tests the writer's ability to creatively use language while adhering to a severe limitation.
• Tautograms: In this constraint, every word in a text must start with the same letter. This can be applied to a single sentence, a paragraph, or an entire work.
• Bouts-rimés: Originating from a French literary game, it involves creating a poem from a given set of end rhymes in a prescribed order. The challenge lies in crafting a coherent and meaningful poem while adhering to these rhyming constraints.
• Prisoner's Constraint (or Macao Constraint): This involves writing texts where certain letters are “imprisoned” inside words and cannot appear on their own. For example, the letter 'e' might only be used within a word, never as the first or last letter.
• Beautiful Outlaw: Similar to a lipogram, this constraint involves avoiding the use of one or more letters of the alphabet, but with an additional rule that the banned letters can appear in the text, as long as they are not seen. This means they can be hidden within other words or disguised in some way.
• S + 7: This is a variation of the N+7 method, where not just nouns, but any word in a specified part of speech (like verbs or adjectives) is replaced by the seventh word following it in a dictionary.
• Homosyntactic Translation: This involves translating a text into another language, but keeping the syntactic structure of the original. The result often highlights the unique grammatical and syntactic features of each language.
• Permutation: This involves creating a text that can be read in multiple ways through the rearrangement of words or sentences. This might involve anagrams, acrostics, or other forms of rearranging the constituent elements of a text.

4) Programming in the OULIPIan Mode

OULIPIan techniques can be a powerful tool for educational purposes, offering unique ways to engage with language and computational thinking. The following OULIPian techniques outline various programming exercises inspired by OULIPO, each with its own educational aspect. These exercises are designed to not only teach fundamental programming concepts but also to encourage creative thinking within constraints, mirroring the OULIPO philosophy.

1. Scratch Implementation: Create a program that allows you to input a text. Use a script to scan each word and remove any words containing the banned letter (like 'e').
2. Educational Aspect: This can be a great exercise in understanding string manipulation and conditionals. String manipulation entails modifying and extracting information from text, teaching students to tokenize lengthy text into individual words, process them independently, and concatenate strings to form new textual output. Conditionals, as programming constructs, empower students to make decisions based on specific conditions, involving the use of 'if' statements to check for a forbidden letter ('e') within words and implementing 'else' statements for alternate outcomes. Iterative processing equips students with the ability to repetitively perform actions for each word in the input text by establishing loops and employing variables to track the current word being processed. Problem-solving becomes paramount as students identify, strategize, implement, and test solutions to the real-world challenge of removing 'e'-containing words from a text. This exercise sharpens logical thinking by requiring students to establish the logic for identifying restricted letters in words and plan and organize their code logically. Furthermore, it encourages feedback-driven debugging and introduces user interaction through a user interface, fostering an understanding of user experience (UX) in software development.

1. Scratch Implementation: Write a script where you input a text, and it checks if the text reads the same forwards and backwards.
2. Educational Aspect: This will involve learning about loops and string reversal. Students grasp the intricacies of iterative processes by using loops to traverse the characters of the text, both forwards and backwards, to make the comparison. Additionally, they delve into the concept of string reversal, which involves the manipulation of text data to reverse its order, an essential skill for palindrome verification. Overall, this exercise not only enhances students' programming skills but also fosters a deeper understanding of loops and string manipulation, all while exploring the intriguing world of palindromes in a practical context.

1. Python Implementation: In Python, you can easily work with lists and dictionaries to store nouns and their N+7 counterparts, making it simpler to implement the N+7 replacement logic. This approach is more intuitive and efficient than trying to manage such data in Scratch's list-like structures.
2. Educational Aspect:It allows students to explore essential programming concepts such as data structures like lists and dictionaries, which are fundamental to organizing and retrieving data efficiently. Additionally, students gain practical insights into arrays, learning how to create, manipulate, and populate lists—an essential skill in programming. They also delve into string manipulation and replacement techniques, honing their abilities to process and transform text. Algorithmic thinking is encouraged as they design systematic approaches to identify nouns, conduct dictionary lookups for replacements, and reconstruct text.

1. Scratch Implementation: Create an interface to input words, then use a script to display them in a growing sequence, each one letter longer than the previous.
2. Educational Aspect: The educational aspect of this exercise primarily centers on instructing students in loops and string length properties within Scratch. Through the "forever" loop, students acquire proficiency in repetitive programming actions while continuously soliciting user input and showcasing an expanding word sequence. The emphasis on string manipulation fosters comprehension of string length retrieval using Scratch's "length of [string]" block and the incremental extension of strings, with each word growing one letter at a time. Moreover, students develop their aptitude for crafting interactive programs with a user interface for input acceptance and dynamic output presentation. This exercise harmoniously amalgamates hands-on programming skills with the imaginative constraints of Snowball, enhancing students' competence in loops, string characteristics, and user interaction within the Scratch environment.

1. Scratch Implementation: Design a script to input a text and then scan it, removing words that contain vowels other than the chosen one.
2. Educational Aspect: This requires an understanding of string searching and conditional logic. Students learn to adeptly scan and search for specific patterns within a given text, with a particular focus on identifying words that contain vowels different from the chosen one, thereby enhancing their text analysis and pattern recognition skills. Moreover, the exercise underscores the importance of conditional statements, particularly the "if" statement, in programming logic, enabling students to develop hands-on experience in crafting logic that selectively removes or retains words based on predefined criteria. Additionally, students actively engage in creating an interactive program featuring a user-friendly interface for input, thereby applying and reinforcing their comprehension of user interaction concepts in a practical context.

1. Scratch Implementation: Allow the input of text, and then filter out words that don’t start with the chosen letter.
2. Educational Aspect: This exercise significantly contributes to students' comprehension of fundamental programming concepts, primarily focusing on string manipulation and list handling. Students gain hands-on experience in skillfully manipulating strings as they evaluate the initial character of each word to determine whether it aligns with the chosen letter, ultimately strengthening their competence in text analysis and manipulation. Furthermore, the exercise underscores the critical role of conditional logic, exemplified through the implementation of "if" statements, fostering students' adeptness in designing logic that selectively incorporates or excludes words based on specific criteria. Students also engage with list data structures as they efficiently split the input text into individual words and meticulously process each word through iteration, thereby reinforcing their proficiency in list handling. Lastly, by creating an interactive program with a user-friendly interface, students apply their knowledge of user interaction concepts, further broadening their practical programming skills.

1. Scratch Implementation: More challenging in Scratch, but you can input a set of rhyming words and then create lines ending with these words.
2. Educational Aspect: Students are encouraged to unleash their imaginative abilities while adhering to the structured framework of the Bout-rimes constraint, composing lines that not only adhere to the prescribed rhyme scheme but also convey coherence and meaning, thereby showcasing their creative prowess. The exercise exemplifies the concept of constraint-based creativity, where imposed limitations, such as the requirement for specific rhyming words, serve as catalysts for inventive problem-solving and artistic expression. Furthermore, students are exposed to programming logic as they devise a systematic approach, even within Scratch's visual blocks, to construct poetic lines that align with the Bout-rimes constraint, honing their logical thinking and problem-solving skills. Additionally, they delve into user interaction design by incorporating input mechanisms for sets of rhyming words, enriching their understanding of practical user interaction concepts.

1. Python Implementation: create a function that takes an input text and an imprisoned letter as parameters, then apply the constraint by checking and modifying words accordingly, and finally, return the valid text. Test the constraint with different input texts and imprisoned letters to observe the results.
2. Educational aspect: the Prisoner's Constraint (or Macao Constraint) in Python programming centers on honing students' skills in string manipulation and conditional logic. This constraint challenges students to devise creative solutions to enforce rules that restrict certain letters from appearing as the first or last letter of words within a given text. It provides a practical exercise in problem-solving, where students must design and implement code to navigate the constraint's limitations, fostering their logical thinking and programming proficiency.

1. Python Implementation: design a program that allows users to input text and specify banned letters. The program should then replace the banned letters within words, promoting practical string manipulation skills and user interaction design.
2. Educational Aspect: The educational aspect of applying the "Beautiful Outlaw" constraint in Python programming primarily centers on enhancing students' comprehension of string manipulation, loops, and string indexing. While the full constraint may be too complex for Scratch, implementing a simplified version in Python provides an opportunity for students to delve into intricate string operations. Students will gain practical experience in creatively manipulating strings, particularly focusing on specific letters within words. Furthermore, this exercise reinforces their understanding of loops as they iterate through words and string indexing as they access and modify individual characters within words. Overall, the "Beautiful Outlaw" constraint in Python promotes hands-on learning, logical thinking, and problem-solving within the realm of string manipulation and programming.

1. Python Implementation: Build a program that takes input text, identifies nouns (or other specified parts of speech), and replaces them with the seventh word following them in a dictionary, utilizing lists and string replacement techniques.
2. Educational Aspect: By building a program that identifies and replaces specific parts of speech, such as nouns, with words from a dictionary, students enhance their understanding of natural language processing and computational linguistics. Simultaneously, they reinforce their programming proficiency by working with lists and employing string replacement techniques, fostering a practical combination of linguistic and programming knowledge within a creative constraint-based context

1. Python Implementation: design a program that takes input text and a translation dictionary, then utilizes advanced string manipulation and tokenization techniques to replace words or phrases while preserving the original syntactic structure and grammar. T
2. Educational Aspect: Firstly, students gain valuable insights into linguistic concepts related to syntax, grammar, and language structure as they preserve the original text's syntactic elements during translation. Secondly, they advance their programming skills by applying complex string manipulation techniques and tokenization, enhancing their ability to develop language-based applications and deepening their understanding of the intersection between language and technology.

1. Python Implementation:  create a program that takes an input text and offers various ways to rearrange its constituent elements, such as anagrams, acrostics, or word reversals, using list manipulation and string manipulation techniques to explore creative text transformations. This exercise provides students with practical experience in manipulating text in diverse ways and reinforces their understanding of advanced list and string operations within a programming context.
2. Educational Aspect: The educational aspect of implementing "Permutation" in Python is centered around enhancing students' skills in creative text manipulation and deepening their understanding of advanced list and string operations. By exploring various rearrangement techniques such as anagrams, acrostics, or word reversals, students not only foster their creative thinking but also strengthen their programming proficiency in manipulating text in diverse ways.

5) Step by Step Examples: OULIPO Programming Project in Scratch &Python

5.1) Lipogram example 

• Step 1: Open Scratch and Create a New Project
• Step 2: Create the User Interface

In the "Sprites" section, delete the default sprite by right-clicking on it and selecting "Delete."

Choose an existing sprite to serve as the interface for your program

• Step 3: Initialize the List

Go to the "Variables" section.

Use the block to clear the list “modiyfiedverse”.

Go to the "Sensing" section to find the block to ask the user to enter a phrase.

Then go to the "Variables" section to store the response in the variable verse.

• Step 4: Get User Input for Letter to Remove

In the "Variables" section, find the block to ask for the letter to remove.

Use another block to store this input in the variable letter to remove.

• Step 5: Set Index Variable

Use a block from the "Variables" section to set index to the length of verse.

Start the Removal Loop

From the "Control" section, start a loop that continues until index reaches 0.

• Step 6: Check Each Character and Build Modified List

Inside the loop, use blocks from the "Operators" and "Variables" sections to check if the character at index in verse is different from letter to remove.

If it is not the letter to be removed, use a block from the "Variables" section to insert it at the beginning of the list “modiyfiedverse”.

Decrease index by 1 using a block from the "Operators" section.

• Step 7: Reset Index and Prepare New String

After the loop, use blocks from the "Variables" section to set index to 0 and verse2 to an empty string.

• Step 8: Concatenate Modified List to Form New String

Use a block from the "Control" section to run a loop for each element in “modiyfiedverse”.

Inside this loop, increase index by 1 using a block from the "Operators" section and join the elements to verse2 with blocks from the "Variables" and "Operators" sections.

• Step 9: Display the Result

Finally, find the block in the "Looks" section to have the program "say"“verse2”, which will display the original phrase with the specific letter removed from every position it occurred.

Here is the Scratch program for the OULIPO lipogram example, which allows you to input text and then removes any words containing a banned letter e.g. “e”.

Fig. 1. : illustration of a Scratch program designed for an OULIPO lipogram

5.2) Snowball Examples

• Step 1

Use the “when [green flag] clicked” block from the "Events" category to start the script

• Step 2: Initialization

Create a list named “test” using the “make a list” option in the "Variables" category.

Create variables “index”, “temp”, “string”, “pass” and “swaps” using the make a variable option in the "Variables" category and set them as follows:

• Set “index” to 0.
• Set “temp” to an empty string.
• Set “string” to the desired input sentence or word (answer).
• Set “pass” and “swaps” to 0.

• Step 3: Initial Setup Loop

The loop begins with the “repeat (length of string)” block. This loop will run as many times as the length of the string that is input by the user. 

• Step 4: Following Loop

Following the initial setup, there is a loop starting with “repeat until (pass > 0 and swaps = 0)”. This is implementing a sorting algorithm. Each iteration of this loop represents a single pass through the list to be sorted.

Inside this loop, you set “item” to 0 and “swaps” to 0, which are used to track the sorting progress and whether any swaps have been made in a pass.

There is a nested loop “repeat (length of text - 1)”. This loop goes through each element of the list text and compares adjacent items to check if they need to be swapped. It's typically used in bubble sort algorithms, where the process repeats until the list is sorted, which is when no swaps are needed (hence “swaps = 0”).

• Step 5: Final Output Loop

At the bottom, there is a loop “repeat (length of text)”. This loop seems to go through the sorted list to create a final result that will be spoken by the Scratch program using the “say result” block.

Fig. 2. : illustration of a Scratch program designed for an OULIPO Snowball

5.3) Permutation Example

• Step 1: Understanding the Objective

Create a program that transforms text in various ways.

Consider how you could rearrange the letters or words of a text to create new forms of text.

• Step 2: Text Input

Function: get_input_text()

Thought Process: We need a method to receive text from the user. The input() function is a simple way to do this.

Step 3: Displaying the Options Menu

Function: display_menu()

Thought Process: Provide the user with options for the type of text transformation. Here, we use simple print statements and an input.

• Step 4: Text Transformations

Functions: generate_anagrams(), generate_acrostics(),reverse_words()

Thought Process: Each function performs a different type of transformation. We use split() to separate the text into words, and then apply the corresponding transformation methods.

• Step 5: Program Execution

Function: main()

Thought Process: This function controls the flow of the program. It receives the text, displays the menu, gets the user's choice, and calls the corresponding transformation function.

import random
def get_input_text():
    return input("Enter your text: ")
def display_menu():
    print("Choose a text manipulation option:")
    print("1: Anagrams")
    print("2: Acrostics")
    print("3: Word Reversals")
    return input("Your choice: ")
def generate_anagrams(text):
    words = text.split()
    anagrams = [''.join(random.sample(word, len(word))) for word in words]
    return ' '.join(anagrams)
def generate_acrostics(text):
    words = text.split()
    acrostic = ''.join([word[0] for word in words])
    return acrostic
def reverse_words(text):
    words = text.split()
    reversed_words = [word[::-1] for word in words]
    return ' '.join(reversed_words)
def main():
    text = get_input_text()
    choice = display_menu()
    if choice == '1':
        print("Anagrams:", generate_anagrams(text))
    elif choice == '2':
        print("Acrostics:", generate_acrostics(text))
    elif choice == '3':
        print("Word Reversals:", reverse_words(text))
    else:
        print("Invalid choice")
if _ _name_ _ == "_ _main_ _":

6) Recommended Bibliography

Bellos, D. (2010). Mathematics, poetry, fiction: The adventure of the Oulipo. BSHM Bulletin, 25(2), 104-118.

Berkman, N. (2018). Digital Oulipo: Programming Potential Literature. DHQ: Digital Humanities Quarterly, 11(3), 1-16.

Despeaux, S. E. (2015). Oulipo: applying mathematical constraints to literature and the arts in a mathematics for the liberal arts classroom. PRIMUS, 25(3), 238-247.

Matuszyk, Ł. (2016). Library Mathematics of the Oulipo. In Proceedings of the International Conference on Studies in Humanities and Social Sciences (SHSS-2016) (pp. 86-92). Paris, France: University of Silesia in Katowice.

Reig, C. (2021). Les «Temps mêlés» de l’Oulipo. Contemporary French and Francophone Studies, 25(5), 566-574.

Reig, C., Andrews, C., Reggiani, C., & Salceda, H. (2021). Les Effets de l’OuLiPo. SITES The Journal of Contemporary French Studies, 25(5,(Dec 2021)).

Wolff, M. (2007). Reading potential: The oulipo and the meaning of algorithms. Digital Humanities Quarterly, 1(1). Digital Humanities Quarterly. Retrieved from https://www.proquest.com/docview/2555208716?pq-origsite=gscholar&fromopenview=true&sourcetype=Scholarly%20Journals