The Case For Using Object-Oriented Languages In Creative Programming
The meeting point between coding and frameworks which allow for an intricate, modular and relatable interface for creating inventive pieces is generally built atop object oriented languages. This can be seen in a variety of different mediums and formats, such as scripting in Python while using Blender or making music with Sonic Pi by using Ruby (extremely liberal use of “dub techno” in the title of that one). I wanted to get more perspective on why this is the case and synthesize why OOP ends up being the primary choice for these outlets, and of course, share my findings with you!
Let’s think about the reasons why the concept of inheritance would make developing a framework which allows for creativity among the user more effective. Inheritance essentially means that properties of one type or class have the ability to be transmitted / passed / inherited to others and share those qualities without having to redefine them every single use case. Genes are a more abstract example of this principle, although the evidence of the inheritance is most transparent. What this means for applications is that through their inheriting class, values and properties will be easier to access and there is certainly a dimension of efficiency in this process, both for the use and for the machine. As a creator, having your canvas (so to speak) oriented in a way that does not require reinventing the wheel (so to speak) over and over again allows for a much more natural flow of ideas and the ability to act closer upon the artistic impulses that possess and enrich our lives without having to dwell or get lost in the woods of technical hangups, therefore is a paramount quality of OOP in these frameworks.
To recap on this concept, “polymorphism” is when different blocks of similar code are executed depending on the input case. Imagine you have a function which outputs a string when given a number (a fairly one-dimensional example). The output will be constant across all numbers, but let’s say we want different output for different number ranges such as a creature’s reaction to a temperature with the range being “solidified in a dimension of hyper-ice” to “obliterated by the strength of a couple thousand Suns”. In OOP, this principle can be applied through making copies of the same input / output method for varying input as to dictate what the output will be. Imagine you are trying to create a simple paint app like MS Paint and you are working on the “tools” section. You will want to have different effects on the canvas depending on where the cursor clicks and selects, and those properties to be stored somewhere auxiliary to just one function… This is where polymorphism is powerful, and also eliminates the propensity to write a ridiculous amount of if/else statements.
In my mind, gatekeeping is a deeply antithetical practice for anything conducive to creating anything beautiful and constructive for society. That being said, there should be no need to obscure the potential for more modular based outlets by have the requirement of learning a language like C in order to extend the functionality of an application like Blender. Object oriented languages are much closer to writing in English than assembly languages and therefore are much easier to grasp in concept and apply in practice, which makes for a really beautiful foundation for more code-based creative applications. Additionally, if one gets swept away in the idea of what’s taking place under the hood even further than the interface of something like Pure Data, then the user can always go deeper and deeper down the rabbit hole until they have an unbelievably comprehensive understanding of how a machine works, and then through understanding come the integration of becoming one with the machine as an individual and thus eliminating all human aspects and with it, the desire to produce art (not everyone’s endgame). A happy medium may be more with striving for in that case!