Computational Form Notes Pitch Deck Teardown

Overview of the Computational Form Notes

The document provided is a 54-slide academic log (18 slides reviewed) titled Computational Form Notes by Akshansh Chaudhary. It is clearly identified as work from the MFADT | Parsons School of Design . Unlike a startup pitch deck designed to secure venture capital, this deck is a pedagogical tool used to document a student's understanding of generative art, creative coding, and the mathematical foundations of design. It is a 'build-in-public' style academic journal that tracks specific assignments, technical hurdles, and conceptual breakthroughs over a semester.

Slide 1: Title and Word Cloud

The opening slide is a dense word cloud that serves as a visual index for the entire deck. Key terms include CompForm.net , p5.js , Random , Noise , Turtle Graphics , and Markov . The presence of 'Parsons' and 'Akshansh' establishes the institutional and personal context. This slide functions as a thematic map rather than a traditional title slide, signaling that the content will be highly technical and focused on the intersection of code and art.

Slide 2: Initial Ideas and References

Slide 2 introduces the methodology of the course. The author lists several project ideas, including 'Showing wireless network overlay on top of real world (AR)' and 'Storytelling with Data.' A key reference is made to procedurally generated games like Minecraft and Dwarf Fortress . Crucially, the slide notes the time investment: Min - 60 min; Max - 120 min per sketch. This establishes a cadence for the creative process, emphasizing 'Make. Make. Make.' over over-thinking the concept.

Slide 5: The Logic of Randomness

This slide dives into the technical nuances of JavaScript's math functions. The author warns that round() does not produce equally likely options and suggests using Math.floor(Math.random() 7) for a rolling die. It also introduces Gaussian distribution (Bell curves) via the randomGaussian() function in p5.js. The slide provides a practical code snippet for a 10% likelihood: if (random() . This is a foundational lesson in how to control 'controlled randomness' in generative art.

Slide 8: Interface and Parameterization

Slide 8 explores the Benefits of Parameterizing , citing 'Better code, better UX, better results.' It breaks down the difference between UI (User Interface) and API (Application Programming Interface). A Venn diagram illustrates the relationship between 'Your Project' (what you make) and 'Your User' (what you design). This slide marks a shift from pure code logic to design thinking, asking which parameters should be exposed to the user and which should remain internal to the function.

Slide 11: Variable Declaration and Challenges

This slide covers the syntax differences between let and var in JavaScript, noting that let works only within parentheses while var is for global working. It also introduces the Ternary operator as a cleaner way to write conditional logic for square sizes. The slide concludes with a 'Challenge': Create a face generating tool and do 5 sketches on parameters. This reinforces the deck's purpose as a record of coursework.

Slide 14: Linear Interpolation and Noise

Slide 14 focuses on Perlin Noise , a crucial concept in generative art for creating natural-looking variations. The author lists benefits: it is 'band-limited' (acting like high/low pass filters) and 'visually isotropic' (looks the same when rotated). A graph illustrates one-dimensional noise, and the author notes that noise requires parameters (x, y, z) to determine the frequency of change. This is a high-level technical explanation of how to move beyond basic randomness into organic movement.

Slide 17: Tactics and Placement

The author discusses the 'Trick' of recognizing abstract similarities between problems, such as comparing a bouncing ball to music notes. The slide introduces Placement Tactics , listing five methods: Random, Grid, Noise, Proximity Cell, and Stamp placement. A visual example of 'Clustering' (dots on a square with no overlap and good spacing) demonstrates these tactics in practice. This slide is about the strategy of composition through code.

Slide 20: Hardware and Pixel Arrays

This slide moves into the physics of displays, explaining the Cathode Ray Tube (CRT) and the 'Tearing Effect' in video games caused by refreshing the screen with new values from RAM while the bottom half still holds old values. It also warns about the performance cost of using the pixels[] array in JavaScript, noting that a 1920x1080 image has 4 trillion pixels to process (likely a calculation error or hyperbole, as it is ~2 million pixels, but the point about browser crashes remains valid).

Slide 23: Turtle Graphics

Slide 23 introduces Turtle Graphics , a classic method of programming where a 'turtle' is given commands to move and draw. The author compares drawing a line in p5.js (locating the line is easier) vs. Turtle graphics (the length is explicit in the code). It uses a recursive tree drawing example to show how simple rules can create complex organic structures. This is a staple lesson in computational geometry.

Slide 26: Paper.js and Laser Cutting

This slide compares Paper.js (which the author likens to 'using felt') to p5.js ('pen + paper'). It notes that Paper.js is 'Great for creating stuff for laser cutting.' The assignment listed is to 'Create a poster' and 'Laser cut it.' This shows the transition from digital code to physical fabrication, a key component of the MFADT curriculum.

Slide 29: Animation and Frame Rates

Slide 29 discusses the technical requirements for smooth animation. It notes that for VR, 60 fps is not enough, and 90 fps is the minimum convention to avoid nausea. It distinguishes between the Game Loop and the Draw Loop . A critical tip is provided: do not use frameCount to sync with music because hardware refresh rates vary; instead, use millis() for real-time animation.

Slide 32: Markov Chains and Text Generation

The author explores text-based generative art, mentioning NaNoGenMo 2018 (National Novel Generation Month). The slide explains Markov Chains as models applied to symbols where the next word is chosen based on the current one. A visual example using Dr. Seuss's 'One Fish, Two Fish' illustrates how the sequence 'one -> fish -> has -> a' is formed. It also touches on Context Free Grammar and invalid HTML strings.

Slide 35: Light and Perception

Slide 35 shifts to the physics of light, referencing Richard Feynman and UV imaging. It mentions that a blue LED does not emit white light and references 'The Dress' controversy to explain how eyes perceive colors. The inclusion of an IR Camera photo suggests a lab-based component of the course where students experiment with non-visible spectrums of light.

Slide 38: Algorithmic Music with tone.js

This slide introduces tone.js for creating computational music. It defines three types: Algorithmic , Aleatoric (where the composition is not pre-decided), and Generative . The author notes that 'Visual should interact always with the Sound' to create a more immersive experience. This marks the expansion of the 'Computational Form' concept from visuals to audio.

Slide 41: Sound Machines and Songwriting

Building on the previous slide, this page outlines how to create 'Sound Machines.' It suggests picking random notes and filtering them to a set of keys (12 notes in a main array, 7 in a subset). It references the Berklee Guide: Melody in Songwriting and lists constraints like 'Use C-major' and 'No rests.' The challenge is to 'Record & make a song.'

Slide 44: Programming Paradigms and OpenSCAD

Slide 44 covers computer science fundamentals, including Object Oriented Programming , Logic Programming , and Immutable vs Mutable Data . It introduces OpenSCAD , a tool for functional 3D modeling where variable values are assigned last. A quiz at the bottom tests knowledge of paradigms (Functional, Imperative, Procedural, OOP, Declarative) and notations (Infix vs Prefix).

Slide 47: Comparative Analysis (3D vs Music)

This slide captures a group activity ('Noah & Me') comparing different modules. The author notes that 3D sketches are visual experiences, not auditory , and that music lacked a spatial component that week. A key insight is that 'Color theory & key signature are aesthetics' and both have 'mathematical properties.' This is the conceptual heart of the course: finding the shared mathematical DNA across different artistic mediums.

Slide 50: Self-Application and Tools

The final reviewed slide focuses on p5.play and tools for pixel art like Piskel . It mentions a 'Couch Co-op' coding challenge where two players sit next to each other and compete, citing 'Lovers in a Dangerous Spacetime' as an example. This shows the author applying generative concepts to game design and social interaction.

What Works in This Deck

Technical Depth: The deck does not shy away from the 'how.' It includes actual code logic, mathematical formulas, and specific library names, making it a valuable resource for other students. · Visual Learning: The use of handwritten notes combined with diagrams and photos of lab equipment makes the information more digestible than a standard textbook. · Process Documentation: By including 'Challenges' and 'Activities,' the deck shows the evolution of a project from a prompt to a technical solution. · Interdisciplinary Approach: The deck successfully bridges the gap between music, 3D printing, 2D graphics, and physics.

What is Missing

Business Context: As an academic deck, it lacks a market analysis, competitor landscape, or revenue model. It is not intended for commercial use. · Final Outcomes: While the notes explain the logic of the sketches, the deck (in the provided slides) does not show the final high-fidelity results of the 'Face Generating Tool' or the 'Laser Cut Poster.' · Narrative Flow: The deck is a collection of weekly notes rather than a cohesive story. A reader needs a background in coding to follow the transitions between slides.

Founder Takeaways

The 'Log' as a Portfolio: Founders building technical products can learn from this 'learning log' style. Documenting the technical hurdles and the logic behind a product's architecture can build significant trust with technical investors. · Constraint-Based Creativity: The deck highlights how setting strict mathematical constraints (like a 7-note subset or a specific frame rate) can actually lead to more creative outcomes. Founders can apply this to MVP development. · Visualizing Logic: The way this deck uses simple diagrams to explain complex concepts (like Markov Chains or CRT tearing) is a masterclass in technical communication. Founders should aim for this level of clarity when explaining their 'secret sauce.'