DEV Community: Scott Slatton

Should You Get Certified As A Developer?

Scott Slatton — Fri, 23 Aug 2019 04:53:06 +0000

Currently I’m gearing up to take a few Microsoft exams to get my MCSA and eventually a MCSD. I’ve read quite a few articles debating the pros and cons of getting any certification regarding software development and like a lot of things in this industry, the comment sections seem strangely gate-keepy, asserting that real developers don’t need certifications. I don’t subscribe to this thinking at all and I think it’s never a good look to try to shame someone who is only trying to better themselves.

Why Bother Getting Certified?

I think the reason some people are so hostile to the idea of getting certified is because in software development is because at the end of the day your application either works or it doesn’t. A sheet of paper saying you know something is cool, but if you can’t properly implement anything you were taught then who cares.

I find that this line of thinking is more in tune with intuition rather than reality though. Chances are, if you spend all of this time outside of work to improve yourself, it shows that you really care about what you’re learning and that you’re the type of person who is dedicated, serious and professional.

Another major reason a certification may help you is in overcoming imposter syndrome. Sounds really cheesy I know but confidence is a big deal and being able to speak with greater authority makes a huge impact on people’s trust in you to deliver on what you say you can.

During my time in IT I grew accustomed to studying for certifications and getting that badge on my resume that says, “I definitely know this thing. I dedicated my own time to go in-depth in this subject and earn something that proves I know this thing.”. Honestly, I love the journey of learning that ends in a satisfying reward, like a well told narrative with the final acquisition of the certification being substantially gratifying because you truly earned it.

So why am I going for the MCSD? Well right now I live near Seattle and there are a couple of major players here, namely Amazon and Microsoft. Both of these titans have sent waves across the industry. Amazon are known for being hungry for Java developers and Microsoft obviously want engineers knowledgeable in a language they own: C#. These two languages are pretty similar so what’s important is getting the fundamentals down and building projects that can reflect your skill in that language. Personally I chose C# because I could easily put my newly acquired knowledge into visible, functional code using the video game engine Unity that I’m already familiar with using which uses C# to program game logic. Microsoft certifications are also a boon to some employers as they need a certain amount of Microsoft certified employee’s to maintain partner discounts.

Let’s say you’ve decided you actually want to pursue a certification, below you’ll find the tests you need to take to get yourself certified.

Java Certification Path

You can find the path here.

Oracle is the company that owns the Java language so you’ll be taking their tests. They are multiple choice and cost $245 each.

There are two tests you must pass, Java SE Programmer I will earn you the title, “Oracle Certified Associate”. The second is the aptly named Java SE Programmer II bestowing upon you the label, “Oracle Certified Professional”

Microsoft Certification Path

Microsoft exams are a little different. You can find the path here.

As you can see they have a branching path depending on what technologies you want to specialize in. If you want to stick to web development, I suggest taking the top path consisting of “Programming in C#”, and “Developing ASP.NET MVC Web Applications”. Finishing these two multiple choice tests will net you the MCSA certification leaving you with one of three tests left to earn your MCSD. Take the one that looks most appealing to you.

Each test costs $165 for every try.

You take two exams of three possible choices to get your Microsoft Certified

The Journey

The first thing I do to prepare for these exams is to look at the learning objectives, book mark the page and continually come back to make sure you’ve covered everything. If you get squeamish just looking through the list of what material you’ll be tested on, it’s probably a sign that you need more practice. Some people may say that the first thing you should do is actually schedule the test and this to force you to stop procrastinating and get a move on.

Remember, diamonds are formed under pressure.

In my studies I’ve found some fantastic resources for learning and reinforcing concepts. I find that I am the type of person who needs multiple types of learning materials in order to solidify my understanding of a subject. Sometimes I can watch a few hours of lectures, then perform the tasks on my own. However, I’ve also found that just picking out a feature and reading about where to get started or only resorting to the internet when I get stuck can be incredibly helpful.

Getting Handsy

Currently I’m using Pluralsight for the bulk of my studies but I find that if I’m not explicitly following along in my own code editor I can drift and end up rewatching sections over and over.

To alleviate this, I try to recreated major milestone projects that I went through during my time at Flatiron School in order to get real hands-on experience.

These projects include (in order):

Creating a database and populate it with info pulled from a web api like pokeapi.
Creating a CRUD (Create Read Update Delete) console application that can manipulate that data pulled from the web api.
Serving up web pages and handing forms (again CRUD)
Creating your own API that a front-end can talk to in order to store and manipulate data.

To me this is real development, you’re actively learning and applying concepts in order to create a functional product. What more can you really ask for?

C# Generic Collections

Scott Slatton — Fri, 16 Aug 2019 06:49:29 +0000

One thing I’ve heard before and definitely am guilty of repeating before knowing the meaning of, is the statement: “Javascript doesn’t have arrays it has lists”. I’ve always understood this to basically mean nothing because “functionally, they’re the same” and when you’re learning Javascript for the first time, this can be a good philosophy to have because you don’t get bogged down with theory and can focus your attention on just building things. When I began delving into C# however, starting to use it on a daily basis, this philosophy caught up with me quickly. I’ve known for quite a long time that arrays in languages other than Javascript have a fixed length that you must declare at some point. It was incredibly intimidating and I struggled to understand how you work around this limitation. I’d like to share with you my “Aha!” moment I had when I finally understood that learning data structures and when to use them became so pivotal to creating proper, functional and optimized code.

C# has a namespace in the .NET library called System.Collections.Generic and it’s within here that you can find your lists, stacks, and queues. These are typically data structures you have to build out manually in Javascript. You can instantiate any of these like a normal object declaration.

List<T> grades = new List<T>();

Sidenote: If this is the first time you’re seeing the it’s a generic type parameter, meaning you can fill in that parameter with any type recognized by the compiler like string or double.

Lists do obviously come with a higher memory cost than normal arrays but solves our issue of needing to know how many items are going to be in our array if you’re not sure . My favorite thing about using these built in data structures is that they come with methods built in as well. You can easily implement a binary search on a list by calling .BinarySearch() on the List object instance.

A Quick Look into Gameplay Programming with Unity

Scott Slatton — Thu, 08 Aug 2019 14:49:11 +0000

Since graduating Flatiron School back in May of this year, I have put a lot of my focus in coding on my personal passion: game development. I learned C# in order to script in Unity, a 3D game development program that I learned how to use back in college. However I was never properly taught how to code before my bootcamp experience so I’d say that my eyes have been opened like never before. Now I’d like to share with you some of the things I’ve learned over the past few months.

Lets jump right in!

What Are Components?

In Unity there are bits of code that can be coupled on individual objects. These bits of code are called components, because they are modular and can be appended on to many different types of game objects in order to increase functionality. You can think of a component as a ball and socket system where components can interface with other components extremely smoothly.

When you’re developing gameplay systems in Unity you are basically putting these components together in a cohesive manner so that they talk to each other and create a fun gameplay loop for the player. Unity uses C# in order to write scripts that function as components on these objects, so you can not only make a simple health variable, but you can create a regenerative health system that can be applied to anything with a simple drag and drop.

Getting User Input

To get user input for movement is actually very simple. In Unity, you just need to access the Input class and specify by String which Input you’d like to access.

Making Variables Available Inside the Inspector

You can make variables inside your script accessible from the outside in the Inspector by using the “Public” flag in front of your variable declarations.

As you can see in the script above we've made our movement speed accessible in the inspector.

Not only can we utilize the “Public” keyword to make integers, floats and strings accessible, we can make components and therefore their properties accessible as well.

Collisions

Collisions are where Sir Isaac Newton steps in and adds some fun physics to our game. You can build entire games from just Rigidbody collision mechanics (See Angry Birds). Like much of everything in Unity Colliders come as components, specifically Rigidbody and Colliders.

From the Unity Docs:

A Rigidbody is the main component that enables physical behaviour for a GameObject. With a Rigidbody attached, the object will immediately respond to gravity. If one or more Collider components are also added, the GameObject is moved by incoming collisions.

Colliders on the other hand are the invisible boundaries that actually bump into each other.

So if we want our game objects to be influenced by physics, we need both a Rigidbody component and a Collider. If you don’t have a Collider, objects will be able to pass through other objects. If you are missing a Rigidbody, the object will not be influenced by physics but will repel other objects with Colliders. This is an important feature because we can make our aspects of our level, like the ground and closed doors, impassable for our players.

Those are a few of the tools we can leverage in Unity to create the games that people love to play. Next blog post I’ll go into Triggers, Raycasting, and interactions between different scripts.

Intro to C# for Javascript Developers, Part 1

Scott Slatton — Mon, 22 Apr 2019 18:27:49 +0000

Currently I’m in the last stretch of the Flatiron School’s code camp and at this point in time I’ve learned Ruby and Javascript as my primary programming languages. The time to start applying jobs is heading toward my cohort like a flaming meteor and imposter syndrome has been settling in on my peers quite harshly. When looking at job applications they see a bunch of technologies that they don’t know combined with abbreviations that they may not have seen or haven’t had the time to take a look at yet. I know that these are incredibly smart individual's that pick up concepts and start applying them at a level nearing light speed. So it's really just that they need to be exposed to these other technologies to realize that they have the core concepts down so well that transferring them will be no problem.

With that said, I’d like to just try to pile on right now and show another programming language to my peers, one that they haven’t had their hands on yet. My goal isn’t to make anyone sink in their seats and feel discouraged and crushed from the overwhelming amount of information, but to show that if you’ve made it through to the final round of Flatiron (or if you can comfortably code in Javascript) that taking on another language is really trivial.

There's a saying that “Once you know how to code the rest is just syntax.” and I want to prove just how real that is. It’s not just a nice sounding platitude and I’ll prove it by showing side by side common functions and syntax of javascript with their C# counterparts.

C# Background

C# (pronounced See-Sharp) was released in 2002 to go alongside .NET framework from Microsoft. If you don’t like Microsoft for some reason, that’s okay, C# and Java are syntactically very similar so you can go between them fairly easily. The point of these languages was to increase productivity, be easy to use, and deploy. C# can be found in the Unity engine if you have an inclination toward Game Development (like me) and can also be used to make native mobile apps. They are strongly typed languages, meaning that you must explicitly declare what a variable’s data type is.

However, C# does have implicit conversion like Javascript which makes it very dynamic. C# is also a compiled language instead of interpreted, meaning that you must first turn your code into crunch-sized bytes before running the program. These programs are still interpreted top to bottom though just like JS so be careful when you are declaring and calling variables and functions. Another thing to note is that C# utilizes camelCase for local variables and parameters and PascalCase for class names and methods. Automatic garbage collection is another feature. Both C# and Javascript are based off of C so you'll see quite a lot of similarities.

Anatomy of the Class File

Alright don’t get scared off by that code up there I’m going to walk you through it real quick and show you that you already know what all of that is doing.

At the top it says “using System;” this is just an extension so it's just like "Import X from "./Xfile" for a library you'd see in JS or "Require Gem" in Ruby.

Move down we have "Namespace Test" which as you can guess namespaces all of the text in the file as "Test" to protect it from outside disturbances and from polluting the namespace of your application as a whole. You can call it whatever you want.

Continuing on we have "class MainClass" which as you can expect, starts the body for the "MainClass" class code. This can be changed to "User" or "Pikachu" this shouldn't be anything unexpected.

Line 5 is where the seemingly unfamiliar steps in but once I break it down you'll realize you know what every word does.

"Public" this is a declaration of the scope of the incoming function, it's either publicly available for use or Private.

"Static" is a keyword that declares that the method is global and can be called without creating an instance of the class.

"Void" is the return value of the function, as you may recall in JS Console.log() doesn't have a return value, it just prints to the console and is finished.

"Main()" is the name of the function and acts as the entry point of the application. Only one class in your application needs the Main method and you can specify which class' Main method you want to use in the IDE if you have multiple.

"string[] args" are the parameters for any arguments passed into the Main() function at runtime. This is completely optional to have in there and you can omit them if you don't plan to use any arguments during runtime. You can name "args" whatever you want, its just a parameter name.

Console.WriteLine("Hello World") is, as you'd expect, just Console.Log() or "puts" in JS or Ruby.

Hopefully it doesn't look so scary anymore.

Variable Declaration

The main difference between variable declaration in C# vs JS is that the type of variable needs to be declared immediately before the name of the variable is given.

So in JavaScript you'd see.

let greeting = "Hello"

But in C# the same variable needs to be declared as:

string greeting = "Hello"

Here's a short list of common datatypes used in C#, a longer list can be found here.

string greeting = "Hello World";
int number = 100;
double trouble = 10.2;
char grade = 'A';
bool beef = true;

You can also declare a variable and then assign it later, as shown below.

The ReadLine() function assigns the user's input value to the "name" variable and then logs the last concatenated string to us. Very basic, but this should be very familiar.

Looping Through An Array

In C# there are many different ways to declare array's. In the example shown above is personally my most comfortable way to make a new array but we can also declare how large an array is going to be before we use it, as a memory saving feature of the language. The for-loop in use is also nearly identical to what you would see in Javascript.

Hopefully this demystified a compiled language for you and will help you feel a little more comfortable when you see one of these languages on a job application.

In my next post I'll be going over MVC, Objects and Iterators. We're not done yet!

Game Development Pipeline and Technologies

Scott Slatton — Mon, 08 Apr 2019 18:53:53 +0000

If you want to get into game development there are many paths you can take and in this article I'm going to go into the pipeline, the job responsibilities, and the technologies that go into making a game today. I'll try to include as many links as possible and it's my hope that you can come back to this post in the future to use as a starting point to lead you down the path you'd like to follow. I'd like you to keep in mind as well, that you can get started with gamedev today, absolutely free. I think it's also important to know that you also don't need to know how to code to get started.

NOTE: Analysis Paralysis is a very real thing so I suggest that if you truly want to get into making games pick anything that looks interesting to you from the outline below and just go ham. Absolutely dig into whatever it is because if you stand on the sidelines carefully picking out your technologies, you'll be left in the dust. Software changes constantly but the underlying principles do not, so just get started on something!

What is a pipeline?

In game dev a pipeline is a clear, methodological process to produce assets and features that go into a game. I'll be taking you through an overview on the process on how a game is created.

Design Document

The process starts with a design document, known as a GDD (Game Design Document) it outlines the necessary steps and overview that will go into a game. This document should be treated as the IKEA manual for making your game. It should include art inspiration and the logic behind certain decisions. Your GDD should be expected to have eyes from every department on it so it needs to be as fleshed out as possible. This document isn't necessary for a one-man team but I find that creating a GDD is pretty fun and takes my idea out of the realm of fantasy and puts it one step closer to being enacted. A portfolio of GDD's can also serve as inspiration for a future project, as you can pull from this body of work to build something new.

Prototyping

Prototyping can happen anytime that the GDD is being built. Prototyping is basically creating a physical game before you start work digitally. By creating a board game or testing mechanics outside of a game engine, you can very quickly decide what is and isn't fun. This is where you would apply your knowledge of Game Theory and check to see if your resources are balanced, if the incentives are there. If you aspire to be a Game Designer you will more than likely live and thrive in this phase. In this stage you can assess level design and player decision and actions. Mario was famously designed using just graph paper for the levels.

Technologies Used:

Dice
Playing Cards
Grid paper
Photoshop (for making custom cards or maps)
Pencils & Pens

2D vs 3D

During the prototype phase you probably have had this choice picked out already, but once that phase is over the decision needs to be made. Are you going to make a 3D game or a 2D one? When making the decision, the one thing that I'd say that is most important to consider is the size of your team. Are you a one man army? If so it might serve you better to stick with 2D. This is due to the amount of work that comes with 3D. By sticking with 2D you can focus almost solely on the level design, player interactions and crafting a story for the player (if that's what you want). With 3D you have to consider not only animation, and texturing (known in 2D as "sprites") but you have to model all the assets as well and create a whole lot more of everything in order to fill the space that the player can now traverse through.

On the flip side of the coin, 3D now encompasses Augmented Reality (AR) and Virtual Reality (VR) and even without these technologies just makes an entirely different experience for the player than 2D. By all means I do not want to discourage anyone from starting an adventure into 3D but I want them to be prepared for the struggles to come.

Game Engines

Game engines are the sandbox that you put all of the pieces of your game together. They take care of the collision and interaction between objects and players as well as the networking and lighting. Programmers will be working mainly within the engine chosen. Picking a game engine is a large decision that should be informed mainly from what you want to do and what you know already. If you want to make a 2D game you can go with Game Maker Studio 2 for a 2D exclusive experience. It uses a proprietary programming language called Game Maker Language (GML) which has a reputation of being pretty easy to pick up. One notable game made in Game Maker Studio is Hyperlight Drifter

If you've read anything about game engines then you probably know what's coming up. The two titans of game engines are Unity and Unreal Engine (known as UE4). Both of these are free solutions (up to a point) and support 2D and 3D projects. There are many notable games made in UE4 but by far the most popular is Fortnite.
As far as programming goes, Unreal uses C++ and a drag and drop system called "Blueprints" where you can buy modules of code that other programmers have made for a specific feature (like wall climbing) and use it with minimal coding experience necessary.

Unity on the other hand, uses C# as the main programming language. Previously they supported a version of Javascript called Unityscript but that has been discontinued. One of the main strengths of Unity is it's community. Unity has a very large community with a wealth of shared information. One game of note made from Unity is Hearthstone.

Modeling

Modeling is a 3D specific process to create art for games, movies, and other forms of visual media.. It's a mathematical and visual artform where you create objects or characters for games or movies. Personally I find 3D modeling really therapeutic, in the same way making pottery or painting can be. That being said it can be a huge time sink, so professional 3D modellers become masters of their software with shortcuts memorized and value of work judged not only on how good something looks, but how fast you could make it. 3D objects have to be made in specific ways so that the game engines run them efficiently and don't outright break. To learn 3D modelling I suggest following some basic tutorial series to ensure you're following best practices (such as "no N-gons", polycount and proper UV unwrapping).

Another thing to take note of is the difference between Character Modeling and a general 3D modeler. Character modelers are highly specialized artists due to the detail and development required of them versus someone who needs to make a brick or a lamp. A technique known as "High to Low Poly" needs to be utilized in order to make extremely detailed models usable within a game engine.

Technologies Used:

*Maya for 3D modeling (free for students)
*Zbrush for Character Modeling
*Blender, FREE 3D modeling software, great for learning

UV Unwrapping

UV unwrapping is the process of taking a 3D object and making it 2D in order to paint on it. This can never be a perfect process but we can use software to help us along. With any 3D modeling software you use, it should come with tools used to unzip and flatten the model to prepare for texturing. However, specialized tools can help tremendously and in my opinion, should be in every 3D modeler's toolkit. One such tool is Headus.

Texturing

Texturing is the act of coloring and painting those 3D objects that were modeled. Once an object or character has been made, it needs to be unwrapped properly and then painted. This stage forms a lot of the personality of the artstyle in a game so it's important to have a good direction for all Texture Artists to follow. You can either paint this 2D canvas in Photoshop or Gimp by hand, or you can use a specialized program like Substance Painter, which I emphatically recommend.

Technologies Used:

Substance Painter and Designer
Photoshop
GIMP

Animation

I'm going to break this into two sections because this is one area 2D and 3D diverge tremendously. They both fall under the same base animation concepts such as keyframing and timing and as such I think any Animator should have this book to constantly reference and learn from. It should be noted that any sort of animation requires an insane amount of practice and time.

2D

2D animation can be either hand drawn, or digitally drawn allowing for the personal flavor of the artist to really shine through. Whereas 3D likely has many hands on the same model before hitting the stage, and in my opinion can make the animation feel less personal. 2D game design utilizes sprite sheets that have many different frames placed on one sheet and then that is sliced up (by the engine) and played like a flipbook at a certain speed to make the animations.

Tools used:

Photoshop
GIMP
Illustrator

3D

3D animation can be incredibly lifelike and immersive for players. The hard part about 3D animation for games vs for movies is that the animation has to look good from every angle. Models have a skeleton placed within and mapped to all parts of the model with fleshed out controls in order for the animators to actually ...y'know, animate. The process of creating those controls is known as Rigging which was my specialty.

Tools Used:

*Maya
*Blender, FREE and great for learning

Audio

Voice actors, musicians and sound effect artists can bring games to life like no other thing laid out in this article. Scores from games like Halo carry a legacy and sound effects add that extra "oomph!" to player interactions. These sounds are placed within the engine and tied to objects, interactions or menu's by the designers or programmers.

Tools Used:

Adobe Audition

Playtesting

While assets are being made it is crucial to keep a finger on the pulse of your game. You need to make sure that you schedule time to play your game and see if it's any fun. It's important to put your game in the hands of many different people and get their honest feedback. Maybe your menus need tweaking, maybe your players absolutely HATE that they get one-shot constantly. So it should be at the absolute top of your list to get the game into the hands of people that will give you honest feedback so you can improve.

There are so many positions to fill and roles you can take on just get out there and start making something!

As a side note: I'll try to keep this list up to date as much as I can.

Extra reading:

State of the Game Industry 2019

How Your CPU Can Nibble on a Bit

Scott Slatton — Mon, 25 Mar 2019 21:15:08 +0000

Anatomy of the CPU

The CPU (Central Processing Unit) is the brain of your entire computer. It crunches through computations and spits out new information that we can use. I know that sounds very abstract and kind of a “duh” statement so I’d like to go ahead and dig into this a little bit. Let’s start out with the hardware and work our way in. When you type your source code in Ruby, Javascript or C# that high level, human readable code gets broken down and then executed by the CPU lets see what happens when you hit the “Run” button or when your browser stumbles upon some Javascript.

“The simplest computer is just a light switch.” -- My first boss at a PC repair shop.

It’s amazing how oversimplified this statement seems, which it totally is, but it’s also completely true. A CPU just computes ones and zeros, on or off. But we need our computers to crunch hundreds of thousands or millions of calculations per second. How is this achieved? CPU’s are basically a huge network of transistors, turning on or off. The rate at which they can flip these switches is known as “Clock speed”, measured in Hertz.

CPU’s used to be made with vacuum tubes, but these were large, expensive and prone to failure. Vacuum tubes also used quite a large amount of energy and were readily replaced by transistors when they became available in the mid-1960’s.

Just speaking from a hardware standpoint, you only need the CPU, power supply, RAM, and a motherboard in order to run your computer. RAM (Read Access Memory) is volatile meaning that it is wiped from existence each time electricity stops running through it. There are several different types of RAM, the one that you probably think of when that word is said are the sticks attached to the main motherboard. This is only one type however and their main utility is that they are large, fast, and physically placed close by to the CPU. There are even faster and closer caches of RAM placed on CPU die though. These caches just store the information that the CPU is most likely to need next, like the variables you just declared and assigned. If you want any of this data to be stored after the power is turned off this is where a hard drive would come into play.

To sum up: Once your computer hits some code it comes in as a stream of instructions to the CPU which then utilizes its RAM to store bits for later use.

CPU's can vary in size because the requirements of the CPU may be different. In the picture above the CPU on the right was made to support larger amounts of memory and stores more physical cores on the die itself.

Multi-threading vs Single Threading

Before we get into single threading and multi-threading, let's talk about what a thread is in regards to cpu functionality.

“In computer science, a thread of execution is the smallest sequence of programmed instructions that can be managed independently by a scheduler, which is typically a part of the operating system.” -- Wikipedia

So a single thread can crunch through a stream of data sent through a program while having the order of what is actually being calculated managed beforehand and re-assembled after the calculation has completed. In real world terms, this means that Javascript (an interpreted language) is broken down by its JIT (Just in Time) compiler from top to bottom and fed into the CPU. This is why ordering your code is so important in Javascript and why hoisting is used.

Now knowing what a single thread is, you probably now understand what multi-threading is. This is where multiple CPUs (also called “cores”) are placed adjacently on the same die and can crunch calculations from multiple sources at the same time.

Concurrency & Parallelism

From here I’d like to talk about the above stated terms because once we get into multi-threading, we’re talking about completing multiple tasks at the same time.

You can think of parallelism as a cook in a restaurant making dish after dish after dish all day. Maybe they have to switch between cutting celery while the chicken is cooking but they’ll return to take the chicken out of the oven before it burns.

A popular form of parallelism comes from Intel. Their Hyperthreading technology splits a physical CPU core into two logical cores to optimize wait times between tasks.

Concurrency on the other hand is like having multiple chefs in the kitchen cooking completely different meals entirely independent from one another.

Click Here for a much more in-depth article on this topic.

Applying Game Theory to your App

Scott Slatton — Mon, 11 Mar 2019 15:59:05 +0000

Game theory is all about creating rules, incentives and payoffs for your users. Players need to know what the goal of the overall game is, and the actions they can take to further themselves toward that goal. Technically speaking, Game theory is a branch of applied mathematics that sort of merges mathematics and behavioral economics in order to analyze and develop strategies for competitive situations and systems that takes player’s choice into account. A player in the context of game theory can be any active participant in a system be it a single user, a group of people or even a country. As developers, we can take advantage of this school of thought to enrich our applications to include more engaging user interactivity.

Game theory was originally developed by the mathematician John von Neumann and Oskar Morgenstern, a Princeton economist, to solve problems found in economics. In their book “The Theory of Games and Economic Behavior”, published in 1944 Neumann and Morgenstern asserted that the contemporary mathematics developed for the physical sciences,, was a poor model for economics. They observed that economics is much like a game, wherein players anticipate each other’s moves, and therefore requires a new kind of mathematics, which they called game theory. It is important to note that there is no single overall “capital G” Game theory due to the large breadth of situations and systems that fall into its umbrella. While game theory is used to identify systems already in place, we can use it to implement systems of our own design.

The features of a game system that I am going to focus on are:

-Players
-Rules
-Skill and Luck
-Incentive
-Payoff

Players

As I stated before, players are any participants in the game system, but the number of players can be important especially if the action of a player influences the behavior of another. For example, this can be seen in social media with hashtags that get popular or trends, content creators see what is getting shared around and change their content to reflect what their audience wants to see.

Rules
I’ll be talking game theory in relation to an overall goal as it relates to a software application, for a game that goal would be player enjoyment. However, for a social media app, a game system could be applied to how your user’s content gets shared around. In software, the possibilities for what players can do and the actions they take seem endless… and that’s because as developers, we know that we can do pretty much anything we want. So setting up loose rules at the beginning of the design process is important, things like number of players, the incentives and goal of the game itself. The key word here is “loose” because we don’t want to get into the mindset that everything is locked down, set in stone and unchanging. The reason is that during the process of implementing your system, it’s nearly inevitable that things will need to be altered or changed in service to the overall goal.

Skill and Luck

This is one of my favorite sections of implementing a system because this is where the interactivity gets tweaked in something like a video game. This concept does have its place outside of recreational games. Consider Vine: a platform spawned from Twitter where you tried to make a 7 second clip go viral. It has a clearly defined goal but in order to make your video go viral it took talent (editing, writing and timing) and also luck (posting at a time of day so that most eyes would see it). Increasing the difficulty of performing an action or affecting another player can result in players feeling engaged but also frustrated. This frustration can be a very powerful emotion that turns people off from using your service, so you can use luck as a yin to skills yang. By providing luck you are giving a player the ability to soften the blow to their ego by providing an excuse why they lost a zero-sum game or why their Vine didn’t end up on national news (shouldn’t have posted it at midnight).

Incentive and Payoff

Incentive and payoff answer the "Why should I?" questions your users may ask. To incentivize is to entice the player into performing an action, be it liking a post, commenting or something as simple as making the player keep playing the game. Payoff is the feedback for those actions, this can be positive or negative. Payoff determines whether or not a player will perform the action again.

Zero Sum and Non Zero Sum Games

The above diagram is a demonstration of the Prisoner’s dilemma in which each individual prisoner benefits if they rat the other prisoner out. This benefit is only reaped though if the opposing prisoner stays silent. However it is overall more beneficial if the prisoner’s work together, stay silent and take the much lower sentence. This is an example of a non-zero game, because the outcome, of either twenty years, five years, or one, is always greater (or less) than zero.

Zero sum games have a fixed, limited set of resources and therefore in order to win you must take away resources from your opponent resulting in a net loss for them. An example of a zero sum game would be Poker. Adding the net losses and winnings together will yield the result 0, hence the name.

Perfect and Imperfection Information Games

Games of perfect information are games in which players know all of the rules, and any actions that can be played and the history of all those actions (even if they can’t remember). These are traditional board games like chess and checkers. These are also games that can be cracked by computers to determine the best overall decision by looking at probability of the opponent’s actions and the consequences of their own. Imperfect information games are the opposite, some information is kept secret from the players. Most games you’d play today fall into this category. Algorithms can take in variable values, do some magic and spit out a result that the player may have not intended.

Games can be made of nearly anything regardless of the intention of the original design of a program. Recently, I happened upon a Twitter thread of a speed runner who has been attempting to try and crash Windows 95 as fast as possible. This is another reason why it's important to consider the motivations your users may be harboring and actions you provide them.

Now that you know the individual parts of a game you can now analyze current systems in place and apply these concepts to your own development. Add an incentive and pay off for the user to interact with other players or your app itself. Make it rewarding to use your site every day, and if you find that when your testing, your program feels sterile, maybe take a look at what interactivity you can add.

Database Normalization for Object Oriented Programmers

Scott Slatton — Mon, 25 Feb 2019 22:24:57 +0000

Optimization is something I've always been in love with. This mostly takes the form of me trying to squeeze as much time for sleep as possible, so I utilize scheduling shortcuts so I can spend as much time as possible warm and snug in bed. This definitely leaks over into my interests because I genuinely enjoy doing things as fast and consistently as possible while maintaining quality. So today I'm going to venture into a topic that isn't exactly associated with words like "fun" or "interesting", but I've found that even being aware that normalization is a thing that exists has helped me in other aspects of object orientated programming. So what is normalization and how does it relate to OOP?

Normalization is a process in which we optimize our databases, making them more flexible, expandable and easier to use. It is an imperative competency for someone working directly with databases. This process can be applied at any time during development and works well to have in mind during the initial creation of your object models and can be reapplied as you tweak and discover new relationships for your objects. This may sound daunting but I'll hold your hand through this whole process so you can come back and reference this guide on your own projects.

A few definitions before we start:

Normalization

To achieve "normalization" or to consider our databases "normalized" we need to take our databases through a few steps and for each step we consider our databases as on a new level or "form". I'll take you through the first 3 forms because going any further than that you start floating off into the realm of mathematical possibility instead of real-world practicality. Once we've hit the 3rd form you can safely consider your database to be normalized. These steps will be shortened as 1NF, 2NF and 3NF respectively.

Primary Key

A Primary Key candidate requires two things:

Never allowed to be Null/Nil.
Must be a Unique Value.
May never change.

Luckily in our Object Oriented language our instance objects all have a unique key called it's Object ID. Our databases on the other hand like SQLite, automatically include a unique auto-incrementing row.

Foreign Key

Foreign keys are just primary keys from other tables. Generally a linking table will have it's own primary key and then two or more foreign keys. These connect two separate tables together.

Through the Forms

Taking your databases through the first three normalization steps will drastically improve the quality of the data that you are storing. Luckily utilizing object oriented language features such as classes make it extremely easy to have an efficient database without having to think about what's going on behind the veil. Before normalization starts you need to have a primary key, with an object oriented language this will be the Object ID itself (found with .self in Ruby), or when stored in the database will automatically be added as the "id" column that is usually auto-incremented.

As you may know, attributes on a class map to columns in a database quite neatly. Taking your data through the first normal form means that each column and each cell should contain one value only. This means that the instance object of the Toy class (lets call him "Woody") has a column in the database with the title "Name" with the value "Woody". But what happens if we want to store another Toy with the name "Buzz Lightyear"? In the table below I've done just that and for good measure lets also put in a third Toy with the name "Action Lightyear Aldrin".

The trouble starts when we start asking our databases questions like "Hey database, can you get me all of the Toys with the last name of 'Lightyear'?" Well, you don't have a column titled "Last Name" so you have to query the "Name" column with something like "Hey database, get me all the Toys that have the name 'Lightyear'." As I'm sure you would expect it will return both Buzz and Aldrin which isn't what you want. This may seem trivial for a Toybox, but if you're querying a database with hundreds of thousand or millions of rows, you can see how having data not broken down into smaller pieces can quickly become completely infeasible to manage and manipulate.

Alternatively, something to look out for is when values are all jammed into one cell. As shown below.

This spits in the face of 1st Normal Form and must be corrected, though, this is a situation unlikely to happen if you're using your classes correctly.

This is the first thing 1NF is about: Atomicity.

In object oriented languages, this problem is generally taken care of by erroring out when you try to put more than one value in a cell and suggesting you use an array.

Continuing on, lets fix this problem real quick and add a row splitting up the name into three parts and letting the additional names optionally be null/nil, like in the case of Woody.

We'll also add an accessory column because we want to keep track of each Toy's accessories that they are boxed with.
But not every toy only comes with one accessory so we need more columns to hold each item the toy comes with.

The problem with this strategy is that for each new instance of our Toy class (newly renamed from ToyBox), the object might have a different number of accessories. If you notice that you have column names that end in incrementing numbers, there is a great chance that you have a problem that can be solved by taking those columns out and making a new class that has a relationship with the toy and maybe storing the relationship in a linking table if necessary (like if you discover you actually have a many-to-many relationship).

Second Form

Second form normalization is one that as far as I can tell is taken care of quite well with OOP without any human intervention. It mostly has to deal with Composite Primary Keys, where two columns are used to uniquely identify a row in a table. I'm sure there are cases when this is good to keep in mind but I'm willing to admit that at this point I haven't run into a situation where this was necessary.

Basically 2NF states that any non-key field should be dependent on the entire primary key. This is situation usually presents itself on linking tables.

Third Form

Third normal form states:
Can you find the value of a field from any other non-key field?

Below you can see that you can always find out the total of a toy order if you know how the price of the toy and the amount sold.

Best practice would be to eliminate the "Total" row and use a method or a built in database feature to calculate that information.

Wrapping Up

As you may have noticed object oriented languages and modern databases keep these principals in mind from the get go but it can be tempting to try to make your own shortcuts. Try to avoid those traps and take the time to analyze what data you're storing and the relationships between that data.