Siggy's Notebook

An Artist's Guide to C# in Unity3D: Classes

Siggy — Mon, 18 Jan 2021 13:00:35 GMT

This article is an addition to my series for code-leaning artists who want to learn Unity 3D. In this article we learn about functions and methods.

The series is available here.

Way back in lesson three of the Artist’s Guide to C# in Unity, we learned about common data types. These built-in data types are great for representing simple data values.

Need to track a player’s game score? No problem--use an integer

Need to set the speed of a ball? Check--use a float

Need to indicate if a character is alive or dead? Easy--use a boolean

Need to store a character’s first name? (Is this supposed to be hard?) Use a string

And on and on.

These work fine for many simple cases, but what if you need to represent something a little more complex or multidimensional like a box, or a dog or a whole character. Can we do this in C-sharp?

The answer is, “of course, we can!”

You can define your own “custom data type” and then create objects of this data type whenever you want. You define custom data types using something called a class--it's sort of like a blueprint. This blueprint is then used to create one or more instances of your custom data type--these are the objects you assign to a variable and use in your program.

So, to restate, a class is like a set of blueprints, and instances are the actual objects created from the blueprints. Each “blueprint” contains any number of internal attributes (variables) and behaviors (functions/methods) that make-up the object.

Parts of a class

A basic class definition adheres to the following format:

access_level class class_name {

   // attributes -- variables
   
   access_level data_type variable1;
   access_level data_type variable2;
   access_level data_type variable3;

   
   // behaviors -- methods

   access_level return_type method1(parameter_list) {
      // method body
   }

   access_level return_type method2(parameter_list) {
      // method body
   }

   access_level return_type method3(parameter_list) {
      // method body
   }

}

The only new part of this format to us is the class declaration line (access_level class class_name). This is where we name our class (our custom data type) and define its innards within a code block.

We will discuss the access_level towards the end of this lesson. The main thing to note is the keyword, class, which tells C-sharp that we are defining a custom class with the class_name we decide to give it.

A Class can be named anything as long as it starts with a letter and is not a pre-existing C-sharp keyword. The C-sharp convention is to use camel-casing for class names (e.g. BomberPlane, HarrierJet).

Let’s assume we’re creating some sort of ninja fighting game. We may want a custom data type to represent a ninja character type since we are likely to have several. We could declare a class to represent a ninja object. In your Fundamentals.cs script file, locate the space between the library import statements (the last line should be Using UnityEngine;) and the script top-level class which starts with this line:

public class Fundamentals: Monobehaviour { ...

Add the following code in that space.

public class Ninja {

}

We now have a valid class that we could use to create instances of Ninjas. Right now it’s empty so lets make it a bit more useful. I imagine there are some attributes of ninjas we may need in a game such as power level, health level, weapon, running speed and suit color. Lets add these attributes.

public class Ninja {
    int power = 10;
    int health = 5;
    float speed = 3.5;
    string weapon = “katana”;
    string suitColor = “red”;

}

Now that we have some basic attributes for our Ninja type, let’s give our Ninja class a couple of behaviors. I’d like our ninja object to be able to change weapons, change suit color and yell when instructed. Lets add those methods next.

public class Ninja {

	int power = 10;

	int health = 5;

	float speed = 3.5;

	string weapon = "katana";

	string suitColor = "red";

	public changeWeapon(string nextWeapon) {

		weapon = nextWeapon;

	public changeSuit(string nextColor) {

		suitColor = nextColor;

	public yell() {

		Debug.Log("Hee-yah!");

Your entire script file, if you’ve been following along, should look something like this:

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

public class Ninja

	private int power = 10;

	private int health = 5;

	private float speed = 3.5;

	private string weapon = "katana";

	private string suitColor = "red";

	public void changeWeapon(string nextWeapon) {

		weapon = nextWeapon;

	public void changeSuit(string nextColor) {

		suitColor = nextColor;

	public void Yell() {

		Debug.Log($"Yee-haw! I am a {suitColor} ninja 
                            with a giant {weapon}!");

public class Fundamentals : MonoBehaviour

        // Start is called before the first frame update

        void Start()

                Debug.Log("Unity Rocks!");

        // Update is called once per frame

        void Update()

We have now defined a class that we can use to create as many new Ninja objects as we want, anytime we want. Let's learn how to do that next.

Using a class

Once we’ve defined our class (the blueprint), we can use that class to create instances (objects) of our custom defined data type. The process of creating a new instance from a class definition is called instantiation. The way to instantiate new objects will be familiar to you--we simply use the new keyword when creating our variable much like we did when creating a new list object.

Let's create our first Ninja object. In the Start() method, add the following code:

Ninja ninja1 = new Ninja();

With our new instance let's ask it to Yell();

ninja1.Yell();

The console should now print out:

“Yee-haw! I am a red ninja with a giant katana!”

Lets create a second ninja.

Ninja ninja2 = new Ninja();

ninja2.Yell();

Right now, our second ninja prints out the same exact thing as the first one.

“Yee-haw! I am a red ninja with a giant katana!”

Let’s change this.

ninja2.changeWeapon("bo");

ninja2.changeSuit("purple");

ninja2.Yell();

ninja1.Yell();

Now, ninja2 prints

“Yee-haw! I am a purple ninja with a giant bo!”

While ninja1 prints

“Yee-haw! I am a red ninja with a giant katana!”

We could keep creating new instances of our Ninja class this way indefinitely. However, every time we create a new instance, the attributes like suit color or weapon are always the same at the beginning. What if we would like to create new instances but specify the suit color and weapon during instantiation? Well, we can do that using a special type of method in our class called a constructor.

Constructor methods are just regular class methods that are executed when the instance is created. Constructor methods must be named exactly the same as the class name and do not have a return type—they must be void.

For our example, we would like to provide a way to specify the suit color and weapon for each new ninja. This can be accomplished by adding two parameters on our Ninja constructor method. Let’s modify the Ninja class to look like this:

public class Ninja

	private int power = 10;

	private int health = 5;

	private float speed = 3.5;

	private string weapon = "katana";

	private string suitColor = "red";

	public Ninja(string weapon, string suitColor) {

		this.weapon = weapon;

		this.suitColor = suitColor;

	public void changeWeapon(string nextWeapon) {

		weapon = nextWeapon;

	public void changeSuit(string nextColor) {

		suitColor = nextColor;

	public void Yell() {

		Debug.Log("Yee-haw! I am a {suitColor} ninja 
                           with a giant {weapon}!");

We now have a constructor function which accepts two string variables--one for the weapon and one for the suit color. The constructor assigns these values to the object's weapon and suitColor variables respectively. The “this” keyword is C-sharp’s way of referencing the current object (self-referencing). This is how the compiler tells the difference between the weapon variable you’re passing as a parameter and the weapon variable that is an attribute of our ninja object.

Now, our instantiation call could look like this:

Ninja ninja1 = new Ninja("nunchuk", "blue");

It's important to note that this is now the only way we can instantiate a new Ninja object. The old method without parameters will no longer work. If we still wanted a way to instantiate ninja objects without specifying weapon or suit color, we would need to add a second constructor which doesn’t accept parameters like this:

Public Ninja() {

	Debug.Log(“Ninja created with default values”);

Lets add this to our file right before the existing constructor so our class looks like this:

public class Ninja

	private int power = 10;

	private int health = 5;

	private float speed = 3.5;

	private string weapon = "katana";

	private string suitColor = "red";

	public Ninja() {

		Debug.Log("Ninja created with default values");

	public Ninja(string weapon, string suitColor) {

		this.weapon = weapon;

		this.suitColor = suitColor;

	public void changeWeapon(string nextWeapon) {

		weapon = nextWeapon;

	public void changeSuit(string nextColor) {

		suitColor = nextColor;

	public void Yell() {

		Debug.Log($"Yee-haw! I am a {suitColor} ninja 
                           with a giant {weapon}!");

Now we can create our ninja objects like this:

// creates a ninja with default attributes

Ninja ninja1 = new Ninja();

// creates another ninja with these values

Ninja ninja2 = new Ninja("crossbow", "green");

ninja1.Yell(); // Yee-haw! I am a red ninja with a giant katana!

ninja2.Yell(); // Yee-haw! I am a green ninja with a giant
               // crossbow!

Other details about classes (access and scope)

Now that we understand how to use classes, let's finally talk about those access_level keywords we keep running into. Access level keywords, or access modifiers as they are called, determine how “visible” a particular variable, method or class is to other objects in your program. Every C-sharp program runs within what’s called a program assembly (a bundle of all the classes and libraries compiled together as part of your program’s executable).

The main visibility levels are:

Public -- these methods and variables can be accessed by any code with access to the object whether in the same assembly or not.
Protected -- these methods and variables can only be accessed by code in the same class or subclass (subclasses are classes derived from a parent class--no need to worry about them for now until we learn about inheritance).
Private -- these methods and variables can only be accessed by code in the same class.
Internal -- these methods and variables can only be accessed by code in the same assembly.

If you skip declaring an access level, then a default visibility is used--class variables and methods default to private while classes default to internal.

Access levels are best illustrated with an example. We’ll largely be concerned with just the public and private access levels. So, let's revisit our Ninja class example in our script.

Right now the Fundamentals script is running in a class of its own as you can surmise from the code. The Fundamentals script and the Ninja objects created within it are logically separate objects.

In the Start() function of the Fundamentals script, we instantiated a ninja object and then called its .Yell() method. We were able to do this because the .Yell() method was created with a public access level. If we had created the function with a private access level, the call would have failed.

The same logic applies to the variables in our Ninja class. Go to your Ninja class code and change the power level attribute to public for now.

public int power = 10;

Now in the Start() function of Fundamentals.cs try the following:

Ninja ninja1 = new Ninja();

ninja1.power = 20;  // since power is public, this works

Debug.Log(ninja1.power);  // ...and so does this

// However, if you try this, it will fail:

// this fails because suitColor is set to private
ninja1.suitColor = "black";

Private attributes can only be accessed by code within the class.

This sort of access level restriction is beneficial for code design, data security, proper encapsulation and separation of concerns within a program’s design. These benefits will become clearer the more you code and the larger your projects become.

The last thing worth mentioning here is variable scope. This refers to which variables can be accessed from different blocks of your code. This is different from access level modifiers which are enforced at runtime. Variable scopes are enforced at write-time, or compile time.

Let's revisit the Ninja class. I’ll add some new comments, a new private variable (BoxOfTricks) and a new method (ShowTricks).

public class Ninja

	// Scope:  All variables declared within this class block
        // have class scope and can be accessed by all code in 
        // this class

	private int power = 10;

	private int health = 5;

	private float speed = 3.5;

	private string weapon = "katana";

	private string suitColor = "red";

	private List BoxOfTricks = new List() {

		"Cyclone Kick",

		"Shuriken Flurry",

		"Invisibility Cloak"

};

	public Ninja() {

		Debug.Log(“Ninja created with default values”);

	public Ninja(string weapon, string suitColor) {

		this.weapon = weapon;

		this.suitColor = suitColor;

	public void changeWeapon(string nextWeapon) {

		// Scope:  the nextWeapon parameter is passed into
                // this method and has method level scope only. 
                // So, it does not exist outside this method.  The
                // same applies for any variables declared within
                // a method.

		// As you can see, the weapon variable can be
                // accessed here because it has a class level scope

		weapon = nextWeapon;

	public void changeSuit(string nextColor) {

		suitColor = nextColor;

	public void Yell() {

		Debug.Log($"Yee-haw! I am a {suitColor} ninja with 
                           a giant {weapon}!");

      	public void ShowTricks() {

		// Scope:  BoxOfTricks is accessible because it was
                // declared at the class level but the i variable
                // is created in the for loop block, so it’s not
                // accessible outside this block. It has block
                // level scope only.

		for(int i = 0; i < BoxOfTricks.Count; i++) {

			Debug.Log($"Behold my {BoxOfTricks[i]}!");

		// the i variable does not exist here

The rule of thumb with scope is that variables are accessible only within the code block they are declared within. These code blocks are usually at the:

Class level -- the variable can be accessed only within the class it is declared
Method level -- the variable can be accessed only within the method it is declared
Block level -- the variable can be accessed only within the code block it is declared, such as a looping block

That’s a wrap on the concept of classes. You’ll find yourself using classes extensively because they are a fundamental aspect of object-oriented design. When applied well they promote good code design and structure. So let’s get a little practice using classes.

Try it out

You’ve been tasked with creating a set of class structures to represent characters in your new game and the characters’ weapons. Here is your brief:

Create a class to represent a warrior.

Warrior attributes are

Name
Warrior type (Amazonian, Hulkian, Monkian or Smurfian)
Health (0 to 100)
Power (0 to 10)
Sigil color
Weapon (created from the Weapon class)
Goodie bag

Warrior behaviors are

Greeting -- Print a hello message with their name
Strike -- Print the damage amount they can inflict which is:
weapon’s damage amount * warrior’s power
Take Hit -- decrease the Health score by the damage amount passed to this method
Inventory -- Print what’s in their Goodie Bag
Empty Bag -- ability to empty the bag at once (clear it)
Select Item -- ability to pick an item from the bag using the name of the item
Stash Item -- ability to place items into the bag by name only
Discard Item -- ability to remove and discard an item from the bag

Create a class to represent a weapon (which can be owned by the characters).

Weapon attributes are

Weapon type (sword, battle axe, crossbow, spear, machete, slingshot, morningstar, club)
Damage amount (1 to 5)
Weapon ID

Create instances of the different warrior types and assign them different types of weapons.

Have fun with this exercise and see if you can get the striking and “take a hit” functions to work correctly between combatting warriors.

An Artist's Guide to C# in Unity3D: Functions and Methods

Siggy — Mon, 21 Dec 2020 03:45:22 GMT

This article is part of an ongoing series for code-leaning artists who want to learn Unity 3D. In this article we learn about functions and methods.

Read Previous: Flow Control

Congratulations for making it this far, you motivated learner!

This is the last topic in our C-sharp fundamentals section. After this, you could pretty much write your own game with the knowledge you already have—pretty much.

So, let's continue with functions and methods. For our purposes, I’ll use the terms function and method almost interchangeably. The difference between a function and a method is purely contextual—similar to the difference between a man and a husband (or a woman and a wife). A husband is just a man within the context of matrimony. All husbands are men, but not all men are husbands.

The same applies to functions and methods. All methods are just functions that are associated with an object. Incidentally, in C-sharp all functions are associated with an object, so the difference is negligible. We’ll learn more about objects in an upcoming lesson about classes.

For this lesson let's stick mostly with the term function. Where I use the term method, you can understand that to mean the same thing as function.

Function Basics

A function is a chunk of code that you assign to an identifier, the same way a variable is a piece of data that you also assign to an identifier. If a variable is a container for data, then a function is a container for code. We use functions for organization, good program structure and code reusability.

If we view functions as containers for code, we should mention a few things about this container. For one thing, once the code is written, it helps to think of the function as a black box, or at least a self-contained box. This box accepts specific input data from one end, crunches this data internally, and then spits new data out of another end.

The basic syntax looks like this:

access_level return_type function_name(parameter_list) 
{
    function_body
}

The components of a function are:

function name — this is the identifier you’ll use to reference and call the function
parameter list — the input data provided to function, usually represented as a comma-separated list of variables. If the function doesn’t accept any parameters this is left blank.
function body — this is your function’s code—the guts of the function. Every time the function is called, this code is executed from top to bottom.
return type — when the function is called it returns a value of this data type
access level — functions have different access levels to determine who (which objects) can call them. It makes more sense to cover this in an upcoming lesson about classes, so I won't say anymore about this here. We will skip the access level for all our examples in this lesson.

Let’s look at the example of a temperature conversion function. This function could accept a temperature value in Fahrenheit, run its internal conversion equation, and then output a new temperature value in Celsius. We’ll call the function TemperatureConverter.

If you’re using the Fundamentals.cs file, place the following code right after the Start() method—just below the bottom curly brace ( } ) but before the Update() method.

float TemperatureConverter(float fahrenheit) 
{
    // our code will go here
}

In the code above, we skipped the access level and started with the return type. Since this is expected to be the temperature value in Celsius, we opted for a data type of float. Then we used the name TemperatureConverter followed by a list of parameters (expected inputs) enclosed in parentheses. We’re only expecting one input variable so we list it with the right data type and name it accordingly—float fahrenheit.

Right now, our function body is empty. It just contains the comment, “our code goes here”. Let's make it do some real work and properly return the Celsius value.

float TemperatureConverter(float fahrenheit) 
{
    // we use the fahrenheit-to-celsius conversion equation 
    // to get the celsius value, 
    // then we assign it to a variable

    float celsius = (fahrenheit − 32) * 5/9; 


    // then we return the celsius value as the output

    return celsius;  
}

There.

We have a functional TemperatureConverter, umm… function. Let’s use it in code.

In the Start() method lets add some more code that calls the TemperatureConverter. Modify the method to look like this:

void Start() {

    float fahrenheit = 36;  // 36 degrees Fahrenheit
    float celsius;          // no value yet

    // now call our converter function to get a celsius value
    // Note: the data type of the variable passed to the 
    // function must match what the function expects

    celsius = TemperatureConverter(fahrenheit);
    Debug.Log($"{fahrenheit} Fahrenheit is {celsius} Celsius");

}

This is great so far.

Right now our function is only useful if we have a Fahrenheit value and want to convert it to Celsius. What about going the other way? Passing a Celsius value to get a Fahrenheit value back? Well, one option is to write another function, just like the one we have, to convert from Celsius to Fahrenheit values. However, that seems like doubling our work for not much gain.

What if we modified our function to accept a second parameter that indicates what type of value we are providing. Then we would know which type of value to return.

For example, if we passed the values 36 and “fahrenheit”, the function would know it was receiving Fahrenheit readings and therefore return a Celsius value. However, if the second parameter was “celsius” then it would convert to and return a Fahrenheit value.

Let’s make those changes to TemperatureConverter.

float TemperatureConverter(float temperature, string scale) 
{
    // declare a local variable that will hold our new temperature
    float convertedTemperature;

    // we create a set of  if-else clauses, to check 
    // the scale parameter

    if (scale == "fahrenheit") 
    {
        // convert to celsius
        convertedTemperature = (temperature − 32) * 5/9;
    }
    else if (scale == "celsius")
    {
        // convert to fahrenheit
        convertedTemperature = (temperature * 9/5) + 32;
    }
    else{
        // print error message if scale is unknown
        Debug.Log("Error: Unrecognized temperature scale!");
    }

    // then we return the converted value as the output
    return convertedTemperature;  
}

Now the code in the Start() method should be changed to something like this:

void Start() {

    float temp = 36;  // 36 degrees Fahrenheit
    string tempScale = "fahrenheit";
    float convertedTemp;
    string convertedScale;

    // Now call our converter function to get a celsius value
    // Note: the data type of the variable passed to the 
    // function must match what the function expects

    convertedTemp = TemperatureConverter(temp, tempScale);

    // show the right convertedScale to use in the print message
    if (tempScale == "fahrenheit")
    {
        convertedScale = "celsius";
    }
    else if (tempScale == "celsius")
    {
        convertedScale == "fahrenheit";
    }

    Debug.Log($"{temp} {tempScale} is
                {convertedTemp} {convertedScale}");

}

Play around with the temp and tempScale values to get different results.

Finally, what if we want to create a function that doesn’t return any values. Maybe a function that just prints the current date and time to the console and nothing else. Functions with no return value use the keyword void as their return type—as in, they return a void.

Here is our function to print the date and time.

// The function uses the void keyword to indicate that it 
// doesn’t return anything. It's parameter list is also empty
// because it doesn’t take any parameters

void PrintTimeNow()
{
    // we print the current time and date 
    // using C#'s built-in DateTime object

    Debug.Log(DateTime.Now);

}

Add a line in the Start() method to call this PrintTimeNow function.

PrintTimeNow();

Now the date and time gets printed to the console as expected.

Try it out

Time to practice creating different functions on your own. Here are a few exercises to test your knowledge.

Create a function to calculate the area of a circle. The formula for calculating a circle’s area is area = pi * (radius * radius). Use 3.14 for the value of pi. The function should accept just one parameter—radius—and return the area of a circle with the given radius.
Write a function that takes an integer between 1 and 7 and returns the corresponding day of the week spelled out. So, 1 should return “Sunday”, 2 should return “Monday”, 3 should return “Tuesday” and so on. Do the same for the months of the year (1 - 12).
This last exercise is closer to something you’re likely to write during game development—a function that inflicts health damage on a character. To start with, create a variable to store your character’s health and set it to 10 (remember to place this just above the Start() method).

Next, create a function called DamageHealth which accepts one integer parameter called damage. This is the amount of “damage” to subtract from the character’s health. Add code to prevent the health score from dropping below zero (0). Print the health value after each call.

Congratulations!

Give yourself a well-deserved pat on the back.

You now understand the fundamentals of C-sharp. And, believe it or not, you could write a full game with the knowledge you currently possess.

You could branch off from here and start experimenting with creations of your own, or you could continue with the upcoming lessons to gain intermediate knowledge and try your hand at some guided projects.

An Artist's Guide to C# in Unity3D

Subscribe now

An Artist's Guide to C# in Unity3D: Flow Control

Siggy — Fri, 18 Dec 2020 21:40:23 GMT

This article is part of an ongoing series for code-leaning artists who want to learn Unity 3D. In this article we learn about mechanisms for controlling the execution flow of your programs.

Read Previous: Collections

We’ve learned quite a bit already about coding in C-sharp--variables, data types, operators and collections. However, we still can’t do much in our programs without a way to:

Make branching decisions
Conditionally repeat an action or block of actions
Iterate through items of a collection

For example, say you have a list of 100 city temperatures in Fahrenheit and wish to convert all 100 values to Celsius. How would you do that? You need a way to run through your entire list and perform the conversion equation on each value.

Or say you have a player character running around in your video game world. You’ve placed several different types of objects around the world for the character to run into. Some objects may be coins to add to his wallet, health tokens to give him extra health points or poisonous bushes that reduce his health points. You would need a way to make decisions based on what type of object your player has collided with.

These are all examples of flow control in a program’s structure.

Making branching decisions

The primary device for making branching decisions is the logical if-else statement. It tells your program to execute one block of code if a set of conditions is true, but execute a different block of code if those conditions are false. The basic form looks like this:

if ( expression_is_true) 
{
   // Run all the code in this block
}
else 
{
  // ...run the code here instead
}

The expression_is_true should be replaced with an expression that the compiler can evaluate into a boolean value. This likely means using logic or comparison operators.

Here’s an example. Your character stumbles on a clover and you would like to print different messages depending on the number of leaves found on the clover.

int cloverLeaves = 4;  // set to 4 or some other number

if(cloverLeaves == 4)
{
    Debug.Log("Yippee! Today is my lucky day!");
}
else 
{
    Debug.Log("Shucks! No luck today!");
}

In this example, the statement in the if-clause checks to see if cloverLeaves is equal to 4. It then proceeds down one of two paths, depending on whether that statement is true or not. This is the most basic form of branching you’ll create.

You can also have the if-clause alone, if your logic doesn’t require an else-clause.

if(cloverLeaves == 4) 
{
    Debug.Log("Yippee! Today is my lucky day!');
}

There is also an if-else-if statement you can use. This adds an extra evaluation clause and code block to the entire construct. For example, what if we also want to check if the clover has 5 or more leaves? Our code would look like this

if(cloverLeaves == 4) 
{
    Debug.Log("Yippee! Today is my lucky day!");
}
else if (cloverLeaves >= 5) 
{
    Debug.Log("Today is an unusual day!");
}
else 
{
    Debug.Log("Shucks! No luck today!");
}

We now have three possible branches our code could take depending on the value of cloverLeaves. It's important to note that when our running program encounters this code, it will only select one of these branches to run, before continuing through the rest of your program.

At this point, you may be wondering if you can add more else-if clauses to this structure. The answer is, “yes!”

You can add as many else-if clauses as you like. Let's add another one to handle a clover with three leaves or fewer. I’ll rearrange the order of the clauses so the conditional numbers are arranged incrementally--it's just easier to read and understand.

if (cloverLeaves <= 3) 
{
    Debug.Log("Meh! Nothing special today!");
}
else if (cloverLeaves == 4) 
{
    Debug.Log("Yippee! Today is my lucky day!");
}
else if (cloverLeaves >= 5) 
{
    Debug.Log("Hmm, today is an unusual day!");
}
else 
{
    Debug.Log("Shucks! No luck today!");
}

Ok, now I would like to add yet another clause to handle exactly two leaves. I could add it to my existing stack of clauses, but at this point it's starting to get a bit long for my liking. If you have more than four or five branches to string together, there is another feature we can use called a switch statement.

Switch statements take an expression and then execute the code block that exactly matches the expression value. Each code block in a switch statement is labeled with a case clause which must be a literal data value and NOT a variable. There is no limit to the number of cases allowed in a switch statement block.

The syntax for a switch statement looks like this:

switch(expression) {
   case literal_value1:
      // this code runs if expression == literal_value1
      break;
   case literal_value2:
   case literal_value3:
      // this code runs if expression == literal_value2 or
      // expression == literal_value3
      break;
   case literal_value4:
      // this code runs if expression == literal_value4
      break;
   default:   
      // this code runs if expression does NOT match any of 
      // the literal values above
      break;
}

Additionally, every case clause must be terminated with a break statement. The last clause is simply called default and will run if none of the previous case clauses match the expression.

Default clauses are optional.

Let's refactor our clover leaf branching logic to use a switch statement instead of a string of if-else statements. We’ll also add the extra code to handle clovers with two leaves.

int cloverLeaves;  // assign this to any number between 2 and 5

switch(cloverLeaves) {
    case 2:
        Debug.Log("Ooh, you better go ring shopping!");
        break;
    case 3:
        Debug.Log("Meh! Nothing special today!");
        break;
    case 4:
    case 5:
        Debug.Log("Yay! It’s a lucky day!");
        break;
    default:
        Debug.Log("Dude! Are you sure it's even a clover leaf??");
        // this clause will run if cloverLeaves is set to anything
        // other than 2, 3, 4 or 5
}

Conditionally repeat a block of actions

Sometimes you may need to repeat an action or group of actions several times. We’ll start by learning two ways of implementing loops in C-sharp.

for loops
while loops

These loops accomplish the same thing--repeating a particular block of code one or more times. However they accomplish this in different ways depending on the scenario.

for loops

for loops are best used when you know how many times you want your code block to run. The basic syntax is:

for (initialize counter; termination expression; increment counter) 
{
	// this code will run multiple times until 
        // the termination expression is false
}

So what’s going on here? The for statement has three parts to it.

A counting variable (usually an integer) must be initialized to a starting value like 0.
Before each attempt to execute the code block, the program checks the termination expression. If the expression evaluates to true, then it executes the code block. If the termination expression evaluates to false, it will terminate the loop and continue with the rest of your program.
After every execution of the code block, the program increments the counter by a specified amount—usually 1.

Let’s look at a trivial example.

Remember when you had to write lines in school for punishment? (Or am I the only one?)

I once had to write the following line 100 times:

“I will not pour glue on my neighbors chair!”

If I knew how to code back then, I could’ve saved myself a lot of time. Using a for loop I could’ve done it this way:

for (int i = 0; i < 100; i++) {
    Debug.Log("I will not pour glue on my neighbor’s chair!");
}

That’s all there is to it.

We initialize a variable (the convention is to use an i) to 0. The termination expression is a check to see if i is less than 100. After each loop, we increment i by 1 using the ++ operator. There is nothing special about incrementing by 1. If your logic required it, you could increment by any number like 4— i += 4. But then it wouldn’t repeat 100 times, right? And I’d still be in detention.

while Loops

In some other scenarios you may not want to loop your code a fixed number of times. Perhaps the type of loop you would like to create doesn’t depend on a strict counter.

Let’s consider the example of continuously outputting an “S.O.S” message until it has been received by someone. You could create a received variable and set it to false. Then repeatedly print the SOS until received is set to true.

while loops look like this:

while (termination expression is true) {
    // run this code ..
}

Simple enough, right? The thing with while loops, is that it’s up to you to make sure your termination expression evaluates to true at some point, otherwise the loop will run forever. Or at least until your machine crashes. Seriously.

Following this syntax, our example would look like this:

bool received = false;

while (received == false) {
    Debug.Log("S.O.S");
    // This message would print continuously, 
    // until confirmation is set to true
}

Note: If you’re running this program in your Fundamentals.cs file from lesson two, you’ll need a way to set the received variable to true otherwise this loop will run forever. Let's modify our code so that received is flipped to true after 20 loops.

bool received = false;
int counter = 0;

while (received == false) {  
    Debug.Log("S.O.S");
    
    if (counter > 19) {
        received = true;
    }
    counter++;
}

Iterate through items of a collection

Ok, now the last set of flow controls we’ll discuss is how to loop through all those fancy collections you learned about in the previous lesson.

We can use for loops and while loops to accomplish this. Let’s start with a for loop.

Given this array:

String[] turtles = 
new string[4] {"Leonardo", "Michelangelo", "Raphael", "Donatello"}

We can write a simple iteration loop to pull each name from our array and print it out.

Let’s recall the standard loop syntax for this:

for (initialize counter; termination expression; increment counter)  { 	
    // this code will run multiple times until          
    // the termination expression is false 
}

We’ll set our initial counter variable to 0.
We want the looping to stop once the counter reaches the end of our array.
We will increment the counter by 1.

Putting that all together, our loop will look like this:

for (int i = 0; i < turtles.Length; i++)
{
    // we use i as the index of the item we want to retrieve
    // since i will be incremented from 0 through to the end
    // of the array we can use turtles[i] 
    // to get the array item

    Debug.Log($"Here comes {turtles[i]} to kick Shredder's butt!");
}

We can achieve the same thing with a while loop. We just have to provide and increment our own counter. Given the same array, here’s what a while loop would look like:

int index = 0;

while (index < turtles.Length) 
{
    Debug.Log($"Here comes {turtles[i]} to kick Shredder’s butt!");
    index++;  // increments our counter at the end of each loop	
}

Looping through arrays and looping through lists are almost identical. The only real difference is using .Count to get the size of the list instead of .Length for arrays.

Here’s a for loop:

List turtles = new List() {"Leonardo", "Michelangelo", "Raphael", "Donatello"};

for (int i = 0; i < turtles.Count; i++) {
    Debug.Log($"Here comes {turtles[i]} to kick Shredder’s butt!");
}

And the while loop:

int index = 0;  

while (index < turtles.Count)
{     
    Debug.Log($"Here comes {turtles[i]} to kick Shredder’s butt!");
    index++;  // increments our counter at the end of each loop	 
}

There is another type of loop called the foreach loop which is commonly used for iterating through collections. Rather than use an incrementing index for referencing the items in the collection, foreach gives you the actual item as a variable in each loop iteration.

The basic syntax is:

foreach ( data_type variable in collection) {
    // code goes here to do something with variable;
}

Using our collection of turtles, a foreach loop would look like this:

foreach (string turtle in turtles) {
    Debug.Log($"Here comes {turtle} again!"); 

    // the variable, turtle, is the actual value retrieved 
    // from the collection or turtles--no indices needed
}

The foreach loop is particularly useful for looping through collections like dictionaries which aren’t indexed by number. Looping through a dictionary requires the use of a new data type we haven’t encountered yet called a KeyValuePair. This is a special data type for storing key-value pairs of a dictionary item.

The syntax for the key value pair looks like this:
KeyValuePair, where the data_types match the dictionary to loop through.

First, let’s create our dictionary:

Dictionary ninjaTurtles = new Dictionary() {
    {“Leonardo”, “Leader”},
    {“Donatello”, “Hacker”},
    {“Raphael”, “Brawler”},
    {“Michelangelo”, “Party Boy”}
};

Now we’ll use a KeyValuePair to match the data types of our dictionary.

foreach ( KeyValuePair item in ninjaTurtles) {
    
    // Now we can access the key with item.Key 
    // and the value with item.Value

    Debug.Log($"{item.Key} is the {item.Value}!");
}

This will print out:

Leonardo is the Leader!
Donatello is the Hacker!
Raphael is the Brawler!
Michelangelo is the Party Boy!

Try it out

We’ve covered a lot of territory in this lesson. Understanding and using proper flow control is a fundamental aspect of writing code. The good thing is that these are just syntactic concepts to represent the way we naturally reason as human beings.

Let's get a little more practice before we move on to the next lesson.

You’re writing code for a quality assurance robot at a toy factory. The robot receives a list of toys each with a quality score assigned. Quality scores range between 0.0 (if it's utter crap) and 10.0 (perfect). It's the robot’s job to sort the toys into the following bins according to their quality scores.

Discard bin: 0 to 2.50
Re-fabrication bin: 2.51 to 6.50
Refinishing bin: 6.51 to 8.0
Shipping bin: 8.01 to 10.0

Here is your quality test data. Copy-and-paste this into your script.

Dictionary toyScores = new Dictionary {
    {"Z00M56R", 6.9},
    {"Z00M14R", 7.8},
    {"Z00M91R", 1.33},
    {"Z00M28R", 9.93},
    {"Z00M66R", 3.97},
    {"Z00M72R", 6.5},
    {"Z00M39R", 8.55},
    {"Z00M87R", 2.509},
    {"Z00M43R", 0.248},
    {"Z00M15R", 4.41},
    {"Z00M07R", 9.01},
}

Create suitable collections to represent the four different bins. All they need to store is the toy’s serial id.
Iterate through the toy scores and place each toy in its correct bin.
Once the toys are sorted, print out the contents of each bin. How many toys are in each bin? Print that out too.

Next, we’ll learn about functions and methods—the last topic of this introductory series to the fundamentals of C-sharp.

An Artist's Guide to C# in Unity3D

Subscribe now

7 Myths about Creativity

Siggy — Wed, 16 Dec 2020 12:45:50 GMT

Photo by evesandbox

If your friend circles are anything like mine then you’re probably sick of hearing this question:

What is creativity?

Pose this question to ten different neuroscientists and psychologists and you’ll get ten different answers. Trust me, I’ve asked.

In all fairness, there are some consistencies across the different responses I’ve received, however any hope of consensus around a definition of creativity is still in the distant horizon.

After reading several dozen books about the topic of creativity (there are millions), I’ve noticed that even though experts may disagree on a definition of the word, they share broad agreement on what creativity is not. More surprisingly, what they have discovered often contradicts popular beliefs about creativity.

Even though experts may disagree on the definition of [creativity], they share broad agreement on what it is not.

So in our ongoing attempts to understand our creativity, here are some myths about the process that you should definitely put to rest.

Myth 1: Only a chosen few are born creative

The prevailing man-on-the-street wisdom is that certain people are born creative while others are not. Some may even cite anecdotal evidence about their friend, cousin or brother who could “always draw,” forgetting that most children up to a certain age, enjoy drawing.

There is overwhelming evidence from recent brain science which shows that human beings are not born with a fixed creative capacity. In fact, it's quite the opposite. What we recognize as creativity can be expanded and improved with effort much like training a muscle. Furthermore, this improvement can be accomplished at any age.

People who “appear” to be creative from birth just have more immediate agency over the brain states that facilitate creative work. For instance, most human beings are born with the ability to breathe on their own--it's not a special trait. However, not every successfully breathing human being knows how to use their breathing to control mood, mental state or cognitive function. This sort of proficiency can be acquired early or late in life.

Myth 2: Painters and poets are creative but certainly not doctors or accountants

People often associate the word “creative” with individuals who have chosen a profession in the arts of some kind. They think of poets, painters, and musicians as creative but fail to draw the same conclusion about professions in the sciences.

The start-up accountant who figures out how to extend the life of his cash-strapped firm for another three months is being just as creative as the poet who pens a new sonnet. Physicists developing new theories, entrepreneurs developing new services or products and doctors diagnosing and developing new treatments for diseases are all exercising tremendous creativity.

A helpful way to understand the universality of creativity is not to think of the practitioner as a “creative,” but to think of the person as engaging in “creative thinking.” Viewing creativity as a mode of thinking regardless of the domain emphasizes just how pervasive it is in humans.

Myth 3: People are Left-brain or Right-brain dominant

This model about how the brain is structured, though once useful, is now widely believed to be inaccurate and a bit antiquated. The idea that humans are either left-brain or right-brain dominant originated from a series of studies conducted on patients who had their corpus callosum severed.

In these patients, their left brain hemispheres could no longer communicate with the right one. And a series of interesting behaviours were observed as a result. For example, some patients could recognize and read letters and symbols with their right eye but not their left (the right side of the brain controls the left side of the body and vice versa). Or could hum along with a tune piped into their left ear but not their right one.

Based on such compelling results, scientists developed the familiar left-brain, right-brain model of brain function. The left brain is believe to specialize in rational, analytic thought like mathematics and language processing, while the right brain specializes in more non-verbal tasks like spatial awareness, music, emotion and intuition.

Current brain-imaging software has revealed that this simple left-right delegation of tasks to particular brain hemispheres isn’t exactly accurate. There is far more cross-communication between the hemispheres on all tasks than was previously thought. Although there is some degree of hemispheric specialization, most brains engage both hemispheres quite dynamically on many tasks.

It's actually more accurate to think of different brain states for different types of activities rather than different brain regions handling one type of activity over others.

Myth 4: Mental illness improves creativity

Forget all the Hollywood lore and popular fiction fetishizing the “mad genius” or “tortured artist.” Despite well known examples like Van Gogh, Howard Hughes or Nina Simone, there is no evidence to support a link between mental illness and enhanced creative output. Such famous examples remain the exception, not the rule.

Despite the perception, highly creative individuals with mental illnesses still make up a tiny percentage of the larger pool of creative exceptionals. In fact, upon further investigation artists like Van Gogh and Sylvia Plath were creative despite their illness, not because of it.

The image, though, is a persistent one. This could be because of what creative researcher, Scott Kaufman, calls the “messy creative mind.” He reports that highly creative minds are often characterized by a compendium of paradoxes, capable of maintaining contradictory extremes such as fierce individualism and devoted collectivism, a high tolerance for disorder but an ability to thread order out of chaos.

Such extremes in the same person may lead observers to conclude that creatives are mentally unstable when in fact, they are quite psychologically sound.

Myth 5: Creativity is an individual endeavour

Consider this assertion, Thomas Edison invented the lightbulb. Or this one, Steve Jobs created the iPhone. As much as we love to repeat them, both statements are of course, false.

Thomas Edison employed an army of engineers at Menlo Park and so did Steve Jobs at Apple. These creative geniuses understood something fundamental about creativity--it thrives and multiplies with collaboration. Some historians like Edmund Morris will even say Edison’s greatest invention was his team and culture at Menlo Park, not the thousands of inventions with which he is credited.

Similarly, Steve Jobs crafted the cultures of Apple and Pixar to encourage group interaction and what he called “social collisions.” Jobs insisted the work space at Pixar be built around an enormous atrium which everyone had to pass through to get to their cubes and offices. This raised the frequency of worker interactions, sharing of ideas and likelihood of collaborations. Apple's current headquarters is built in the shape of a giant ring for the same reasons. These creative collaborations gave us our beloved iPhones, iPods and Macs; hardly the products of a singular tireless genius tinkering away in a dark bunker.

Myth 6: Creativity strikes in a flash of brilliance

This one is a myth only in the way it is recast as a near mystical event. Tales of Archimedes running naked through the streets of Syracuse shouting “Eureka,” or August Kekule discovering the benzene molecule* in a dream are quite inspiring to hear. Sadly, these over-dramatizations of miraculous moments of insight are a tiny sliver of the entire creation process.

The truth is less dramatic. Research by creativity myth-debunker, David Burkus, shows that such moments of insight are usually the culmination of months and often years of prior hard work. If the insight is the visible tip, then the prior failed attempts and long hours of study are the entire iceberg.

It takes time for the brain to assimilate and synthesize information in a particular problem space, but our minds are remarkably good at condensing and synthesizing information in this way. Think about the amount of mental effort you had to exert when you were learning how to drive a car. You had to think about steering, speeding up and slowing down, shifting gears (if you learned a stick-shift transmission) and many other details that seemed overwhelming at the beginning. However, ten years later, when was the last time you consciously thought about those things while driving. More likely, you’re thinking about an office meeting, picking up the kids and fixing your hair all while switching lanes on a freeway at 80-mph.

Our minds are good at this type of chunking down and synthetization of information and we do it all the time. When such synthesis happens in a specific problem space, the end results can seem like a flash of insight from the gods. It's more likely your mind finally grasping the problem space after countless hours of wrestling with it.

* The benzene molecule is an important hydrocarbon used to make everything from plastics and synthetic fibers to life-saving drugs and detergents

Myth 7: Creativity cannot be learned

Perhaps the greatest and most debilitating myth of all is the view that humans are given a fixed amount of creative capacity. Thankfully for us life-learners, this has been thoroughly debunked by neurologists and psychologists all over the world.

In the past, scientists believed the human brain reached its intellectual peak around 40 years old before slowly declining all the way into the 70s and 80s when new learning was thought to be almost impossible. Today we know that the brain remains incredibly elastic and pliable well into the late 60s, and even later for some.

So, since we know that the mental “hardware” remains capable for the majority of one’s lifetime, our next question becomes, is creativity learnable?

According to psychologists like Mitchel Resnick, head of the Lifelong Kindergarten group at MIT Media Labs, the answer is a resounding, “Yes.” To improve educational creativity, Resnick says, “all stages of education should allow more time for students to work collaboratively on interdisciplinary projects that pique their interests.” Which is to say, a creative learner’s curiosity should lead them to the subjects and people that most interest them.

As long as curiosity is maintained it can be used as a driver for cultivating creative capacity throughout one’s life. After all, we are all born with curiosity and some degree of creative capacity. Learning and problem-solving would be next to impossible if this were not the case. Matisse, Georgia O’Keefe and Buckminster Fuller are just a few examples of creative notables whose output increased (and changed) in the latter years of their lives as their craft improved over a lifetime. They allowed themselves to be led by their curiosity even when it meant changing direction or in some cases changing fields entirely.

Summary

There are many more myths about creativity worth debunking, but in my studies and everyday conversation, these seem to be the most pervasive. Psychology and Neuroscience, like many fields today, are constantly improving and developing at a rapid pace. Especially around the study of creativity, which is receiving increased attention as job automation advances, it's not uncommon for once heralded ideas to fall out of favor due to new evidence and better technology-aided experiments.

So to summarize, here are the ideas you can take away with you:

All human beings are born with a capacity for creativity
Creativity is exhibited in all fields, not just the “artistic” ones
The left vs right brain model is incomplete. The brain uses both hemispheres in tandem for most tasks.
There is no correlation between mental illness and enhanced creativity (despite what Hollywood tells us).
Creativity is not a solo act—it works better in collaboration.
Creative flashes of insight are usually the result of prior, extensive hard work.
Creativity can be cultivated at any age, partly because the brain remains elastic and supple well into old age.

Subscribe now

An Artist's Guide to C# in Unity3D: Collections

Siggy — Wed, 16 Dec 2020 06:28:06 GMT

This article is part of an ongoing series for code-leaning artists who want to learn Unity 3D. In this article I introduce you to three useful collection types.

Read Previous: Operators

Collections.

No, these aren’t shady callers with anonymous phone numbers shaking you down for that $17.29 water bill you somehow forgot to pay in 2010.

Ahem.

Collections in C# are much friendlier. In every program you write you’ll need a way to store a basket (or group) of items that you can reference later. Things like a list of city names, a list of numbers like geographic coordinates or maybe even something like a list of available weapons in your player’s inventory.

Basics of a collection

Collections are variable types that let you store several items of data together. As you learned in previous lessons, variables allow you to store a single piece of data (of a particular data type).

string fullName = "Bruno Mars";

What if you wanted to store a list of 10 musicians? Or 1000? Would you create 1000 different string variables? You could, but good heavens, who wants to do that? This is where collections come into play.

One way to understand collections is to think of them as special variables with the following capabilities:

Have an identifier or label just like regular variables
Work with one type of data (string, float, int, etc) or can work with a mix of data types
May declare a specific number of items they are able to store (this is fixed in most cases) or declare that they can store any number of items
Provide a way to assign/put items into the collection
Provide a way to uniquely access each item in the collection
Provide a way to uniquely change/update each item in the collection
May provide a way to delete one or all items in the collection

In this lesson we will learn about three types of collections:

Arrays
Lists
Dictionaries

Arrays

Arrays are the simplest type of data collection (really a bargain basement collection compared to the other types). They allow you to store a fixed number of items of a particular data type. When you create an array, you must specify which data type this array will hold and how many slots to provide.

To create an array, we use the following format:

data_type_to_store[] name_of_the_array = new data_type_to_store[number_of_items_you_intend_to_store];

string[] musicians = new string[3];

We now have an array called musicians that can store three string data items. But, our array is empty.

Lets try adding just one string to the array. Since the array has three empty slots we need to specify which slot to add our new string into (No, it won’t just know to place it in the first slot--I told you arrays are the economy class of collections).

musicians[0] = "Bruno Mars";

Now we have one string item in the first slot of the array. But what’s with that 0, you ask? Well, array positions don’t start counting from 1, they start from 0. That means our array position indices will be 0, 1 and 2. Not 1, 2 and 3!

Let's add two more items to our array.

musicians[1] = "Miley Cyrus";

musicians[2] = "Alicia Keys";

If we try to add a fourth item, the compiler would yell at us because the array was declared with a fixed size of 3.

musicians[3] = "Philo Debangs";  //Error! Who is Philo Debangs???

What about accessing the array’s items? If you wanted to print the second item, you would use a similar indexing syntax to retrieve the item:

Debug.Log(musicians[1]); // Prints Miley Cyrus to the console

To change the second item in the array, assign the new value to the item position like this:

musicians[1] = "Beyoncé Knowles";

Now the second item has been updated.

Debug.Log(musicians[1]); // Prints Beyoncé Knowles to the console

A illustration of Arrays in C#

We can also check the size of the array using the Length property of the array like this:

Debug.Log("We have " + musicians.Length + " items in our array!");  

// Prints "We have 3 items in our array”

* We'll talk about object properties when we learn about classes. For now, think of .Length as an attribute of all array objects that returns the size of the array.

An easier way to print the above line is to use a feature called string interpolation. If we stick a $ right before the string in the above line we can skip using those ugly plus signs and just wrap our variable in curly braces ({ }) like this:

Debug.Log($ "We have {musicians.Length} items in our array!"); 

// Prints "We have 3 items in our array"

So far, we’ve added string items to our list one at a time. We also could have initialized our array at declaration time like this:

string [] musicians = string[] {"Bruno Mars", "Miley Cyrus",     "Alicia Keys"}

This would produce our three-item array immediately. Obviously, you may not be able to do this in every situation. It's an alternative way to initialize an array if you know your items at declaration time and your list is short enough.

What if you want to delete an item from an array?

Well, here’s where I disappoint you. You can’t.

Arrays are immutable in size. Once you declare an array size, it can’t be altered. If you want an array with a different size, you’ll have to create a new one. You can, however, update the individual array elements as much as you like.

The next collection type we will look at does not have this size restriction.

Lists

C-sharp provides us with another type of collection called a generic list type. As mentioned previously, this collection type is a lot more flexible than a basic array.

The basic syntax for creating lists is:

List<data_type_to_store> name_of_list = new List<data_type_to_store>();

To recreate our collection of musicians with a list we could do this:

List musicians = new List();

Now we have an empty list called musicians. Unlike arrays, lists are able to grow and shrink as we add and remove items so you don’t need to specify a size at declaration time.

Adding items to lists is pretty easy:

musicians.Add(“Bruno Mars”);
musicians.Add(“Miley Cyrus”);
musicians.Add(“Alicia Keys”);

To see how many items we now have in our array, use the list’s .Count property (which is similar to the array’s .Length property).

Debug.Log($"We have {musicians.Count} items in our array");

Accessing a particular item in the list is accomplished just like you would for an array.

Debug.Log(musicians[2]);  //prints Alicia Keys

As with arrays, providing an index that is larger than the list will throw an error.

Debug.log(musicians[3]); //Error!

//The list only has three items so the indices only go up to 2

Similar to arrays, changing or updating an existing item is just a matter of reassigning a new value to that particular index.

musicians[1] = "Beyoncé Knowles";
Debug.Log(musicians[1]); // Prints Beyoncé Knowles as expected

And if we wanted to initialize our list at declaration time we would do this:

List musicians = List {"Bruno Mars", "Miley Cyrus", "Alicia Keys"}

Lastly, our list collection gives us another ability we don’t have with arrays—deletion. The complement of the .Add feature we used for adding items to the collection is the .Remove feature for—you guessed it—removing items.

List musicians = List {"Bruno Mars", "Miley Cyrus", "Alicia Keys"};

musicians.Remove("Miley Cyrus");

Debug.Log(musicians.Count); // prints 2
Debug.Log(musicians[0]);  // prints Bruno Mars
Debug.Log(musicians[1]);  // prints Alicia Keys
Debug.Log(musicians[2]);  //Error!  Only 2 items left

A illustration of Lists in C#

Dictionaries

So far, with both arrays and lists, we’ve been referencing our collection items with index numbers (from 0 to whatever). These are called ordered collections (because the items contained are accessed by number in the same order in which they were added) and work well for many purposes. However, sometimes it's more appropriate to access our list items with something other than a numeric index.

A simple example is keeping track of player scores. Assume you have the following three players and their scores:

Yakko - 61
Wakko - 47
Dot - 93

Using an array or list would not be the best way to store this data. When order doesn’t really matter, C-sharp provides another type of collection called a Dictionary for storing key-and-value pairs. In our case the player’s name would be the lookup key while the player’s score would be the value we want to retrieve.

The syntax for creating a dictionary is:

Dictionary<data_type_of_the_key, data_type_of_the_value> name_of_dictionary =
new Dictionary<data_type_of_the_key, data_type_of_the_value>();

Lets go ahead and create our dictionary.

Dictionary playerScores = new Dictionary();

Now, just like we did for lists, we can add new items to our dictionary by passing in both the key and value we wish to store.

playerScores.Add("Yakko",  61);

This stores the integer value 61 against the string key Yakko. Let's add the other two scores.

playerScores.Add("Wakko", 47);
playerScores.Add("Dot", 93);

With our playerScores dictionary populated, we can lookup a score by using the player’s name (the key) to retrieve the score (the value).

Debug.Log(playerScores["Wakko"]);  // prints 47
Debug.Log(playerScores["Dot"]);  // prints 93
Debug.Log(playerScores["Yakko"]);  // prints 61

If we wanted to update Yakko’s score to 65, we would do this:

playerScores["Yakko"] = 65;
Debug.Log(playerScores["Yakko"]);  // prints 65

Lastly, if we want to remove Yakko from the dictionary we can do this:

playerScores.Remove("Yakko");

Debug.Log(playerScores["Yakko"]);  // Error!  

//Yakko no longer exists in the dictionary

A illustration of Dictionaries in C#

As we can see, dictionaries behave very much like lists except we’re using strings for accessing item values instead of position integers. It's important to note that dictionaries allow you to use any data type as the lookup key—integers, floats and even other objects are valid keys. We’ll learn more about this in upcoming lessons.

Try it out

Now that you’re comfortable with collections, try answering the following questions to improve your understanding.

Assume, you’re running an experiment where you flip a coin ten times and record the result—whether the coin comes out heads or tails. What collection could be used to represent this information since you know how many items you need to store? Create the collection with the appropriate data types and initialize it.
You’re a dispatcher for a traveling sales guy. He calls you every morning and asks what the temperature is in five different cities. Today the cities and their temperatures are:
Atlanta - 74
Charlotte - 71
Louisville - 68
Nashville - 70
Indianapolis - 62

What kind of collection would you use to represent this? Create the collection and add the data. Remove the Nashville entry and add Richmond with a temperature of 63 degrees.
You’re conducting an online survey. Everyday, your survey website sends you a list of email addresses submitted to you that day. What collection would you use to store these email addresses? Create the collection and add these emails to it:
larry@stoogehq.com
moe@stoogehq.com
curly@stoogehq.com

Print the email addresses to the console.
Whoops, two more just came in. Add these extra emails to the collection and print again.
shemp@stoogehq.com
joe@stoogehq.com
Next we’ll learn about flow control in your programs.
An Artist's Guide to C# in Unity3D
Subscribe now

An Artist's Guide to C# in Unity3D: Operators

Siggy — Sat, 12 Dec 2020 12:00:02 GMT

This article is part of an ongoing series for code-leaning artists who want to learn Unity 3D. In this article I introduce you to operators and how to use them on different data types.

Read Previous: Common data types and variables

Operators provide actions such as value manipulation, logical comparisons or mathematical calculations that may be applied to data types. Each operation is usually represented by its approximate conventional mathematical symbol. E.g., the plus (+) and minus (-) for addition and subtraction, respectively.

C-sharp comes with several built-in operators but we’ll cover just the operators in these four groups

Arithmetic Operators
Logic Operators
Relational Operators
Assignment Operators

Arithmetic Operators

As the name implies, these operators apply arithmetic calculations on numeric values. Arithmetic operators also work on char values because each character is represented by its numeric ASCII value under the hood. The only arithmetic operator which works on string values is the plus (+) operator which concatenates the string operands together.

Here are the arithmetic operators in order of precedence

Logic Operators

These operators perform simple logic algebra on boolean values. Here they are in precedence order.

Relational Operators

These operators perform quantitative comparisons between values such as “greater than,” “less than,” or “equal to,” and return true or false.

Assignment Operators

We have seen the basic assignment operator (=) already. It's the basic way of assigning a value to a particular variable identifier (e.g., name = “John”). The other five assignment operators do the same thing except they perform some sort of arithmetic operation on the value before assigning the result to a variable.

Here are the assignment operators.

Try it out

Now that we’ve learned about operators, we have enough knowledge to calculate some simple equations.

Let’s revisit some of our elementary school word problems.

Take a look at the following illustration and use it to complete the code exercise.

We have a scene here with an intrepid rancher squaring off against four, um, let's call them wild boars. The following conditions apply:

The rancher has six bullets in his gun
There are four charging wild boars
Each boar is charging at a speed of 2.5 feet per second (ok, not a very aggressive charge but still, wild boars!!)
It takes one bullet to kill one boar
The red line is the rancher’s property border line. He is exactly 10 feet behind it. If any boars reach the line, and he’s out of bullets he’ll have to run for his life.
The rancher’s running speed is only 2.0 feet per second.

Answer the following questions. Use any variables and operators you need and print your answers to the console.

If the rancher is able to kill each boar before it reaches the border line (with one shot each), how many bullets will he have left?
How would you use the modulo operator as an alternative way to find the answer to the previous question?
If the rancher goes all “scarface” on the boars and decides to charge the border line as he shoots, how many seconds will it take him to reach the border line (assuming the boars don’t get him before that)?
If a boar successfully crosses the border line, and the unlucky rancher runs out of bullets, how many seconds will it take the boar to reach the rancher’s current position?
If the rancher turns around and runs, how far could he get in the same amount of time it takes the boar to cover 10 feet?
In this chase scenario, how long would it take the boar to catch the rancher?
How far away from the border would both boar and rancher be when the boar finally catches him?

We’ll cover C-sharp data collections next.

An Artist's Guide to C# in Unity3D

Subscribe now

An Artist's Guide to C# in Unity3D: Common Data Types and Variables

Siggy — Thu, 10 Dec 2020 10:00:58 GMT

This article is part of an ongoing series for code-leaning artists who want to learn Unity 3D. In this article I introduce you to some common data types in C# and how to use variables.

Read previous: Creating your first script

Common Data Types and Variables in C#

In any program you’re going to be dealing with data values of different types. You may want to store a player’s age, name or calculate a character's speed, health points, etc. These are all different types of data you may need to store, manipulate or calculate.

C-sharp comes with several built-in data types it can handle, but you don’t need to learn them all. For eighty-percent of your game development needs, you’ll use the following five built-in data types.

Common Data Types

Variables

If built-in data types are the values you use in your program, then variables can be thought of as named slots or containers for holding those data values.

Variable declarations take the form of:

;

Or, if you want to assign a value to the variable in one go (called initializing the variable):

=

In lay terms, what you’re doing with this one-liner is:

Declaring what type of data container you want
Specifying the label/name you’ll use to identify this container
Placing the value you want into the container

For instance, let's say you need to print out a player’s full name in twenty different places, you could do something like this each time:

Debug.Log(“Michelangelo di Lodovico Buonarroti Simoni”);

However, you would have to type that long name twenty times in all the locations you need it. A better alternative would be to assign the player’s name to a variable called fullName. Now you can use fullName anywhere you need to print the name. So your code would look something like this:

string fullName = “Michelangelo di Lodovico Buonarroti Simoni”;
Debug.Log(fullName); //prints the full name

You created a container called fullName to hold the value “Michelangelo di Lodovico Buonarroti Simoni.” This container can be passed around your program as needed.

Later in your program, you can still change the value of fullName to anything you want as long as its a string:

fullName = “Leonardo Da Vinci”;
Debug.Log(fullName); // will print out “Leonardo Da Vinci”

If you tried to do this, you would get an error:

fullName = 34; // Error!

Since the variable, fullName, was declared as a string type, attempting to assign non-string values to it will generate an error.

For now, here is how to declare variables of the five data types mentioned above.

Integers

In C#, integer variables are declared like this:

int coins = 10;

They are good for representing any number values that don’t require a fractional amount.

Floats

In C#, float variables are declared like this:

float gravity = 9.81f;

C# requires that the ‘f’ be added at the and of any float value literals so the value may be correctly recognized as a float.

Booleans

Booleans are simple true or false values and cannot be anything else. They are declared like this:

bool isAlive = true;

Characters

Characters and single character values stored between single quotes. They are declared like this:

char group = ‘D’;

Strings

Any length of characters strung together between double quotation marks are stored as strings. They are declare like this:

string motto = “Give me freedom or give me death!”;

Try It Out

The best way to learn these is to try them out for yourself. So here’s your assignment.

Open up your Fundamentals.cs script and try creating the following variables in file. If you’re wondering where to place the variables, my recommendation is to put them above the Start() method (inside the Fundamentals class block). Do not forget to save your work.

Add a variable to store the nickname of a player. Call the variable nickName and initialize it to anything of your choosing.
Add a variable called health to store the player’s health. Let’s assume a player's health is measured as a whole number between 0 and 5.
Add a variable to store the player’s speed. Speed values will have decimal parts.
Add a variable to store whether a player is invincible or not.
For each new variable you add, print it out in the Start() method

When you’re finished, your script should look similar to this

using System.Collections; using System.Collections.Generic; using UnityEngine;
public class Fundamentals : MonoBehaviour { string nickName = “Picassolo”; int health = 5; float speed = 3.6; bool isInvincible = false;
// Start is called before the first frame update void Start() { Debug.Log("Unity Rocks!"); Debug.Log(nickName); Debug.Log(health); Debug.Log(speed); Debug.Log(isInvincible); }
// Update is called once per frame void Update() { } }

Next, we’ll learn about what sort of operations can be performed on these data types.

An Artist's Guide to C# in Unity3D

Subscribe now

An Artist's Guide to C# in Unity3D: Creating your first script

Siggy — Wed, 09 Dec 2020 08:39:37 GMT

This article is part of an ongoing series for code-leaning artists who want to learn Unity 3D. In this article I show you how to create your first script in Unity.

Read previous: Setting up your learning environment

Unity Editor Overview

If this is your first time using Unity or any integrated development environment (IDE), the Unity Editor interface can appear quite daunting.

So, I’ll just start by saying, “fear not!”

You’ll grow comfortable with the unity interface very quickly. Additionally, since we’ll be focusing more on learning C#, we will limit our concerns to just a handful of Unity’s features to begin with. This will give you ample time to learn how Unity works before exploring on your own.

For now, go ahead and launch the project you created in the previous lesson.

Lets identify the different panels we’ll be interacting with.

The Unity Editor’s default layout has four main panel group regions.

Hierarchy (A) panel -- lists every item in your game scene, in hierarchical order. It is useful for organizing your scene items, grouping items, nesting items and providing for easy selection of items especially within large scenes.
Scene and Game panels (B) -- these two panels are grouped together. The scene panel allows you to visually add and arrange your game objects like a director placing props and actors on a stage. The game view panel only becomes active when you hit the play button to enter play mode. In this mode, the Unity Editor compiles all your game objects along with accompanying logic found in your C-sharp scripts and runs your game the way it would execute on a target device.
Project and Console panels (C) -- these are the two panels grouped underneath the hierarchy and scene/game panel group. The project panel holds all your project’s folders and file assets. Things like your game graphics, sprites and script files would be contained here. It's really just Unity’s representation of the actual Assets folder that exists on your hard disk. The console panel is where we will spend a lot of our time as we learn C-sharp. When we instruct our code to print a line of text, that output is displayed in the console panel. Unity also displays all notifications and error messages that occur while running our game in this panel.
Inspector panel (D) -- this panel is context-sensitive. Anytime you select an item from the scene panel, the hierarchy panel or the project panel, the item’s attributes and properties are displayed in this panel. The values of these properties can be modified through the inspector.

Create Your First Script

Lets jump right in and start learning what we came here to do. Right now your unity editor is displaying a sample game scene. This works just fine for our C-sharp learning goals. So lets start exploring a bit.

In the Hierarchy panel, you’ll see our SampleScene and two default objects underneath it--Main Camera and Directional Light. These are default game objects that Unity automatically creates for you when you start a new project.

Try clicking on the Main Camera. You’ll notice that the camera graphic gets selected in the scene panel and the inspector panel also displays lots of information about the Main Camera. Just take a look at the attributes for now. No need to change them if you don’t want to. Click on the Directional Light to see its attributes.

Let's move our attention down to the Project & Console panel group. You’ll notice that the project panel is divided into two sections. There’s a folder view display on the left side and a larger content window on the right. This works just like the file finder or file explorer you use on your computer to locate files. The content view on the right will always display the contents of whatever is selected from the folder view on the left.

Click on the Assets folder in the folder list on the left side. There is currently one nested folder inside this folder called Scenes. If you click on the Scenes folder (either from the left folder list or by double-clicking on the scenes folder icon on the right) you’ll see that it contains one item called “SampleScene.” This is the game scene currently displayed in the Scene and Hierarchy panels--also known as the active scene.

Click back on the Assets folder to select it and view its contents. The scenes folder looks pretty lonely, so let's give it some company by creating a second folder inside our assets folder.

In the content window, right-click on the blank space next to the scenes folder to bring up an action menu. Select:

Create > Folder

A new folder will appear. Rename this folder to Scripts.

The scripts folder is currently empty. Let's create our first script inside it. Select the scripts folder. The content view says “This folder is empty.”

Right-click on the empty space again to pull up the action menu and select:

Create > C# Script

Rename the new script to Fundamentals. It's important to match the letter casing exactly otherwise we may run into errors in the future.

Now, guess what? Technically, you’ve just created your first C# script in Unity!

It's still not doing anything yet so lets fix that next.

Make Your Script Do Something

We have created our first script in our project but it doesn’t “do” anything yet. In order to change that we need to edit our script. This is simple enough to accomplish.

From the content view of your project panel, double click the script you just created. This will launch another program, Visual Studio, which comes bundled with your Unity installation. Visual Studio is Unity’s default program for editing C-sharp code.

Once it launches it will display the current contents of your script Fundamentals.cs.

We’ll discuss what all that code means in a minute. Right now we’ll just add a line to print a simple message to the console panel.

Find the section where it says,

void Start() {
}

And change it to the following:

void Start() { Debug.Log(“Unity Rocks!”); }

All we’ve done is add a single line between some curly braces:

Debug.Log(“Unity Rocks!”);

This is how we instruct Unity to “print” or “log” some text to the console screen.

Save the script file and go back to the Unity Editor.

Click on the console panel tab so we can see its contents. It's currently empty but if all goes according to plan, once we run our program, we should see the words “Unity Rocks!” printed in the console.

Located at the top middle portion of the Unity Editor, you’ll see the play and pause buttons. This is how we run our programs in Unity.

Click the play button.

Unity runs our program and… nothing happens!

Click the play button again to stop it.

So what happened?

Well, I forgot to tell you that all C-sharp scripts in Unity need to be attached to game objects in the scene. This is done by adding our scripts as “components” to any number of desired game objects. When the game runs, all attached component scripts are executed on that object. This is how we add behaviors, actions and custom functionality to objects in our game.

Our scene contains two objects at the moment--the main camera and a directional light. Although we could add our script to these objects, it’s just as easy to add it to our own special object. Let's do that now.

In the hierarchy panel, click the plus button found in the top left corner of the view to display an actions menu. Select:

3D Object > Cube

This creates a cube in the center of our scene view and adds it to the hierarchy view. We’re going to attach our Fundamentals.cs script to this cube.

Attaching a script to an object is as simple as dragging the script from the project panel and dropping it unto the desired object in the scene view. Go ahead and try that. Make sure your project panel view is visible and you can see the Fundamentals.cs script in the context window. Click and drag the script file and drop it unto the cube object in the scene view.

Now, if you select the cube in the scene, you should now see the
Fundamentals (Script) listed as one of the cube’s components in the inspector panel. You may need to scroll the inspector window down to see it.

Now we’re ready to test.

Click on the console panel again so it's visible. Then click the play button like you did before.

Viola! The expected output is printed in the console window preceded by a timestamp.

Something like this:

Unity Rocks! UnityEngine.Debug:Log(Object)

Congratulations, for real this time!

You have created your first functioning C# script in Unity.

We now have a good base script that we can keep adding to throughout the rest of this series.

Before we end this lesson, let's go back to Visual Studio and take a look at what we have.

Basic Parts of a Unity Script

Here is what our Fundamentals.cs script looks like so far.

using System.Collections; using System.Collections.Generic; using UnityEngine;
public class Fundamentals : MonoBehaviour { // Start is called before the first frame update void Start() { Debug.Log("Unity Rocks!"); }
// Update is called once per frame void Update() {
}
}

For our purposes, I’ll quickly identify the basic parts of the script and draw your attention to the portions you’ll need to know as we practice and build on your C# scripting skills. At this point you’re only required to know where to add your code in the script file. More advanced aspects of the file will be explained as your C# knowledge grows.

Library import statements
Class declaration and body
The Class’ methods
The Start method

I’m identifying these parts just to make you aware of them. However, we only need to pay special attention to section 2 and 4 for now.

Regarding section #2, think of the Class declaration and its body (all the code between first and last curly braces) as the encapsulation body (or shell) of this particular C# script. The restriction to remember here is that the name “Fundamentals,” must match the name of the script file--Fundamentals.cs.

The class can contain any number of named coding blocks, called methods in this context. These code blocks are also demarcated with their own set of curly braces. We have two methods in the Fundamentals class:

void Start() { … }

And …

void Update() { … }

We’ll ignore the Update method for now and focus on the Start method.

The Start method is a special method that gets executed when our game scene is loaded exactly once. When you hit the play button in Unity, the engine loaded the scene and all its containing game objects. For each game object, Unity located the object’s Start function and executed it once. That’s why we added our code to this code block.

We will be adding most of our code to this block as we learn the basic features of C-sharp throughout this course.

Lastly, I’d like to mention the lines that begin with //. These are comment lines for the benefit of the programmer and are always ignored by the game engine.

Next, we’ll cover variables and common data types in C-sharp.

An Artist's Guide to C# in Unity3D

Subscribe now

An Artist's Guide to C# in Unity3D: Setting up your learning environment

Siggy — Wed, 09 Dec 2020 03:27:14 GMT

This article is part of an ongoing series for code-leaning artists who want to learn Unity 3D. In this article I walk you through the steps required to set up Unity on your development computer.

Completing this step is required if you want to follow along in the upcoming lessons.

An Artist's Guide to C# in Unity3D

Since we will be learning C# within the context of Unity, it makes sense that the first thing you need to do is to install Unity on your computer. The creators of Unity have made this process very simple to accomplish across all three major operating systems. So whether you’re working on macOS, Windows or Linux, the process is almost identical.

Let's start by downloading a copy of the Unity Hub. This is a central tool that Unity provides to make it easier to install and manage different versions of the Unity Game Engine and other learning assets. It is very similar to Adobe’s Creative Cloud desktop application hub which allows you to manage the installations of all your favorite Adobe programs.

Download and Install Unity Hub

Visit Unity’s store page here: https://store.unity.com
You’ll be on the Plans and Pricing page. Click on the Individual tab and select the Personal option.
You’ll be prompted to select whether you’re a first-time user or a returning user. Choose the First-time Users option.
Read the Terms of service pop-up (because you’re just a good citizen) and, if you agree, click Agree and Download.
After the Unity Hub installer has downloaded to your computer, follow your operating system’s standard process for installing it on your machine.

After the Unity Hub installed, go ahead and launch it for the first time.

You should see a screen that looks very much like this:

Next, lets install a version of the Unity Game Engine through the hub.

Install Unity Game Engine

Click on the Installs menu option to take you to the software installs section
Click the Add button in the top right corner
You’ll be prompted to select the version of Unity you want to install. Go ahead and select one of the Unity 2020.1.xx versions. In my case I selected Unity 2020.1.16f1
Click the Next button and select at least one of the build target modules you want. These modules will require more space on your computer’s hard disk and will take longer to install. Since they are optional for completing our lessons, feel free to skip them if you want.
Click Next. Accept any end user agreements if prompted and finally click Done.

Finally, let's create a project we will use for all the upcoming lessons.

Create a project

If you’re not already there, click on the Projects option from the menu on the left. You should see a message, similar to the image below, saying you don’t have any current projects yet.
Let's create one by clicking the New button in the top right corner
You’ll be prompted for some project basics like the starting template, the project name and the folder location. Select the 3D option template
Name your project LearnCsharp
Select a folder on your computer where you would like to save the project files, then click on Create.

Unity Hub will now spend a few minutes creating and configuring your project. When it's complete, it will launch your new project in the Unity Editor and display a screen that looks something like this:

If you’ve made it this far, congratulations!

You’re all set to learn C# in Unity with the lessons that follow.

For each lesson, open up the Unity Hub and navigate to the Projects section. Launch this project by clicking on the project name in the projects list.

Next: Create your first C# script in Unity

An Artist's Guide to C# in Unity3D

Subscribe now

Imaginative Play and How to Improve Yours

Siggy — Wed, 02 Dec 2020 13:01:02 GMT

A few weeks ago I knocked on the front door of my brother’s home and walked in without waiting for a response, as I always do. (Don’t ask why I knock first, it’s a useless habit of mine).

It was my regular Thursday evening visit and the only day of the week when I leave the office early so I can hang out with my two nephews before their bedtime.

On this day, as soon I walked through the door, my seven-year old nephew screeched, “Uncle Siggy! Uncle Siggy! Hurry, jump unto the island, they’re going to eat you!”

“Me? Who’s going to eat me?” I asked.

“The sharks!” He yelled back.

“And the alligators,” the five-year old added.

Both boys were standing on the couch with toy hockey sticks in their hands, frantically motioning for me to join them on the couch.

“Quickly, Uncle Siggy! Hop on the islands to get to the big island.”

I looked around the disheveled living room. There was an explosion of toys everywhere and couch pillows strategically placed around the living room floor.

Without missing a beat, I hopped from pillow to pillow and launched myself unto the couch with the two boys.

“Oh my god, thanks guys.” I gasped.

“They almost got you,” the seven year old said, “Our only problem now is keeping our supplies up.”

“Our supplies?” I wondered aloud.

“Yeah, for our injured comrades.” They gestured to a group of bandaged stuffed animals on the couch with us. I looked down at my knee which was currently crushing Toothless the dragon, who was swaddled in a hand towel.

“Oh, excuse me,” I said, gently patting the injured toy.

“They need supplies from the giga-factory.”

The giga-factory was their toy box located in the far corner of the living room. Their father is an engineer, so of course, they would go with a name like “giga-factory.”

The couches and cushions were the only safe spots. Everything else was shark and alligator-infested water.

“Got it,” I said. “So what’s my mission, Captain?”

For the next half-hour, I was thrown into a fantastically fluid world of survival, danger, heroic rescue, tragic loss and brave triumph (aided by hyper-futuristic technology or sorcery, not sure which).

Afterwards, on my drive home that night, I started wondering when I stopped having that sort of imaginary fun. I’m not about to start hopping from couch to couch in my living room, all by myself, pretending my floor is molten lava or something. My neighbors would think I was bonkers (or more likely, ask to share whatever ‘shrooms I had taken).

Why don’t I play like that anymore? Why don’t most adults?

Adults are Kids Too

It's generally accepted that adults are less playful than children, but why is this the case and is it necessarily a good thing? My curiosity on the matter led me to several books about play and it turns out adults never really stop playing--at least not the most creative ones. The nature and subjects of adult play are different from that of children but the effects on the brain are the same. Playfulness is an indispensable component for cultivating and maintaining creativity throughout one’s life.

As I’ve explained in previous chapters, immersing oneself in a particular domain and exerting the discipline required to master a craft is an obvious prerequisite for producing innovative and impactful work. However, mastery of craft is only a fraction of the creative calculus. In the book, Wired to Create, positive psychologist, Scott Kaufman explains that “cultivating a childlike sense of play can revolutionize the way we work.”

Injecting a sense of play into otherwise grueling work keeps us creatively nimble and more adroit at recognizing potential problem-solving breakthroughs. We are fortified against the stress induced from long hours of creative work when there’s a playful lightheartedness about the work itself. Kaufman’s research also shows that playful work provides the optimal learning conditions for both children and adults.

Think about the kid in your sixth grade class who could recall reams of vital playing statistics for every Chicago Bulls player since 1996 but still couldn’t tell you the names of the first four presidents of the United States. You can guess which set of data the kid likely played with more often.

Adult Barbie Dolls and Fire Trucks

When it comes to playfulness in adulthood, the definition of a toy expands beyond just Barbie dolls and shoe-sized fire trucks. For creatively inclined adults, almost everything can be a toy worth engaging in imaginative play.

All manner of objects, personal experiences, memories, emotions, ideas and fantasies are suitable toys for adult play. When you hear an interviewer ask a famous musician or author, “where do you get your inspiration from?” You can bet the artist is about to share what his or her imaginative play toys are.

Grant Wood, the artist behind the iconic piece American Gothic, was engaging in this type of mental play when he came up with the concept of his most recognized painting. While on a drive through rural Iowa, he made a sketch of a farmhouse that caught his attention. When he got back to his studio Grant started playing with different views of the property and imagining what sort of people might live in a house like that. Eventually, he settled on using his sister and his dentist as models for the couple in the now famous painting.

Emotions like love and loss are popular sources of play and inspiration for musicians and poets. However, the great thing about the limitless nature of imaginative play is that the source could be anything. Even, let's say... deodorant.

According to record-industry lore, the line, “Kurt smells like teen spirit,” was scrawled on Kurt Cobain’s wall by a fellow bandmate. The message was intended as a mild condescension towards Kurt and the brand of deodorant worn by his girlfriend at the time. However, when the Nirvana front-man read the line he thought it sounded deep and rebellious and was thus inspired to write the 1991 hit song, Smells Like Teen Spirit. You’ve got to love the power of imaginative play.

Another product of imaginative play familiar to writers, filmmakers and game designers is world building. The sort of elaborate world building produced by J.R.R. Tolkein, C.S Lewis, George R. R. Martin and George Lucas maintain their roots in childhood paracosms.

Creativity Psychologist Michelle Root-Bernstein defines paracosms as detailed imaginary worlds created by children usually between the ages of 8 and 12. Children engage deeply with these worlds filled with complex rules and imaginary characters in what she calls worldplay.

This type of play differs from simple pretend play which is more ephemeral and usually only lasts as long as the child is engaged in the moment. Worldplay is more persistent and continuous in the sense that the child returns to the world over and over, adding rules, extending character narratives and generally expanding the world’s systems.

Even after world building and worldplay ends around puberty, Root-Bernstein has found that this richly creative exercise can be an indicator of creative giftedness in adulthood. Several creative luminaries like C.S Lewis and famous Nintendo game designer Shigeru Miyamoto, report engaging in extensive worldplay as children and indeed drew upon those worlds in their later work.

For some adults like J.R.R. Tolkein worldplay never really stops. Tolkein was a philologist with a profound interest in linguistics and literary history. It has been reported that he invented the vastly detailed worlds of Middle-Earth and all its lore as an “excuse” to explore the imaginary languages he created. In fact, the volume of instructional manuals and guides he produced describing the incredible world and history of Middle-Earth exceeds the total volume of purely fictional stories he completed about those worlds. These stories include the famous classics The Hobbit and The Lord of the Rings trilogy.

Imagination Games

A great benefit of our brain’s neuroplasticity is that we can benefit from imaginative play throughout our lives. For adults, imaginative play can be incredibly rewarding on a mental and physiological level. This sort of internal respite from the shackles of professional adult life fosters curiosity, ageless vitality and of course, increased creative thinking.

So here are a few exercises you can try for yourself to reap the benefits of your imagination at play.

Analogy Portrait ID

The goal of this exercise is to analogize the descriptive attributes that may appear on a standard government issue ID of a famous person with a noun (an object place or thing). The substitution criteria are as follows:

Photograph an animal
Height a cartoon character
Hair a geographic location
Eyes a movie or TV show (unaffiliated with the subject)
Voice a song
Sex a restaurant
Place of Birth an element from the periodic table
Date of Birth a number between 1 and 365
Profession a gemstone
Address a famous quotation (not made by the subject)
Signature one playing card from a standard 52-card deck

So for example, let's say I pick Tiger Woods, then my answers could look like this:

Photograph Chipmunk
Height Ned Flanders
Hair Joshua Tree Park
Eyes The Shawshank Redemption
Voice Let Her Cry by Hootie & The Blowfish
Sex Bahama Breeze
Place of Birth Fluoride
Date of Birth 29
Profession Emerald
Address “You never really learn much from hearing yourself speak.”
—George Clooney
Signature The king-of-clubs

Here are a few names to get you started: Bill Clinton, The Dalai Lama, Elon Musk

Music Muse Stream

This is a fun exercise I often use to loosen up my imagination “muscles.”

The instructions are simple. First, you’ll need a pen and some paper or a device you can type quickly on, such as a laptop with Google Docs. Next, visit your favorite music streaming service and pick an instrumental song with no lyrics or vocals and hit play. As you listen to the song, ask yourself, “if this was the soundtrack to a movie in your head, what scene would be taking place right now?” What images, sequences and narrative would be unfolding on-screen to accompany this music?

Write down the story as you see it unfolding in your mind’s eye. Do this while the music plays and allow the music to drive your imagination, no matter how absurd. Try not to censor yourself during this process and you’ll be pleasantly surprised by the end result.

Titled Picture Completion

For this exercise you’ll need three sheets of blank white paper and a pencil.

Here we go. Pick any three popular song titles from the following list:

“Cry Me A River”
“I Want To Know What Love Is”
“Welcome to the Jungle”
“Respect Yourself”
“Get Ur Freak On”
“All Apologies”
“Come As You Are”
“I Shot the Sheriff”
“Smoke on the Water”
“Bitter Sweet Symphony”

Now, write each song title you selected at the top of each blank piece of paper. When you’re done, each piece of paper should have a song title written across the top of the page.

At this point you’re probably wondering why a single letter from each song title has been highlighted. Well, here’s where you find out: Write that letter right in the middle of your sheet of paper. You should write the letter large enough to take up the middle third of the page--roughly the same size as a toddler’s hand.

Your imaginative task is to transform the letter in the middle of your page, into a picture/drawing that expresses or complements the title you’ve written on the page. This doesn’t have to be a masterpiece. In fact, it works better if you don't agonize over the quality of the drawing and just create the most appropriate line sketch you feel matches the song title.

You may find the mild tension of creating an image (constrained by the initial strokes) that matches the song’s theme quite gratifying.

Feel free to attempt these exercises as often as desired. After doing this regularly, the rewards of a strengthened imagination will be yours to reap.

All images by Freepik

Human Beings: Those Novelty Addicts!

Siggy — Wed, 18 Nov 2020 13:00:51 GMT

Photo by freepik

How many different kinds of socks exist in the world?

What about shoes? Or just sneakers? How many new sneaker styles were created just this year? What about movies or TV shows? Or iPhones? Why do we keep buying new ones every single year?

This question could be posed of any consumer product, but the real target of inquiry should be the consumers. Why do we buy billions of dollars worth of sneakers every year? Or line up around the block for the latest iPhone? Or clamor to see new movies when they get released?

Humans love the new, new thing. You could even say we live for the novelty. Last year’s perfect pair of near pristine Nike Air Max’s, get discarded for this year’s Nike Yeezy’s. The new Call of Duty video game turns into a must-have because everyone stopped playing the last epic release over a year ago. Or, we all scramble to see the latest James Bond movie even though we know exactly how it will end--just like the previous twenty releases did before it.

In their book, The Runaway Species, Anthony Brandt and David Eagleman offer several good explanations on why human brains are addicted to the new. And, as you might expect, it has everything to do with our evolution.

Pattern Interruptions: Brains evolved to pay attention to differences and novelties

Our brains are constantly bombarded with information from our sensory channels. Let's consider how human beings listen for instance. Our ears don’t have an off-switch, so every sound around us is constantly streaming into our ear canals and hitting our sound receptors. For example, imagine you’re sitting on your balcony reading a novel. The sound of vehicle traffic rumbles from the street below, complete with car honking, doors slamming and the roar of car engines starting up. There is also the chatter of passers-by, dogs barking and the clanking of dumpster lids but none of those sounds register in your brain. They are all part of the normal sound pattern you’ve grown to expect in your neighborhood. So you barely notice and get deeper engrossed in your book.

Now let's say at this exact moment, still lost in your book, you hear the roar of a Tiger! No matter how engrossed you may be in your book, you’re likely to stand at attention--immediately! The Tiger’s roar in your neighborhood is a definite pattern interruption. The sheer novelty of it forces your brain to say something like, “hey dude, I know this book is really starting to get interesting but you better check out that sound I just sent to your inbox. It sounds like a Tiger and I don’t think we’re anywhere near a zoo, so you should check it out. Now!”

A mental bias towards novelty kept our ancestors alive by enabling them to determine what new changes may have occurred in their environment. Such changes could indicate an immediate need for self-preservation (running to safety from a wild animal) or survival-enhancement (running towards freshly flowering plants that could indicate the availability of fruits).

Another simple example is noticing a quick movement in the periphery of your field of vision. You’re bound to divert your straight ahead gaze in the direction of the movement. It's a change to which your brain demands you pay some attention. It could be a quickly darting and potentially delicious rabbit, or a rapidly approaching bear.

Today, pattern interruptions are exploited by advertisers and creators of all the consumer goods we purchase. Undulating, inflatable dolls at car dealership strip malls, singing beer-drinking frogs on TV and giant pink mustaches on tiny Hondas are all designed to exploit your mind’s tendency to fixate on novelty and difference.

Repetition Suppression: That joke you’ve heard 1000 times is no longer funny

A corollary to the pattern interruption is repetition suppression. Repetition suppression is the result of our brains learning from pattern interruptions.

Let's say you’re returning home from work one day and as you pull into your driveway, you notice a large pink unicorn with a huge rainbow tail prancing around in your neighbor’s front yard. As we learned earlier, an event like that would qualify as the mother of all pattern interrupts. You would probably spend the rest of your week talking about it, maybe even calling a joint-press conference with your neighbor to show it off.

Then let's say the unicorn visits every weekend. It would probably still be the talk of the neighborhood for the next six, seven maybe eight weeks? By the fifth or sixth month of Mr. Rainbow-tailed Unicorn showing up every weekend, even senile neighborhood porch dwellers would barely acknowledge his presence. The once shiny unicorn might start feeling like a low-rent Bojack Horseman to you and, certainly, your neighbor.

According to Brandt and Eagleman, “once our brains become familiar with something, the less neural energy it spends on it.” Our brains are highly efficient pattern-recognition machines. Patterns are helpful for making predictions in the future once they are learned. And this is exactly what the brain does.

When we encounter something novel, whether it's a new person, skill or event like a unicorn in your neighbor’s yard. Our brains spend a lot of energy collecting information about this new “pattern.” With increased exposure to the novel entity, the amount of energy spent by the brain on that entity diminishes as it learns what to expect. So the first time you heard your uncle tell that one randy joke, your brain probably lit up significantly, as you doubled over with laughter. On the 99th or 100th time, however, that same joke has become quite a yawn and left you wondering how you ever found it funny in the first place.

This rapid pattern-recognition and chunking down of patterns is how our brains keep learning and conserve energy at the same time. The brain wants to spend energy on new things to notice, learn and assimilate about the environment not on old patterns it has already mastered.

Mastering patterns is how our minds try to predict the future in order to keep us safe and one-step ahead of our environment and the challenges it may bear on us. Once our brains recognize a pattern, it jumps to the final outcome as quickly as possible and redirects resources towards processing for the next thing. If familiarity with a pattern leads to mastery, it also inadvertently produces indifference and boredom as a by-product of that mastery.

Imagination: An infinite simulation holodeck

One of the most magical things about our human brains, as David Eagleman and Yuval Hariri would both agree, is our ability to simulate elaborate alternatives to reality. It’s the simple act of asking ourselves, “What if,” and observing what comes out of that consideration.

Again, our brains are trying to teach us about the future and preserve us when we encounter unknown circumstances. When we explore what-if scenarios, our minds are playing an adventure video game and testing out several options, routes and strategies. This allows us to learn vital lessons in imagination-space without risking life and limb in reality.

This is easily observable in young children at play. Their imaginative adventures can transition fluidly from fantastic space explorations to saving lives on an operation table in the same scene. Almost every parent has a story about watching their kids engage with an empty card box with as much enthusiasm as the toy that came in the box. These children are practicing for a future beyond the safety of their parent’s living rooms.

Additionally, these imaginative simulations do not diminish with age. Instead, our mental simulations become less fantastic and more rooted in reality. We may no longer day dream about shooting aliens on Mars with double finger-guns, but we will mentally simulate taking our vacation time in July so we can go to the beach, versus waiting until December so we can go on a longer ski trip with the family. The imagination is still exercised but on a more limited holodeck.

The chief aim of all this mental simulation is to determine which decisions to make in reality. Eagleman and Brandt say the mental simulation is the process of mediating numerous inputs into a viable course of action. The mind deploys a trove of assimilated information in the service of exploring real world options. It is constantly dissecting and recombining ideas, experiences, skills, facts, everything in order to produce new thoughts that could be of use to us. Unlike computers, which return garbage information when fed garbage inputs, human minds can take garbage inputs and return real life gems!

Conclusion

Human minds cannot help but be drawn to the new, new thing. The shiny object that deviates from expected norms will always command our attention, but only for so long. Once the brain masters its pattern, it will lose interest in continuing to explore that pattern and move on to the next novel item. This gives the brain ample material for creating elaborate simulations about life and our environment in order to produce viable options for real-life execution and continued survival. It’s a never ending march that has transformed us from flint wielding huntsmen to space-bound astronauts.

Do You Know Who Invented the Super Soaker?

Siggy — Tue, 17 Nov 2020 13:00:17 GMT

Image by Freepik

I crouched as low as I could and crawled along the side of the brick stone building. My gun in my sweaty palms and senses on hyper alert. All I could hear were my own heavy breathing and the faint yelling of children somewhere in the distant background. I was inching my way toward the corner of the building so I could get a sense of where my assailants were. I had lost track of my team a while ago. I could only assume they had all been eliminated and I was the last survivor. I took a few more deep breaths and kept crawling towards the corner.

My gun felt much lighter now--fifteen straight minutes of firing will do that. If I could duck into the building, I could regroup and think of a new strategy for survival. I reached the corner of the building and peered around it very carefully. There was nobody in sight and just one old Honda parked in front of the building. I could get a better look around from behind the car. I got to my feet and made a mad dash for the car.

Whomp! Phoosh! Splash!

I felt like I got hit from a hundred different angles. I crashed to the ground and rolled over on my back in defeat.

They got me.

I could already hear the cackling of Jeff Larson and his stupid 5th grade gang, taunting me with “You’re all wet, sucker!”

It wasn’t a fair fight at all. My little pee shooter was no match for his Super Soaker 50. The arms race was on. I had to convince my parents to buy me one--somehow. Jeff’s lunchtime tyranny had to end.

So began my fascination with the Super Soaker and all its models. Beyond the SS50, there were models like the colossal SS300 with its three nozzles and 6-liter tank and the crazy Artic Blast which chills the water stream as it shoots out. Who thought up all this stuff, I wonder?

Enter, Dr. Lonnie Johnson.

Image by Johnson Research & Development Co., Inc.

To describe Dr. Johnson as an engineering heavyweight would be the understatement of all understatements. The man is a nuclear engineer who spent over a decade working at NASA’s Jet Propulsion Laboratory in Pasadena, California. As a life-long tinkerer and maker, the Super Soaker was more like a side hustle for him until it blew up, becoming the most successful toy in America almost immediately.

Finding his Passion and Immersion in the domain

Lonnie Johnson was born in Mobile, Alabama during the last few decades of state-enforced segregation in the southern United States. Although the cultural climate could be hostile to a young black boy like Lonnie, he grew up in a nurturing home where his father, a World War II veteran, taught Lonnie how to tinker with electrical gadgets.

Once his passion for gadgetry was ignited, Lonnie didn’t hold back. In 1968 he built a pneumatic robot and represented his all-black high school at the Alabama state fair. Unsurprisingly, to those who knew him, Lonnie won first prize for his creation. He went on to attend Tuskegee University where he earned mechanical engineering and nuclear engineering degrees before landing a job with the US Air Force and subsequently, NASA’s Jet Propulsion Labs in 1979.

He completely immersed himself in his domain, learning and soaking up as much knowledge as he could. Such dedication rarely exists without a driving passion to fuel it. Passion seems to fortify and enable a certain resilience against hostile environments, obstacles and the inescapable moments of drudgery that often accompanies deep work.

Playfulness

Johnson is a natural tinkerer and was always working on personal projects in his spare time. As Johnson tells it, he was working on a new type of heat pump that used water as a coolant rather than Freon. As he was testing out different nozzle designs, he hooked on up to a faucet and it shot water clear across his bathroom. To a non-playful mind, that probably would have been the end of it. Johnson, however, thought, “Hmm, that would probably make a really cool water gun?” And the idea was planted.

In their book, The Runaway Species, neuroscientists Anthony Brandt and David Eagleman propose a basic cognitive framework for understanding the way the brain synthesizes new information. Their framework identifies three basic strategies the brain uses: bending, breaking, and blending. These strategies are not mutually exclusive and often overlap, but I think Johnson’s thought pattern here was a good example of blending. Blending is when the brain combines two or more ideas or inputs in fresh and original ways. It is a powerful tool for creativity and innovation.

Johnson blended the unexpected event of his device shooting a stream of water across the bathroom, with his own playful memories of using a water gun, evidently unsatisfyingly. This new blended idea was compelling enough for him to actually create a prototype rather than simply discarding it as a nice thought.

Evaluation, Feedback and Collaboration

After Johnson created his prototype he tried selling the idea to several companies but was summarily dismissed by all of them, including Hasbro. Undaunted, or perhaps as a last resort, Johnson took his invention to the Toy Fair in 1989. There he was introduced to a small toy manufacturing company called Larami. After a brief demonstration, Larami agreed to license Johnson’s creation and the first Super Soakers hit toy stores in 1990.

Johnson said he thought about manufacturing it himself, however, the price tag for even a limited run manufacturing was too high for him at the time. That’s when he started looking for a manufacturing partner to license his idea.

Larami turned out to be a great collaborator for Johnson. Johnson admits that at the time he didn’t fully understand branding and marketing. And why should he, he’s a nuclear engineer. Early discussions with Larami’s owner resulted in the name we now know--the Super Soaker. Initially it was called the “Power Drencher” but licensing and marketing considerations caused them to change the name. Thankfully.

Following the success of the Super Soaker, Hasbro ended up buying Larami. Johnson kept on inventing and added to Hasbro’s product list with his creation of high-powered dart nerf guns.

Today, Johnson lives in Atlanta, Georgia and is still actively inventing and creating. He is founder and owner of two technology companies, Excellatron Solid State, LLC and Johnson Electro-Mechanical Systems. The former creates solid state battery technology and the latter is on the cutting edge of thermal-electrical energy production and transfer.

I told you he was an engineering heavyweight!

Even though I never quite got my comeuppance against Jeff Larson and his band of 11-year old malcontents, I have enjoyed countless hours of super-soaking fun since that day.

Subscribe now

The Future Belongs to Creators!

Siggy — Mon, 16 Nov 2020 13:00:36 GMT

Image by freepik

Take a look at the graph below. This is a McKinsey report showing how much each job category can be automated away with today’s technology. Which is to ask, how much of the current tasks performed in these positions will eventually be performed by robots (or more likely, software)?

The percentages run the gamut from 0% to 100%. And the results aren’t always what you’d expect. Can you guess what two jobs these arrows are pointing to?

The first arrow points to registered nurses with 2 million of them in the U.S economy and the second to pharmacists, representing 260,000. For pharmacists, 47% of their current job tasks can be performed by machines and for registered nurses that number is 29%. This means almost half of what pharmacists currently do and one-third of what nurses currently do can be accomplished by a machine--a machine that can work 24 hours a day with no vacation or sick days.

What about this next example? Can you guess what occupation this is?

That bubble represents the 2.4 million American workers who are waiters and waitresses. A usually reliable source of occupation for young workers, students and middle class families, waitering is incredibly vulnerable to automation. 77% of waitering tasks can be automated away with today’s technology.

Lest you underestimate the relentless march and wide reach of automation, here is where web developers stand:

Web Developers

And what about computer programmers in general?

Computer Programmers

Even these previously immune techie positions are falling to the beast of automation and technical obsolescence. After all, how many telegraph operators or linotype setters have you come across recently? These highly technical jobs were once competitively pursued and financially rewarding for their time. However, telegraphs gave way to the telephone and linotype to photosetting and computer-aided printing.

This sort of technical obsolescence is happening at an exponential rate today because new innovations often have a multiplicative effect on previous technology rather than a simple additive one. It took about 3600 years to progress from the invention of writing in Mesopotamia to the first wooden printing blocks in China around 200 CE. From there, it only took 1200 years to progress from wooden printing blocks to Gutenberg's printing press. And a mere 500 years to advance from the printing revolution to the desktop publishing explosion.

Exponential technological growth also means rapidly evolving skills demand across all industries. As new technology eliminates older jobs, it also creates a fresh demand for brand new jobs, often related to the operation and management of the same technology that eliminated the old jobs. When telephone technology gradually phased out the telegraph, a whole new career for switchboard operators was created just as the old telegraph operators were slowly being obsoleted.

This cycle of creation, obsolescence and re-creation is narrowing over time and resulting in shorter job tenure. Where in the past, it was fairly common and expected for a worker at General Motors to remain with the company his entire career, such life-long occupational marriages are far less common today. Modern workers are forced to constantly train themselves for new technological developments coming just around the corner.

However, training and skills acquisition are only part of the solution for workers of the 21st century. We have seen that even the most advanced technology jobs can and will be automated to some degree. So, how should 21st century workers future-proof themselves once the robots come for their jobs?

Ultimately, despite appearances, this is an article about encouragement not fear.

In that vein, here are four recommendations for future-proofing yourself and thriving even after the robots come for your job.

Face your fears

The first step is to accept the fact that change is coming. And it is coming for us all. There aren’t any occupations that are completely immune from automation of some degree. Sticking your head in the sand may work in Bugs Bunny cartoons but in real-life we all need a more effective strategy than simply wishing the problem away. Short of a global-level nuclear holocaust, technology only advances, it does not retreat. We cannot shove the AI toothpaste back into its tube.

Likewise, raging against the literal machine will get you nowhere and Zack De La Rocha himself will probably agree. As noble and well-meaning as the Uber and Lyft boycotts may be, their long-term effectiveness is doubtful. How successful were 19th-century Luddites at preventing the automation of the textile industry? It didn’t matter how many factories and mills they burned, their handlooms were just never going to compete effectively. Greater productivity drives profits and profits drive markets. As long as we continue to exist in a market-driven economy, novelties like self-driving cars and trucks will eventually replace human commercial drivers.

The sooner you accept this fact, the sooner you can identify alternative career paths for yourself.

Trust yourself to find solutions

Once the fear of obsolescence is handled, you’re free to start looking around and observing your surroundings with greater attention. For some habitual corporate types, you may be doing this for the first time in your life. The key is to understand that you are a conscious, thinking, self-directed entity with some agency over your environment. If you probe this environment with enough patience and curiosity it will yield insights (and opportunities) that would not have been apparent to you before.

Engage with your environment, no matter how immediate, and it can’t help but engage back.

In a lighthearted example, consider how abysmal our world would be today without the invention of chocolate chip cookies. Up until 1930, there was no such thing as a chocolate chip cookie. A horrible thought, I know.

We owe this great debt of gratitude to the resourcefulness of Ruth Wakefield. She ran a roadside tourist lodge called the Tollhouse Inn in the 1930s. Every morning, the Tollhouse Inn guests were treated to freshly baked chocolate cookies from Ruth’s kitchen. One morning, she discovered she had run out of the baker’s chocolate necessary to make her chocolate cookies. Rather than deprive her guests of her delicious treats, she decided to use whatever she had at her disposal. She broke bits of Nestle chocolates into her cookie dough, fully expecting the chunks to melt in the oven to produce regular chocolate cookies.

To my eternal gratitude, that isn’t what the laws of cooking physics granted. The chocolate bits clumped together and Ruth pulled out the world's first batch of chocolate chip cookies instead. Her little culinary improvisation became an instant success for herself and Nestle--and, of course, every kid’s birthday party since.

Embrace the practice of creativity

Creativity is the rocket that will power you through the detritus of the robot takeover. Let’s revisit McKinsey’s data for a minute.

Take a look at the chart below. Jobs that require a high degree of creativity and emotional intelligence have the lowest automation vulnerabilities--at least for now.

Producers and Directors

Healthcare Social Workers

This isn’t to suggest that we all need to become painters and poets to avoid being replaced by machines. It just means occupations that require a reasonably high degree of human ingenuity and creativity to produce their final outputs will fare well against automation in the near term.

Architects and Industrial Engineers all work in jobs where human creativity and insight is used to harness the laws of nature towards the production of a useful product or service. As a result these two occupations are similarly resistant to automation.

Architects

Industrial Engineers

Fortunately for us, creativity is a skill that can be improved with practice. Psychologists and neuroscientists like David Eagleman and Scott Kaufman, among others, have demonstrated through their research, just how neuroplastic the human brain can be. We are capable of learning and rewiring brains throughout our lifespan.

Recent creativity research also sheds light on the brain’s internal states when engaged in various classically creative activities. Seeking novelty, identifying patterns, synthesizing and modifying inputs to produce new outputs are all innate human brain behaviors which can be enhanced in almost anyone.

These skills also happen to be the most difficult for computers to mimic. The small consistent practice of creativity will inform every aspect of your life and significantly impact your personal and occupational output.

Give more than you expect to get

There is an old, overused adage that goes: “Life is a journey, not a destination.”

Or something to that effect.

I prefer the slight modification, “creativity is a journey, not a destination.” Where creativity is concerned, it helps to view the destination as a side effect of the journey. This doesn’t mean the destination is irrelevant, after all the destination is the whole reason you got on the road in the first place. It just means, after you’ve decided on a destination point, your journey to get there should command all your resources, effort and attention.

Focusing too much on the outcome (your destination) counterintuitively makes the creative journey more difficult and less effective. The personal growth we desire only happens as we exert effort during the creative process with little expectation for the outcome. The work that results is akin to a road marker or a way of keeping score. The real personal benefit is within the process and how you improved along the way.

This method of giving yourself completely to a process without a guarantee of the outcome is, paradoxically, the most likely way to achieve that outcome. If this sounds scary, congratulations, you’re paying attention. It's the reason the first step is to face your fears. Without doing so, none of the subsequent steps are possible. Recognizing a threat, trusting yourself to find a solution to that threat, embracing the intangible concept of creativity and then leaning into it by committing precious time and resources without a guaranteed outcome is downright terrifying!

A reckless gamble?

Perhaps it is, perhaps it’s not, but I’m willing to bet this is the sort of gamble every remarkable individual you’ve ever admired in life made.

People like Van Phillips who, after losing a leg in a horrific water-skiing accident, devoted his life towards the invention of a new type of prosthetic that would enable him to run and play sports again. It took twelve years of toiling before Phillips released his Flex Foot Cheetah line of performance prosthetics. These were the same prosthetics Oscar Pistorius wore to compete in the 2012 Summer Olympics.

Another famous example is J. K. Rowling’s life leading up to the publication of the first Harry Potter novel in 1997. As Rowling describes it, in 1990 she was working for Amnesty International in London while living in Manchester, England. On a long train ride from Manchester to London, she got the inspiration for a story about a young, bespectacled boy wizard. Rowling was so gripped by the idea that she started writing it immediately. However, the next seven years were anything but smooth for the then 25-year-old Rowling.

She endured the passing of her mother in 1990, an abusive relationship in Portugal with her first husband and one miscarriage before the birth of her daughter. By 1994 she had moved to Edinburgh and was living on state benefits while rearing an infant. She admits to feeling like a failure during that period of her life, but she kept writing her novel--with no guarantee of the outcome.

She finished her manuscript for Harry Potter and the Philosopher’s Stone in 1995 and was rejected by twelve publishers before finally being accepted by Bloomsbury Publishing House. Even after her book was accepted by the publisher, they advised her to get a day job because they had low expectations about her profitability as a children’s book author.

Bloomsbury published her book in June of 1997 and eight months later it won the British Book Award for Children’s Book of the Year. The rest, as they say, is well known history. Nobody could ever have predicted how well her books would do, but that’s the point. Even without a guaranteed “pay-off” at the end, she kept toiling away at her book for five years and endured rejection for almost two more. It took seven years of steadily giving to her vision before the world was graced with her tale of the orphaned boy wizard we know and love today.

Conclusion

Automation will eventually eliminate a considerable fraction of all jobs. Unfortunately, some jobs like low-level manufacturing positions and commercial transportation have a higher exposure to automation than others. These industries will experience the greatest amount of upheaval in the form of industry shrinkage and worker displacement.

Industries with the lowest-exposure to automation, for now, involve work that is highly creative and requires substantial emotional facility. We see this in creative industries like architecture, entertainment, legal and social services to name a few. Novelty, creativity and human emotions are all incredibly difficult for machines to produce with any consistency.

When automation and redundancy finally come for you it’s good advice to:

Face your fears. Automation and the accompanying change is an irreversible tide
Trust yourself to find solutions. Engage with the world and try new approaches because what you seek is out there
Embrace the practice of creativity. Lean into the greatest strength you possess as a creative human being
Give more than you expect to get. Even though the creative journey will be long and arduous with no guarantee of a destination prize, you should still commit yourself completely to taking the journey

Subscribe now

Art + Code = Delightful Creativity

Siggy — Mon, 16 Nov 2020 05:55:24 GMT

Welcome to Siggy Works by me, Siggy.

I write mostly about creativity and software development. I'm still not sure if I'm an artist who writes code or a coder who makes art.

Subscribe now

In the meantime, tell your friends!

Siggy's Notebook

An Artist's Guide to C# in Unity3D: Classes

Parts of a class

Using a class

Other details about classes (access and scope)

Try it out

An Artist's Guide to C# in Unity3D: Functions and Methods

Function Basics

Try it out

An Artist's Guide to C# in Unity3D: Flow Control

Making branching decisions

Conditionally repeat a block of actions

Iterate through items of a collection

Try it out

7 Myths about Creativity

Myth 1: Only a chosen few are born creative

Myth 2: Painters and poets are creative but certainly not doctors or accountants

Myth 3: People are Left-brain or Right-brain dominant

Myth 4: Mental illness improves creativity

Myth 5: Creativity is an individual endeavour

Myth 6: Creativity strikes in a flash of brilliance

Myth 7: Creativity cannot be learned

Summary

An Artist's Guide to C# in Unity3D: Collections

Basics of a collection

Arrays

data_type_to_store[] name_of_the_array = new data_type_to_store[number_of_items_you_intend_to_store];

Lists

List<data_type_to_store> name_of_list = new List<data_type_to_store>();

Dictionaries

Dictionary<data_type_of_the_key, data_type_of_the_value> name_of_dictionary =

new Dictionary<data_type_of_the_key, data_type_of_the_value>();

Try it out

An Artist's Guide to C# in Unity3D: Operators

An Artist's Guide to C# in Unity3D: Common Data Types and Variables

An Artist's Guide to C# in Unity3D: Creating your first script

An Artist's Guide to C# in Unity3D: Setting up your learning environment

Imaginative Play and How to Improve Yours

Adults are Kids Too

Adult Barbie Dolls and Fire Trucks

Imagination Games

Human Beings: Those Novelty Addicts!

Pattern Interruptions: Brains evolved to pay attention to differences and novelties

Repetition Suppression: That joke you’ve heard 1000 times is no longer funny

Imagination: An infinite simulation holodeck

Conclusion

Do You Know Who Invented the Super Soaker?

Finding his Passion and Immersion in the domain

Playfulness

Evaluation, Feedback and Collaboration

The Future Belongs to Creators!

Face your fears

Trust yourself to find solutions

Embrace the practice of creativity

Give more than you expect to get

Conclusion

Art + Code = Delightful Creativity

`data_type_to_store[] name_of_the_array = new data_type_to_store[number_of_items_you_intend_to_store];`

`List<``data_type_to_store``>` `name_of_list` `= new List<``data_type_to_store``>();`