Week 2 – Reading Reflection

I really like using random elements in my work; both assignments so far have incorporated random elements because I feel like it adds so much movement and engagement with only a few lines of code. The computer program almost creates the art for you; you just have to give it a guiding path to follow. Even though I like randomness, there’s still specific visions I want it to follow. I use random as a way to represent reality and organic ways of forming images. For example, carefully placed and well-thought out placements of certain objects feel artificial; being able to simulate randomness means mimicking real life. 

The book of random numbers (million digits) in Casey’s talk mirrors my point; people use these numbers to simulate and test things in the real-world. It did get me wondering though, if multiple areas and teams are using this specific set of random numbers, would it eventually be unreliable? Depending on the context in which it’s used, I’m sure it doesn’t matter, but I just felt like if the whole point of these random numbers is to give unbiased data on society, they shouldn’t be reused over and over again. Another thought came to mind when watching the video: our universe is just a random simulator. What if our world was just programmed by someone who used randomness to let organic life move and form freely? This reminds me of the theory popularized by the Matrix about how we’re very likely living in a simulation because eventually, a civilized society will develop the ability to simulate worlds, which then can also simulate worlds, and so on. That means there are probably millions of simulated worlds and only one base reality; the likelihood of us being one in a million is unlikely. We might be a simulation to test a specific outcome, and that technology could be rooted in the randomness shown in Casey Reas’ talk.

Week 2 – Loops Artwork

Concept

For the second assignment, I will present a  series of squares that show contrast between a structure  black and white gradient and vibrant colors. When pressing the “Enter” key, the orderly monochrome arrangement becomes a more random, colorful display. At the time, I aimed to explore how colors can change randomly and how it can change a perception of an artwork

Code Highlight

One snippet i am proud of is this one:

//Loop pattern
 for (var i = 0; i < 20; i++){ // Loop through 20 columns
   for (var j = 0; j < 20; j++){ // Loop through 20 rows
     //Position and Size of the square
     var x = i * 50 + 25
     var y = j * 50 + 25
     var d = 25

This is because I was working on repeating the same code of using Variables of x, y, and d except changing the values, then I later found out, through a p5.js  tutorial by The Code Train on “Arrays and Loops” that there can be another loop to incorporate instead of copying the same lines of code over and over for rows to better calculate the positions and dimensions for each square in the grid.

Embedded Sketch

Reflections

Initially, I wanted the squares to rotate or spin upon pressing “Enter” using the rotate() and rotateX() functions, but there are challenges in structuring the lines of code, since at some point there are mistakes that disrupted my entire layout, leading me to use an alternative to incorporate randomly generated colors within the cubes.

I also referenced snippets from my past p5.js experiments, like using this from my last experiment with p5.js:

function keyPressed() {
if (keyCode === ENTER)
// Clicking between two assets :)
showGif = !showGif;
}

However, I modified it to change colors instead of changing gifs.

Overall, this was a really insightful experience and I plan on revisiting more concepts on loop functions along with rotating functions to help understand more as I experiment more with p5.js.

week-2 reading response

For this week’s reading reflection for Casey Reas’ lecture about chance operations, I have considered how randomness can be utilized in my work. In my current work in VR, I have seen that randomness could introduce an added level of immersive experience in my work. For example, having unpredictable environment shifts and interactions could generate a sensation of uncertainty, amplify the level of engagement for the user, and make them even more engaged in the experience. Nevertheless, a delicate balancing act must take place between randomness and control, for excessive randomness could disorient, and a lack of randomness could make the experience too rigid and lifeless. In my work, I’d like to experiment with randomness in bounded structures—generating a level of surprise but not compromising purpose and clarity of the experience.

The lecture challenged my thinking about randomness in my work. As I have liked having a level of control over my work, having calculated unpredictability in my work opens doors for new avenues for investigation and inquiry. It’s posed questions for me about an excessive level of randomness and whether an ideal sweet spot can stimulate and maintain a level of creativity and an involved level of user experience. Can excessive randomness destroy the narrative and emotional impact of a VR experience, or can it generate new dimensions of meaning? I’m interested in exploring these questions in my continued development of my work.

week 2-Morphing Ripple

concept:

“My artwork is derived from early computer graphics, with its use of dynamically changing, concentric forms. I‘d prefer to utilize symmetry and repetition in an attempt to produce a hypnotic rhythmic effect, similar to early computer artwork.”

highlight of the codes:

I’m particularly enjoying the loop structure I designed for generating concentric shapes with iteratively altering colors and dimensions. That recursive algorithm generates a rich, multi-colored effect that looks complex but is achieved with relatively simple code.

function setup() {  
  createCanvas(400, 400);  
  noFill();  
}  

function draw() {  
  background(0);  

  let x = width / 2;  
  let y = height / 2;  

  for (let i = 0; i < 10; i++) {  
    push();  
    translate(x, y);  
    rotate(frameCount * 0.01 + i * 0.1); // Rotate dynamically  
    stroke(0, 255, 255); // Cyan-colored square  
    rectMode(CENTER);  
    rect(0, 0, 6, 6); // Small square inside the circle  
    pop();  
  }  
}

 

the sketch I indetened to use

Week 2 – Calming Color Waves

Concept

For my art project, I initially aimed to create dynamic helix structures using sine and cosine functions combined with loops. I wanted something dynamic and wavy like in the image below I saw from the Computer Graphics and Art resource document;However, achieving a realistic 3D effect proved challenging. Despite this, my efforts were not wasted—they laid the foundation for my new project: Color Waves. Throughout the process, I discovered my passion for interactive art, balancing control with an element of randomness in the colors.

Code Highlight

I’m particularly proud of how I successfully integrated sine curves and loops to create a smooth, gradual increase in the size of both circles and squares.

for (let x = initial_x + offsetX; x < width; x += spacing) {
  for (let y = initial_x + offsetY; y < height; y += spacing) {
    let size = sin(frameCount * 0.05 + (x + y) * 0.01) * 15 + 30;

Reflection & Future Improvements

Although I didn’t fully achieve my original vision of a helix, I notably improved from my previous project as far as interactivity is concerned.  I also gained valuable insights throughout the creative process. This experience has deepened my interest in digital art, and I’m excited to explore and master 3D figures and objects in future projects.

CLICK 🙂

 

 

Week 2: Loops

Concept

While looking through  the old computer art magazines, I came across a design that instantly reminded me of pixels and TV static. The random arrangement of small squares felt similar to the scattered and colourful pattern on an old television screen.After seeing this, I wanted to recreate something along those lines, using code to generate a pixelated display that mimics this static.

This project was the perfect opportunity to experiment with loops and randomness, especially when it came to generating different colors for each pixel. So, by using a loop to fill the screen with these randomly colored squares, I was able to create a simple yet visually interesting effect that kind of recreated the essence of  this TV static.

Process

For this project, the TV frame and buttons were easy to set up, where I used  basic shapes like rectangles and ellipses.

//tv
fill(50);
rect(100, 100, 300, 220, 30);

// antenna
stroke(50);
line(150, 70, 200, 100); 
line(350, 70, 300, 100);
ellipse(150, 70, 10, 10);
ellipse(350, 70, 10, 10);

The most interesting part was creating the static effect on the screen. In this case I used used two nested for loops to generate the grid of small squares, each filled with a random color. This randomness gave the appearance of the moving static, similar to an old television with no signal. One challenge was making sure the pixels aligned correctly within the  shape of the tv, which required adjusting the starting and ending values of the loops. Once that was fixed, the effect worked well, and I liked how the simple loop and random color values could create something visually engaging.

  // pixels in tv
  for (let y = 120; y < 280; y += 10) {
    for (let x = 135; x < 355; x += 10) {
      fill(random(200), random(200), random(200));
      rect(x, y, 10, 10);
    }
  }
}

Reflections & Improvements for Future Work

Overall I’m very happy with how my project turned out. However if I were to improve this I could add more interactivity. To do this I could make the pixels change color when the mouse hovers over them or allow a mouse click to generate a new static pattern. I could also add like different channels to the tv, and add a remote control to allow the users to change channels.

Everchaging, Never Still. (Week 2 Assignment)

Concept

This concept originated from the fact that our lives are never still, and I recently have been getting more and more aware and educated about the importance of mental health which inspired me to do this design. The initial idea was inspired from this piece of art.

The core of the design lies within the order of our lives, which I will represent using a grid of rectangles with varying sizes to represent life responsibilities and events with varying importance which is relevant to the size of the rectangles. The grid then, after a set period of time, begins to mosh into itself creating a sense of confusion and loss of control, which will reset after the user clicks on the screen. This resembles the idea that, mental problems will follow people despite them avoiding them or not trying to get them. Then, to reset the grid, the user has to take action, not just give in into the moshing effect and allow the mental problems to consume them. After the user clicks, the grid comes back and the timer resets, but the grid doesn’t come back to the same initial state as some mental problems are life changing and can leave a scar.

Sketch

Code Highlights

  for (let i = 0; i < 10; i++) { // using a for loop as a timer
    timer++; // increment timer
  }
  
   if (timer >= timerLimit) {
// randomly mosh over time
}

This is my usage of a for loop for a timer, where the variables timer and timerLimit have been initialized as global variables.

 

let randomX = random(width); // grab random x location
let randomY = random(height); // grab random y location

let moshedArea = get(randomX, randomY, 30, 30); // get the specific area with the random x and y positions with size 30
let offsetX = random(-10, 10); // move the area randomly between a range of 10 and -10
let offsetY = random(-10, 10); // same thing

   // redraw the image
image(moshedArea, randomX + offsetX, randomY + offsetY);  }

This is how I did the moshing effect by grabbing random blocks in the sketch and offsetting them between a range of -10 and 10 pixels each direction. Here’s the link for the code I found online to help me/inspire me to write my own moshing code.

I wanted to use a while loop but that crashes my browser for some reason, potentially due to ram usage or the browser i am using is not compatible with p5, so I used the draw function for this effect which I interpreted basically as a while(true) loop.

 

For the drawing of rectangles, I made a function that draws rectangles through a for loop, where indices i andindicate the amount of rectangles the loop is gonna draw. Since the time complexity is O(n * n), therefore the loop below with n = 30, will iterate 900 times, creating 900 rectangles. This could be changed to illustrate the drawing in a different way.

The and variables are set to the counters i and j respectively then multiplied by the value rectSize, which determines the spacing between the rectangles.

This is similar to the following:

where the n in this case in either  or  j.

function drawGrid() {
  let rectSize = 20; // base grid size
  timer =0; // reset timer
background(0);
  for (let i = 0; i < 30; i++) {
    // rows
    for (let j = 0; j < 30; j++) {
      // columns
      let x = j * rectSize; // X position
      let y = i * rectSize; // Y position
      let w = random(1, 20); // width between 1 and 20
      let h = random(7, 20); // height between 7 and 20

      fill(0);
      stroke(255);
      rect(x, y, w, h); // draw rectangle
    }
  }
}

 

Reflection and self improvement

I wanted to rotate each square, but the process of doing that seemed a little bit out of my knowledge scope and I did not want to just copy what I found online without understanding, so I assume the next step would be stepping out of my comfort zone and learning concepts I am not familiar with like the use of rotation when drawing shapes. This is also not the exact use of data moshing as it is sometimes used for transitions when video editing, I want to implement that using code but that is a little bit too hard with the limited knowledge I have right now.

I would also love to add an effect of pixel sorting, which I usually used to do when I used to create my motion graphics videos, but now with p5.js this is a new realm that I want to explore slowly and not rush, so I will probably come back to this sketch and improve it more when I have more experience with p5.js and implement the pixel sorting effect.

 

Thank you for reading.

-Mustafa Bakir

Week 2 — Reading Reflection

When I was watching Casey Reas’ Eyeo’s talk on chance operations, I tried to bare in mind the question: “Where do you feel is the optimum balance between total randomness and complete control?”. Especially because I watched the talk after doing my artwork, I felt that the talk really aligned with the concepts that I envisioned for my assignment. For example, one example that he showed that left a lasting impression on me was Project Signals:

Basically, he explained that this artwork was a result of negative or positive communications that proteins sent within a cancer cell  — essentially a visualization of biology data. Without this context, I would have assumed that it was professional art from a painter or such because of how beautiful it looked. This realization in the assumptions that I made, made me realize that there’s art everywhere and that rather than computers replacing artists, they can serve more as a tool to help us create naturally occurring phenomena into art.

Referencing back to the initial question, I think there’s an important point to be made about the balance between how much randomness we incorporate into an artwork. More specifically, I think that it doesn’t actually matter if an artwork is created totally randomly or with complete control. I believe that the beauty in creating art lies in artist autonomy, even with the uses of computer technology. Of course, for this then we would have to engage in the conversation about AI ethics (e.g. How much of the artwork is truly by the artist), but I think that might be a conversation for another day. Ultimately, I believe that what matters is the intention behind the creation, whether an artist carefully designs every element or embraces randomness as a creative tool, both approaches are valid. In my opinion, the interplay between control and unpredictability can lead to unexpected beauty, and that, in itself, is an artistic choice.

Reading Reflection, Week 2

The interplay between order and chaos in art is certainly a must when it comes to modern day art, especially art that is created digitally. I would argue that the usage of randomness and order definitely depends on the context of the art piece itself, which could determine whether the artist should obey every drawing/sketching principle or go full dice mode and rely on randomness of outcomes.

For my own work this week, I am already in the process of creating an ordered set of rectangles and employing an effect of “data moshing.” Data Moshing is a technique in which the footage is manipulated to look ‘trippy’ or ‘glitchy,’ usually by manual compression (see reference)

The idea of data mosh is usually very random as it takes random pixel ranges from the screen and offsets them, creating a gltchy effect that confuses the brain for a split second then it gets processed by it. The idea of my work is for the user to have a sense of what the art piece was before the moshing begins, then over time, the image would distort and gets moshed into a glitchy image shaped by the randomness of how pixels are shifting. Then, I am to add interactivity by resetting the effect. I would like to think about this art piece as how mental problems affect coherence of our brains, and the user interactivity advocates for mental health awareness and to try to combat and fight those mental problems and not let them consume our “order and coherence” over time.

I think for the purpose of my art piece, this balance between order and chaos is seamless, as shifting the balance to any of the binary directions would result in a different message or would not convey my thoughts accurately.

 

-Mustafa Bakir

Week 2 : Graphic Art

This time, we had to explore the idea of structured randomness—using loops to create patterns that feel both intentional and organic. I was drawn to the symmetry and repetition found in mandelas, so I used circles, triangles, and leaf-like shapes to build a layered composition. While loops helped generate repeating elements, I also added variations in color, rotation, and placement to make the design more dynamic and to add more uniformity I kept the color scheme consistent with shades of blue for the shapes constituting the mandela.

One part of my code that I’m especially happy with is the layered circles in the background. Getting the balance right took more trial and error than I expected. At first, the colors felt too flat, so I adjusted the shades to match the overall theme to give it a sense of depth. I also had to tweak the positioning to avoid overcrowding while still maintaining a structured look and while doing all this I realized how much small details can change the overall feel of a design.

  // depending on grid created calculates spacing across vertical and horizontal axis between circles 
  spacingX = width / (cols + 1); 
  spacingY = height / (rows + 1); 

  // iterates through each position of grid through rows and columns and assigns differing attributes to each circle to ensure randomness but with even distribution across grid to ensure there's no over-crowding or empty spacing left
  for (let i = 0; i < cols; i++) {
    for (let j = 0; j < rows; j++) {
      let x = (i + 1) * spacingX + random(-20, 20); 
      let y = (j + 1) * spacingY + random(-20, 20);
      let circleSize = random(30, 80); 
      let growthRate = random(1, 2); 
      let maxSize = circleSize + random(20, 50);
      let c = color(random(150, 255), random(150, 200), random(200, 255), 150); 
      
      // adds each circle to array created to store attributes
      circles.push({
        x: x, y: y, circleSize: circleSize, growthRate: growthRate, growing: true,
        maxSize: maxSize, minSize: circleSize, col: c
      });
    }
  }
}

function draw() {
  background(255);
  noStroke()
  
  // iterates through array of circles and displays them on canvas
  for (let circle of circles) {
    fill(circle.col); 
    ellipse(circle.x, circle.y, circle.circleSize, circle.circleSize);

    // Growing and shrinking for added randomness
    if (circle.growing) {
      circle.circleSize += circle.growthRate;
      if (circle.circleSize >= circle.maxSize) circle.growing = false;
    } else {
      circle.circleSize -= circle.growthRate;
      if (circle.circleSize <= circle.minSize) circle.growing = true;
    }
  }
Reflection and Future Ideas

Something I found interesting while working on this project was how patterns emerge from simple logic. By repeating and slightly modifying positions of basic shapes, it’s possible to create intricate visuals without manually placing every element. It made me think about the way natural patterns—like those in flowers, shells, or even city layouts—often follow underlying mathematical principles.

Looking ahead, I’d like to push this concept further by incorporating interactivity. Maybe the colors of each layer could shift based on user input, or the shapes which make up each layer change randomly to create a more fluid, evolving mandela. I also want to experiment with layering more complex curves and incorporating randomness in a way that still feels balanced. This project has been a fun challenge in balancing structure and creativity, and I’m excited to keep refining my approach.