Final Project

As mentioned in the syllabus, our final project will be a finished, exhibition ready, work of online generative art. It should extend the work you've created earlier in the quarter, by either combining and/or iterating on one (ore more) of your prior assignments. Unlike your meditations (which are open ended explorations of generative art concepts and techniques) your final project needs to have a stated goal, context and title...

• Goal

  Why are you making this? If you're iterating on an older meditation, why that one? If you're combining pieces/concepts from a couple different ones, why those? What sort of reaction do you hope to get from your audience? Is there a specific message you're trying to get accross? a broader idea (or set of ideas) you want them to consider? a set of questions you'r asking or want your audience to ask? a shift in perspective you're hoping to trigger? a particular feeling or emotion you're aiming to invoke?
  
  For inspiration, consider returning to the various artists we've covered in class and think about what drives them. From the earliest computer artists like Lillian Schwartz and Vera Molnár to more contemporary generative artist like Mary Huang and Joshua Davis.
  
  Remember that generative art evolved from other artistic movements, including some we've discussed in class like Dada and Conceptual Art, many of the ideas which drove those artists like Tristan Tzara and On Kawara can be re-imagined for today, think about how your work fits into this larger history and how it can "respond" to the works that came before you.
  
  Consider what makes this medium unique and how you can leverage these characteristics for creative ends, for example the fact that the Web is a metamedia space, we can combine sound and image (like patatap) and other forms of data (like Aaron Koblin's work). Consider how randomness and other algorithmic techniques we've covered allow for creating works which are different each time someone visits our page, or how we can add all manner of interactivity to our piece. Your work can leverage all of these dynamics, but it doesn't have to, like our meditations it can be extremely focused on a single concept. In the end, it's up to you.



• Context

  Remember that half the planet has access to the Web, which means almost anyone anywhere in the world can easily experience our work, that said, they might be on any number of devices using any number of browsers. For this reason it is important to test your work across multiple browsers and screens (including resizing your browser window, don't forget that you can run code when the browser resizes).
  
  Consider too, our conversations from our Context Aware lecture and the way Evan Roth wrote his code so that it would function as intended on desktop devices, as well as mobile devices and projected in a gallery installation. Alternatively, rather than trying to support all those different context, we may have a piece that is meant to be experience on a very specific type of device or browser, in these cases we can use the nn library to target that specific context.



• Title

  Your work needs to have a title, this can be anything you want, but you should consider how that title "sets the stage" for your work. Often the title is the first thing someone might come across online when they read a post or click a link, how can you use this to further your goal, to ensure your audience enters it with the right mindset or perspective?
  
  You should also think about the relationship between the title and the domain name (your URL). Many of the works and artists we've looked at in class put a lot of thought and consideration into this relationship. Think about how Yung Jake and others play with TLDs in pieces like emoji.ink, or how Evan Roth references art historical tropes in his Tribute to Heather series, or how Rafaël Rozendaal exploits a domain's uniqueness to make this otherwise "public art" work sellable.
  
  

  Custom Domain

  There are numerious places you can go to register a domain name. Personally, I prefer namecheap (but you can use any online registrar you'd like). When you register your own domain, you'll need to let your registrar know that your website is hosted over on the GitHub servers (follow these instructions). Then over in your GitHub repo, navigate to your Settings tab, and then Pages sub-tab to add your custom domain (see video below).

Class Critique

To receive full credit for you final, the work must be submitted on canvas as a published URL (just like the prior meditation assignments) and must also be presented in class on either week 8, week 9 or 10 (finals week) for an in-class ~15 min critique. You will be given ~5 mins to introduce your work, your goal and any necessary context. The rest of the time will be spent giving/receiving critique as per our Critique Guide.

Local Workflows

It may be the case that netnet.studio provides exactly the sort of tooling you need to create your final project. However, if your project requires a more complex file structure or heavily depends on features like URL Parameters that might be trickier to test on netnet.studio, you could optionally choose to work in your own code editor. There are loads of professional code editors to choose from (they all look a little different, but ultimately all do the same thing) some popular editors include the the cult classic Sublime Text, the corporate choice VSCode and the open source Pulsar (formerlly "Atom"), my personal favorite (featured in the videos below)

Here's how you can take a project you started on netnet.studio and continue working on it locally with your editor of choice. First you'll need to visit your GitHub repository (or "repo" for short) by clicking on the "project-name/index.html" link at the top of netnet's editor. There you can copy the git URL. We can use that URL to "clone" our repo, which means make a copy that not only contains all the code/files but also the history of changes we've made since first starting the project.

Then open up your editor to clone your repo. You could also use a terminal, git clone https://github.com/YOUR-PROJECT-URL. NOTE: if you don't have "git" installed you may need to do download and install that first. Below is an example of how to clone a repo using the Pulsar editor: use the CMD+Shift+P shortcut to open the search bar, then search for "clone". Paste your clone URL into the first field, and make sure the path in the second field is creating your cloned copy in the location you want it.

You can open your index.html file directly in the browser to preview your work, but if your project includes JavaScript code that loads assets (like image or audio files) you'll need to run a server on your computer in order for your code to fully work. Just like there are loads of different browsers you can use to access the Web, there are also loads of different servers you can use to publish work on the Web, below I'm using a simple server (which you can download) that i created for Mac, Windows and Linux. But you could also use servers packaged with different languages like python or php (I have detailed notes on that here.)

The project being served by our simple server is only accessible by browsers on our computer. That is of course, unless we change our computer's firewall/sharing settings to allow others on our network to send us requests, that would make it accessible to anyone on the same WiFi (particularly useful when testing on your mobile device). We could also change settings on our WiFi router to "port forward" requests to our computer which would essentially make our project (served on our comptuer) accessible to anyone in the world (ie. officially published on the Web). That said, we don't want to commit our personal computer to hosting and serving our project, so instead we'll publish our work by sending our updates back to GitHub and using their server to share our work to the general public.

The video below demonstrates how to do that in Pulsar. We open the "Git" panel, then choose which of our changed files we want to send back (or "push") to our GitHub repo. Once we've chosen the filese we want (ie. "added them to our stage") we then write a small message associated with that change (just like we do on netnet) and then click "Commit to main". Once it's comitted, we can click the "Push" button to send those changes back up to GitHub.