Hey everyone,

I'm so excited to have you back! Today's going to be a good one, because there's so much information that I will be able to provide you in how _variables_ can be used in your programming careers and lives in general. _Variables_ and _Data Types_ are the backbone of (pretty much) everything in the programming world. We'll even dive down the Rabbit Hole in order to show you how you can use _Variables & Data Types_ in cooperation with each other to create _objects_ that can, then, be reused and used as a hierarchy chain of other objects.

![](https://steemitimages.com/DQmTXAQC3FykbHkbnGekVQszQ9tnMi2jfznHV7Ce3Hyf3cT/image.png)
[Source](https://www.google.com/search?tbm=isch&q=down+the+rabbit+hole&chips=q:down+the+rabbit+hole,g_1:alice+in+wonderland&sa=X&ved=0ahUKEwieyP6lz_XXAhUF7YMKHcLfCNEQ4lYIKCgA&biw=1536&bih=759&dpr=1.25#imgrc=NH_Tfps6r4jSsM:)

So, without further Ado...

_**Variables**_

Ok, so here we sit on the edge of our seats, wondering what I'll say about the greatness of _variables_. _Variables_ are, as I described previously, basically a way to store information for later use. It is the Mathematics of the programming world. These are the components that make the Hamster run inside his proverbial wheel.

![](https://steemitimages.com/DQmQvRpGQRoXgRNRNK243rxSUBfnBoB4qCuA6SLLAq34X9n/image.png)
[Source](https://www.google.com/search?biw=1536&bih=759&tbm=isch&sa=1&ei=IQIoWqruL6HMjwSX1JPIDA&q=steampunk+hamster+in+a+wheel&oq=steampunk+hamster+in+a+wheel&gs_l=psy-ab.3...6957.8275.0.8498.10.10.0.0.0.0.115.807.4j5.9.0....0...1c.1.64.psy-ab..3.1.114...0i13k1j0i13i30k1j0i13i5i30k1.0.Jfk7sgOyKXY#imgrc=iRy3HCzAV_JEMM:)

_Variables_ can come in any _data type_ as long as it's storing the correct information in the appropriate way. There are mathematical-based _variables_ (integers, decimals, floating point decimals, etc.) and word/character-based _variables_ (text strings, characters) and dates and lists and other cool stuff! All of these are used to create a foundation for your own programming. In conjunction with coded logic, the program that you build and execute can do a nearly-infinite number of things based on what's happening.

This is why, when asked by clients or other people _"Can you do [insert crazy request here] on the computer?"_ I like to answer back that "I can do almost anything that's needed, but some of the things just might not be feasible in the limited amount of time that I have." I mean, let's face it, we as Humans can program Space Shuttles and orbital Satellites; Video Games and applications that are made specifically to make us avoid knowing what's going on in the world; and program Robots to perform tasks that we can't physically perform or that we believe is _beneath us_. I tend to program in the hope that some day I can start and finish a video game (which I believe is where we will be heading as these tutorials ramp up) or to automate mundane work tasks that take up my valuable time.

![](https://steemitimages.com/DQmSYksVQjAeGsHaV14GdYERRYh1VVqGjWuc3Gz2Nkta7MU/image.png)
[Source](https://www.google.com/search?biw=1536&bih=759&tbm=isch&sa=1&ei=PgQoWtA9qNePBJ3YsZAM&q=steampunk+pocketwatch&oq=steampunk+pocketwatch&gs_l=psy-ab.3..0i10k1l9j0i7i30k1.14486.15108.0.15265.6.6.0.0.0.0.141.559.5j1.6.0....0...1c.1.64.psy-ab..1.5.464...0i13k1.0.uBwdrNT0DqY#imgrc=IahxO9Ge4yFjLM:)

The thing is, _variables_ at their core are just arbitrarily-named _data types_. As an example, here is what most would agree is a naming convention that (while maybe not perfect) tells what it is and what it does:

decimal invoice_tax_percentage; //boring, but it says so

...and here's one that most **should** agree is horrible:

decimal Turkey_sandwich_on_Rye; //uh, what? are we ordering sammiches for everyone?

As you can see, that last one doesn't say anything about it and does _not_ give any indication of what it will store. Then, of course, you have the standards ones that I see all the time (a la basic math formulas):

`int x; //x can be anything`
`int y;  //y can be anything`

I actually use these, but only in a temporary way. For, you see, _variables_ can be set at a _public_ level or a _private_ level (or internal or protected, yes) and each of these explains directly the access level. A _public variable_ is one that can be accessed anywhere within the _class_ or from a _derived object_ of the _class_... this means, to try to put in more understandable words, that if you create an _object_ called **character** that holds character attribute stats for a D&D-style Character Sheet ([as was discussed here](https://steemit.com/programming/@dbzfan4awhile/c-programming-beginner-tutorial-a-first-look-at-actual-code-using-d-and-d-as-the-project)), the _variables_ within the class can be used outside of it if someone were to create an _object_ of _data type_ **CharacterSheet**.

As an example:

`using DnD_Character_Sheet;`
.
.
.

`CharacterSheet my_character_sheet = new CharacterSheet();`

.
.
.

`my_character_sheet.Dex += 1; /increase the Dex attribute on my character sheet by 1.`

So what you see above are 3 lines that would first (_using DnD_Character_Sheet_) link the new program to the code in the **CharacterSheet** _class_ in order to utilize its functionality. the _using_ statement is a way to say "please _use_ the following _class_".

The next line that you see (_CharacterSheet my_character_sheet = new CharacterSheet();_) creates a new _instance_ of the _class_. This is the key to using _objects_. You have 1 base _class_ (**CharacterSheet** here) and you can create many different _objects_ from it. Then, each of those _derived objects_ can use the same internal structure.

What I mean is that each has the attribute-based _variables_ that are accessible outside of the _class_ code itself (because they are all set up as _public_) and a couple of _functions_. The only _function_ (action-based code) that is accessible outside of the _class_ itself is the **DiceRoll()** _function_ as all of the others are considered _private_.

In the hopes that I'm not losing you, because we're sliding down the walls in this Rabbit Hole very quickly! I know this is becoming a bit jargon-y and I apologize, but these are definitely terms that you need to understand and grasp to become a successful programmer. 

Let me know in the comments whether this makes sense or if I need to spend more time in my next Post discussing _Variables_. The one thing you can count on is that they will be used in almost all (if not all) programs that you build.

![](https://steemitimages.com/DQme5PuiDArs1NB5NeJ7rWmMhAwjELGwgSMi9CVh8Re7L9x/image.png)
[Source](https://www.google.com/search?biw=1536&bih=759&tbm=isch&sa=1&ei=YAIoWvbSD-TVjwTq8Y3ACg&q=confused+meme&oq=confused+&gs_l=psy-ab.3.0.0l10.108154.110490.0.111640.11.9.1.1.1.0.128.706.7j2.9.0....0...1c.1.64.psy-ab..0.11.719...0i67k1.0.rX0_pkmanAI#imgrc=s71mvapg0bqv2M:)

Now, let's actually spend some time discussing _Data Types_ and what they can do.

_**Data Types**_

So, _Data Types_ are basically exactly what they say they are, but more confusing. Underneath it all, they are just pieces that can only use certain types of information. Below I have a list of the most common _data types_ that I use:

_char_: A text-based character... to define a _char_ you use single-quotation marks surrounding a single character.

_string_: A text-based string of characters that can relate nearly anything... to define a _string_ you use double-quotation marks surrounding the entire line of text.

_int_: An integer, a positive or negative whole number or zero (-25, 0, 31, 142322)... to define an _int_ you use no markings except for the _minus_ (-) sign if negative. Keep in mind that large numbers do _not_ use commas.

_decimal_: A positive or negative number that can include digits after the decimal point (25.345, -13422.1, -5)... to define a _decimal_ you use no markings except for the _minus_ (-) and the letter "m" at the end.

_double_: This is a less-precise version of _decimal_... define like a _decimal_ but use the letter "f" at the end.

_bool_: This is a boolean _data type_ and defines true/false and nothing else.

_DateTime_: This is a _data type_ that represents a Date and Time... to define a _Date_ you set it by calling the DateTime(...) function and populating the appropriate parameters that are passed-in (year, month, day, hour, minute, second, etc.).

...the next one is a more advanced _data type_ that is very useful and you will find yourself using it (or a variant) quite often:

_List_: This _data type_ literally says what it stores (a list). The usage is to define the _data type_ that will be stored within angle brackets (![](https://steemitimages.com/DQmQCt5KrGKAs6qkvNC8cDKd9Y4zsRofowSJxRXNUPRbFJH/image.png)) and then populate the list. Then, after populated, the list can be defined as an array of items (multiple instances of the same item) without having to define each _variable_ individually.

![](https://steemitimages.com/DQmcsY3WCsdgp7tZ34DsNxjgcXNFzjdmBDRMQSsMvnqHCJj/image.png)
[Source](https://www.google.com/search?biw=1536&bih=759&tbm=isch&sa=1&ei=YQMoWsjINKndjwTTtZe4Cw&q=funny+grocery+list&oq=funny+grocery+list&gs_l=psy-ab.3..0i67k1j0i24k1l3.1706.1706.0.2176.1.1.0.0.0.0.128.128.0j1.1.0....0...1c.1.64.psy-ab..0.1.128....0.prudMl50TLE#imgdii=wXglWzCPJh_zsM:&imgrc=-eQC5Cn9fYKufM:)

_**The Examples**_

`char middle_initial = 'J'; //notice that the character itself can be Uppercase? it can also be symbols, but they get complicated sometimes.`

`string my_character_name = "Aaron Jaxler";`

`int threat_level = 0;`

`decimal  inventory_weight = 235.0m;`

`double character_weight = 185.0f;`

`bool is_equipped = false;`

`DateTime anniversary_date = new DateTime(2005, 5, 12); //this is just one option that defines it as May 12th, 2005.`

`List`![](https://steemitimages.com/DQmbxK4MhtY1rk4qtXRYRKWR7vFHXbEinp7fXpAMtjm5cQn/image.png)`  equipment_items = new List` ![](https://steemitimages.com/DQmbxK4MhtY1rk4qtXRYRKWR7vFHXbEinp7fXpAMtjm5cQn/image.png)` (); //then you have to use an _extension method_ to Add an item.
equipment_items.Add("Pocket Watch");
equipment_items.Add("Bull Whip");
equipment_items.Add("Cast Iron Skillet");`

![](https://steemitimages.com/DQmembKb7J47pwpzz2n6jXeUT9pUnmWdyxWGDMpm4xXU73e/image.png)
[Source](https://www.google.com/search?biw=1536&bih=759&tbm=isch&sa=1&ei=KwIoWvqSFInVjwSGpK7AAw&q=satellite+passes+pluto&oq=satellite+passes&gs_l=psy-ab.3.1.0i24k1l4.47519.50097.0.52075.16.13.0.3.3.0.102.980.12j1.13.0....0...1c.1.64.psy-ab..0.16.1004...0j0i67k1j0i30k1j0i5i30k1j0i8i30k1.0.p30hEL2SAiQ#imgrc=V65Nsmj4BXN2lM:)

_**In Conclusion**_

Well, that's today's lesson for all my C# Programmer wannabes! I hope it gives you a ton of information without being too difficult to follow. Again, if you have questions or wish me to dive deeper into these 2 components, let me know if the Comments Section and I'll jot down plans and get further examples.

Once you have a bit of a grasp on _variables_ and _data types_ you should really begin to understand just how important they are and how versatile. They are the components that hold the critical details of the program. Without them, you basically have a shell without anything inside. An empty shell is only worthwhile if it's been decorated to look beautiful so that it can subsist without substance.

![](https://steemitimages.com/DQmSuRvaWExRrx7hf24ph29qSWQum8Hme1iSdW1tLwAkFTp/image.png)
[Source](https://www.google.com/search?biw=1536&bih=759&tbm=isch&sa=1&ei=8gMoWrKdMKy-jwTqjrrADg&q=empty+carved+eggshell+dragon&oq=empty+carved+eggshell+dragon&gs_l=psy-ab.3...37206.37979.0.38377.7.7.0.0.0.0.78.477.7.7.0....0...1c.1.64.psy-ab..0.0.0....0.SoOBmG-jt4c#imgrc=pEnEiozYtkBbWM:)

Thanks everyone! See you next time!!