Forem: nineismine

Demystifying Methods and Functions in C# - When should I use them?

nineismine — Tue, 18 Feb 2020 03:15:48 +0000

When shoul

When should I create a new method when programming in C# (or other languages)?

Often as a software engineer you will be faced with the question of… “When should I create a new method?”

The simple answer is: "When you encounter a verb."

What's that? A Verb? I hated English class!

Don't worry! I hated it English class too!

To break this down let's start with a definition of a verb.

VERB
a word used to describe an action, state, or occurrence, and forming the main part of the predicate of a sentence, such as hear, become, happen.

OK so what do verbs have to do with programming?

Let’s break that down a bit!

Let's say that we wanted to create a program with a player character, and of course when we have a player, we probably want to have that player do stuff right?
One of the things that we want to do might be to have the player move around. We might have a system where we trap the screen refresh or maybe we have a timer ticking.

Whatever the case might be we have created an update method that runs at some interval and named it Update().

In our program we are going to create a method called MoveCharacter(). We could just add the movement code to the Update() method but then later in our program, we might need to write the exact same code again (if we need to move again).

This is a somewhat simple example but this type of situation comes up a lot when you are programming.

Over my years of doing computer programming I have often asked myself if whatever I was working on should be contained in a more general method. (like Update)

This question gets easier when you start to think of the programming terms like sentences. When we start to think of examples of things we do as programmers in these kinds of terms it removes the guess work.

When it comes to deciding on when to create a new method you can can think of the methods as verbs. “Brad wants to run”, “Brad attacks”…. In both of these sentences, if we are writing code to make our player do some action, it makes sense to create a method for both verbs.

Let’s take this one step farther now.

Let’s say that we want to write this code to handle PlayerMovement or “Move” (Player) if we are keeping with the Verb reference.

Each time we get a frameUpdate, we want to evaluate if the user pressed a button to tell the computer to Move() (our verb!).
What might happen in the Move() method then?
Well as we discussed earlier, when we move, we need change our players X and Y position.

void MoveCharacter()
{


player.MovePostion(currentPostion +change)


}

If we look back at the psuedocode above, what do we see ?

We have a method that Moves the character and inside of it we have ANOTHER method call, which handles our MoveX and MoveY.

Why is there another method there? Because we encountered another verb. (MoveX and MoveY)

I can’t say that this is a hard and fast rule because when it comes to programming, there will always be exceptions to every rule. But if you can take that simple statement with you then you have a good baseline to answer the question.

“When should I create a new method?”

Hope that helps this next part make a little more sense for you!

If you like this content , or it helped you to develop your skills... head on over to my blog.. Follow me on social media.. there is plenty more where this came from!

Create your first game using Unity and C# – Part 2 Creating your first script to handle player movement.

nineismine — Tue, 18 Feb 2020 02:24:29 +0000

How to build a game in Unity and C# part 2 - Player Movement.

In the last tutorial we got our environment set up and worked through the process of adding a player character to our project. Now we are going to start doing some of the real work. Today we are going to learn how to build a game in Unity and C# .

In this lesson we will learn how to :

Add physics to our Player object
Add collision to the Player (so that he doesn't just run through walls)
Write the code that allows our player to move.
Test that our character can walk freely around our empty scene.

Lets add some physics!

In the last lesson we added a player object to our "Hierarchy" window. In this section we will add physics to our player by adding what's called "RigidBody" to our character.

Add a RigidBody component to the player object

Find the player in the Hierarchy and select it.

Next look to the Inspector widow, at the bottom you should see a button..

Press the "Add component" button.

Select the RigidBody2D item from the menu.

Rigidbodies enable your GameObjects to act under the control of physics. The Rigidbody can receive forces and torque to make your objects move in a realistic way. Any GameObject must contain a Rigidbody to be influenced by gravity, act under added forces via scripting, or interact with other objects.

Make sure the player is still selected in the hierarchy window and add another component

Press the Add Component button

Add a Box Collider 2D Component

(be sure that the component that you add is a Box Collider 2D not the other one)

Modify the collider to surround your players feet. This particular collision will be used to make sure that your character isn't able to walk through blocks or other terrain while moving around the map.

With the player selected in the Hierarchy

Select the Box Collider from the Inspector

Then hit the Edit Collider button.

A green box that surrounds your character will appear it has little squares on it which you can drag to resize your collision.

You can make this as big or as small as you want , but for right now you should make it look like mine. (Below)

Make a script for the player movement.

Add the script

Find the project Window

Select the Scripts Folder

Right click on it

Select Create from the menu and C# Script from the menu that opens

Be sure to name the Script at this time

Name it PlayerMovement.cs

Here is what it looks like initially.

Double click on the script in the project window

If you followed the instructions in the last Tutorial you will have set the External Editor to Visual Studio and when you double click the new script Visual Studio will open.

You should now be looking at the project in Visual studio.

If it didn't open please refer to my last article and find the section on opening your External Editor.

Modify the Script in Visual Studio

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerMovement : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        
    }

    // Update is called once per frame
    void Update()
    {
        
    }
}

First change the "class name" to match the name in the unity editor (this is important the script name MUST match the class name. More on this below) Change this line:

public class NewBehaviourScript : MonoBehaviour

to:

public class playerMovement: MonoBehaviour

In Unity when you create a script the class name must match the script name EXACTLY. If you do not do this correctly then you will get an error which says :

"Cant Add Script - "Can't add script behaviour VisualContainerAsset",
Can't Add Script "The script needs to derive from MonoBehaviour!"

**You won't see this error though until you attempt to add the script to the player model later in this tutorial.**

Let's add our script to our player!

Open Unity back up (make sure you save all the work you did in Visual Studio) Find the Hierarchy window Select your player from the Hierarchy Now direct your attention to the Project view Find your scripts folder Select it and then select your PlayerMovement script Drag the newly created script to the Inspector window. If you did it correctly you will now see a new component in the inspector window named Player Movement (Script)

Coding the Player Movement

Now that we have a script we need to do a few things to handle the movement.

Create variables.
Set their initial values
Modify them as required for the program.
Attach the script to an object in the editor.

Let's talk about variables! - (explanation)

If you are working on this tutorial without a solid programming background. Understanding the code in a necessary part of learning to build a game in Unity and C#. You might find the use of public and private in front of the variables we are instantiating here a little confusing. Everything in this section is general knowledge about variables. If you want to just get the code thats going in the game... skip to the next section. Without going into to much detail, let's just review a couple things about variables and how they are used in C#.

Variables must be "declared".
- When you declare a variable you tell the compiler what the access level is "Public" Or "Private". Knowing how and when to use these is a whole topic in itself.
  - When it comes to Unity you can get by knowing only this much (below) about "Public / Private" Public variables will be available to modify in the Unity inspector.. private will not.
- In general you will declare the TYPE of a variable when you instantiate it. This is what determines what kinds of values can be stored in the variable.
  - Often we think of a variable as single type like public int myNumber = 10; but you can also declare a variable to hold an entire object. An object could be much more complex than a standard variable. It could be a whole range of values. Like for instance the Player that we are creating... at some point we will probably want to give this object some properties that separate him from other objects. The properties are one of the reasons that we use classes in C#. A claa is simply an object and the object acts like a container for these properties.
  - Our player might have
    - a name public string name = "chad";
    - hit points public int hitPoints = 10000000000000000;
    - lives public int remLives = 9;
  - All of the values could be contained in a "class" class Player()
```
class Player()
{

    public string name = "chad";
    public int hitPoints = 100000000000;
    public int remLives = 9;
  

}
```
  - Now that we have a class we can create a variable to hold the entire object. This is not a totally correct example but as long as you understand that a variable declaration can look a couple different ways you should be good to go for the rest of this .
```
public Player myPlayer = new Player();

myPlayer.name = "Chad"; 
myPlayer.hitPoints = 99999999999999999999;
myPlayer.remLives = 99999999999999999;
```
- You are able to give the variable a value when you declare it, but you do not have to.
- Variables must be assigned in order to use them.

Ok so back to the Public private thing....

More specifically what that means is , once you add a script to an object in Unity. You can add variables to that script. In creating these variables you make a choice to either declare them public or private. A public variable will have a graphical representation in the editor that you can change via the Unity inspector interface. (see below)

As you can see above. The speed variable can be increased or reduced in the GUI.

When you make a change to a public variable in the GUI, the game will apply this value at runtime every time you start the game. If you make changes to this value in the code though, that change happens after the intial start and will now be the new value. (until you restart the game)

Let's assign our variables

OK so now that we have reviewed how to use variables let's get back to building this movement script.

Assign the three variables that we are going to need.

We need a value to hold our:

Speed
A reference to the RigidBody that we added earlier
A value to tell Unity the change in position that we are expecting.

public class PlayerMovement : MonoBehaviour

{

    public float speed;

    private Rigidbody2D myRigidbody; //rigidBody gives the player physics 

    private Vector3 change; // the value we will use to tell unity where we moved 

 

    // Start is called before the first frame update

    void Start()

    {
        

    }

**note RigidBody2D is a class and has several values attached to it. **

Get a reference to the Rigidbody component that we set up earlier.

Now that we have the Rigidbody reference we need to populate it. We do this by adding a statement to the void Start() method. Since Start() is called only once and at the beginning of an objects existence it only makes sense to do our initial setup for things in this method. We can do this by using the built in Unity function named GetComponent<Rigidbody2D>(); What this is going to do is look for the component that we named between the brackets, is it exists in the object to which we attach this script. (our player) When we attach this script to the Player object. Unity knows that it should look at the collection of components (attached to player) and find the one that matches what is between the < >. In other words we are telling Unity to look at the Player, and store a reference to the component named RigidBody2D in the value myRigidbody.

Whats is happening with this change variable? - (explanation)

**In this section all of the code is for explanation purposes. You do not need to use any of this code in your script.&& Next we assign our change variable. Because this is something that will be constantly changing we choose to do this in the Update() method. (In this case we are working on player movement so logically you would have the game checking for movement each frame. In other words, we are going to check for key input ,which tells the game which direction we are heading. When we get a command we will run a routine to animate the character (animation will be covered in the next article), and move them in the desired direction. This is stored in the change variable ) If that wasn't clear.... in the update method we will:

set change to zero once per frame
check for movement
normalize the input (im not going into this too much just trust that we did it)
Have the character move to the new position

The change variable is just a set of values that represent changes to the players coordinates. Something important to note here is that Vector2 is class. It contains a set of coordinates X and Y. Unity will modify these coordinates to apply a simple movement algorithm. You can think of this like an x and y on a graph. Moving in any direction one point results in a change in the x and y which is either positive or negative. As we mentioned Vectors are classes and one Vector has multiple values assigned to it . These coordinates can be changed as you see below.

Vector2 change;

change.X = new value

change.Y = new value

You do not have to change both values but each change represents movement on the graph. In our code (which is below in full) we are going to use some Unity libraries to get input in the form of keys pressed from the player. We will then covert that to our change variable. Don't think about this too hard right now, it just works. But later were going to use that movement along with another Unity function called MovePosition(). MovePostion() will take that change value that we stored and a couple other values to figure out where the player is moving and how fast. (WASD or the arrow keys are tracked within unity and are converted to movement (change data))

Make the changes to the change variable

(This section might be hard to understand because there is a lot going on here and Unity is handling a lot of things for us with built in functions. I will do my best to explain what is happening here, if you don't fully understand it you can always come back later and play around with it until you do.) Now were going to tell Unity to make changes when the player moves. We're also going to add a Debug statement to the log so we can view the changes that occur due to movement in the Unity Console. Here is what our code looks like at this point.

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

 

public class PlayerMovement: MonoBehaviour

{

    public float speed;

    private Rigidbody myRigidbody; //rigidBody gives the player physics 

    private Vector2 change; // the value we will use to tell unity where we moved 

    
    // Start is called before the first frame update

    void Start()

    {

        myRigidbody = GetComponent<Rigidbody>(); //add the rigidbody component to this script for use later. 

    }

 

    // Update is called once per frame

    void Update()

    {

        //Zero out the change

        change = Vector2.zero;
        

        //Get the current x and y as points on a graph

        change.x = Input.GetAxisRaw("Horizontal");

        change.y = Input.GetAxisRaw("Vertical");

        //print the change to the console 

        Debug.Log(change);
 

    }

}

Input the code and then save your work in Visual Studio.

Go back to the Unity Editor

Select your player by either clicking on the sprite or selecting the node named "Player" in the Hierarchy tab of Unity.

Let's talk about the code that makes the player move..(explanation of functions/ methods)

OK guys we are almost done with this lesson but before we finish up let's talk about what we are about to do and then let's get it done and tested!

In the next section we are going to write our first "method". Methods , functions, sub routines.. these are all terms that get thrown around in programming but they are all basically the same thing.
A method is a bit of code that you can call from somewhere in your program. When it is called, the code inside the method will be processed. When the code inside the method is finished executing, the program will resume execution where the method was called. The next line of code after the method was called will then execute.

When should I create a new method?

Often as a software engineer you will be faced with the question of... "When should I create a new method?"

The simple answer is: When you encounter a verb.

Let's break that down a bit!
In our program we are going to create a method called MoveCharacter(). We could just add the movement code to the Update() method but then later in our program we might need to write the exact same code again (if we need to move again).

When it comes to deciding on when to create a new method you can can think of them as verbs. "Brad wants to run", "Brad attacks".... In both of these sentences, if we are writing code to make our player do some action it makes sense to create a method for both verbs.

Let's take this one step farther now.

Let's say that we want to write this code to handle PlayerMovement or "Move" (Player) if we are keeping with the Verb reference.

void MoveCharacter()
{

     player.MovePostion(currentPostion +change) 

}

So when we Move(), we are actually telling the computer to move our player, some amount of degrees X, and move our player some amount of degrees Y. (There are those dang verbs again!) We can boil that down to MoveX and MoveY. (TWO Verbs!) If we look back at the psuedocode above, what do we see ? We have a method that Moves the character a,nd inside of it we have ANOTHER method call, which handles our MoveX and MoveY. Why is there another method there? Because we encountered another verb. (MoveX and MoveY) I can't say that this is a hard and fast rule because when it comes to programming, there will always be exceptions to every rule. But if you can take that simple statement with you then you have a good baseline to answer the question. "When should I create a new method?" Hope that helps this next part make a little more sense for you!

Writing the movement code.

OK so here it is.. all of the code we need for (now anyway) our player movement.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerMovement : MonoBehaviour
{
    public float speed;
    private Rigidbody2D myRigidbody; //rigidBody gives the player physics 
    private Vector3 change; // the value we will use to tell unity where we moved 


    // Start is called before the first frame update
    void Start()
    {
        myRigidbody = GetComponent<Rigidbody2D>(); //add the rigidbody component to this script for use later. 
    }

    // Update is called once per frame
    void Update()
    {
       
        //Zero out the change
        change = Vector3.zero;
         //Get the current x and y as points on a graph
        change.x = Input.GetAxisRaw("Horizontal");
        change.y = Input.GetAxisRaw("Vertical");
        //print the change to the console 
        Debug.Log(change);
        if (change != Vector3.zero)
        {
            MoveCharacter();
        }

    }
    void MoveCharacter()
    {
        //transform.position is the player position
        // add the "change" (x and y modifications) 
        //Time.Delta is the amount of time that has passed since the previous frame 
        //So what we are saying here is: Move my character TO my current poistion + the changes I asked to make (direction) * my current speed * the amount of time that has passed.
        //this last piece about the time change is to make it look more smooth when your character moves. 
        myRigidbody.MovePosition(transform.position + change * speed * Time.deltaTime);
    }

}

Breaking the code down

Each frame (the update() method)

void Update()
    {
       
        //Zero out the change
        change = Vector3.zero;
         //Get the current x and y as points on a graph
        change.x = Input.GetAxisRaw("Horizontal");
        change.y = Input.GetAxisRaw("Vertical");
        //print the change to the console 
        Debug.Log(change);
        if (change != Vector3.zero)
        {
            MoveCharacter();
        }

Let's get our change x and change y and store it as our change variable.

change = Vector3.zero;
         //Get the current x and y as points on a graph
        change.x = Input.GetAxisRaw("Horizontal");
        change.y = Input.GetAxisRaw("Vertical");

log to the console the change values

Debug.Log(change);

and IF our change value is not 0 (you can read up on if statements an expressions here )

if (change != Vector3.zero)
       {
           MoveCharacter();
       }

THEN MoveCharacter() Within the Move character we use a unity function to Move an object to the given position. There is some other math happening here but I'm not going to go into that today.

void MoveCharacter()
  {
      //transform.position is the player position
      // add the "change" (x and y modifications) 
      //Time.Delta is the amount of time that has passed since the previous frame 
      //So what we are saying here is: Move my character TO my current poistion + the changes I asked to make (direction) * my current speed * the amount of time that has passed.
      //this last piece about the time change is to make it look more smooth when your character moves. 
      myRigidbody.MovePosition(transform.position + change * speed * Time.deltaTime);
  }

Finally! We are done and we can test.

Go back to the unity editor.

Hit play!

Your scene should start and now you should be able to see the first fruits of your labor.

Try using the arrows keys or the WASD keys to move around. Your player should move around the screen!

One last thing for fun!

OK stop your game by pressing the Play button again.

Now go to your Hierarchy view

Select your player from the hierarchy window. (Or click on him in the scene)

Look over to the inspector and find the Player Movement (Script) component.

As I mentioned earlier , because we made the speed variable public we can modify it in this view.

Just for fun change it to 44. Hit play again and now try to move.

If everything is working properly then you should run "a bit" faster than you did earlier.

I hope you had fun learning how to build a game in Unity and C#

If you like this series and want to see more head on over to my blog and sign up for my mailing list of leave me a comment.

Create your first game using Unity and C# - Part 1 Getting your environment set up and importing some art.

nineismine — Mon, 17 Feb 2020 01:59:21 +0000

Creating your first game in Unity and C#

This series of articles will guide you through the steps to create your first game using the Unity engine and C#. Throughout the course of this article we will be focusing mainly on the Unity engine. In order to get this thing to work though, we are going to need to write a good deal of C# code. I am approaching this article with the idea that users will have basic programming knowledge but are new to the Unity platform.

Because learning Unity is such a big task, we will not be covering the basic parts of computer programming in this article. I will do my best to provide links to those concepts at a later date! For this tutorial we are going to work with a 2D project to make the early steps of learning the engine a little less complicated.

By the end of this module you will have learned about:

How to create a 2D project
The main screens in the Unity editor that you will interface with.
How to add art / graphics to your game.
How to parse a sprite <something>
How to add it to an object that represents a player character in your game.
how to apply physics to the player object.
how to add collision the player object.

Get the tools you need and install them

Here are links to all of the software you will need to create this project. I will not be detailing the install process but it is very straight forward.

Download Unity (main download page )

Direct link to the free Unity Download (if you just want to skip right to the free one)

Download Visual Studio 2019

Download some art to use in your project.

(Here is a direct link to the art that I am using)

Install Unity and Visual studio and unzip / extract the graphics folder that you have chosen for art.

When installing Visual Studio be sure that you install the Unity tools that are part of the installation process.

( if you don't do this then later Visual studio intellisense won't know anything about the Unity package. )

Create a new project

Open Unity and create a new 2D project. (File > new project > )

Select the 2D template.

Set the external editor in Unity to Visual Studio. (Edit > Preferences > External Tools > and then set this to Visual Studio 2019 )

Getting to know the Unity Interface

Now that you have a new project created, and are looking at the unity interface I bet you are thinking... "WOW that's a lot of stuff to look at!"

Don't worry that is a perfectly normal reaction! Let's walk through the interface and talk about each piece. There is a ton of information to learn here, so we will just focus on the stuff we need for now.

The Scene The scene window is a graphical representation of the game and all of the objects that you have set up to interact with. You can think of this kind of like the stage that actors use when performing a play. Everything you create that you want to interact with in your game, will have some sort of representation in the scene. You will eventually be placing everything in this area. Every object that is part of the game from your light source , to audio, all the way to blocks that represent the boundaries and terrain of your game will be represented graphically in the scene.

Hierarchy
The easiest way to understand the hierarchy is to think of it as a list of all of the things in your scene. While you can point and click to grab and examine items in your scene. At some point in a large game, you will have tons of objects in the scene and having a clean detailed interface to select from will invaluable. This is where the hierarchy comes in.
3. Project
The Project window displays all of the files related to your Project. It is the main way you can navigate and find Assets and other Project files in your application. This window is similar to the solution explorer in Visual Studio. I'm making this up off the cuff but essentially you have assets which are things like images, code files, config files and the folders that contain them. Pretty much everything that you build inside of the Unity Environment can be called an Object , and objects are contained in assets.
Inspector
The inspector allows you to examine and modify individual objects in Unity. It is similar to the properties window in Visual Studio. if we keep to the same logic above , when we modify an object in Unity its really just doing the work of finding the right asset and modifying it for you.
Console
The Console is where you get information about what is happening in your program. You can use a statement like "Debug.Log("hello world"); to write information directly to the console.

Create folders to store your work
Now that you know a little about the Unity interface and have created a new 2D project. It' time to do a few things that will help us keep the project organized and orderly.

In this step we will create a series of folders that we will use to store assets for the game.

Go to your project window right click on assets > create folder

Create a new folder for:

Art
Animations
Scenes
Scripts
TilesMaps

This is what your project (above) should look like now.

Import a sprite set for your character

The first thing we need to do here is find the art set that we downloaded on your computer.

Click on the "Art" folder that we created in the assets window and drag and drop the gfx folder from the art files into that the art folder.

This will add all of the art to your project.

Now that we have the art, we are going to tell the editor about our player character.

In the project window:

Open "Art" and then open the gfx2 folder.

In the gfx2 folder you will find several image files.

For the most part we will only need to concern ourselves with the one named character. However we do need to make an adjustment to all of the files for this project first.

Select All of the images and then in the "Inspector window"

Find the setting for "Pixels Per Unit" and set it to 16

Then hit the apply button.

(note that I have some files that aren't images if you have any of these and you select all of the files you will not get the right view in the inspector. it's no big deal you can just select each file one at a time and make this change to each of them.. it will only give you this option for pictures)

Now choose your character image.

(This is actually a set of sprites that Unity can interpret as all of the basic data that we need for animation. I'm not going into detail as to how all of this works at the moment, just follow the steps. )

With the character image selected look to your inspector window and :

Change the Sprite Mode to multiple

Press the "Sprite Editor" button.

This will open up our sprite editor. Here you will see all of the various facings and animations for the character. Above the pictures you will see that there are a few menus.

Select the one labeled "slice"

Set the Pixel size to x = 16 and Y = 32

Now with your character image selected in the project

Look back to the inspector > Change the "Filter Mode" to point (no filter)

Change the compression to "High Quality"

Hit Apply

Grab your character from the assets window and drag it into the scene.

Then in the hierarchy rename it to "Player"

Ok. So we learned how to create a new project , set it up , get some free art, import a sprite sheet, set up our environment to use Visual Studio, create a "Object" for use in our game and finally put it on the stage (the scene) . I think that is enough for now! If you are still with me follow me on to my next article in this series:
Handling Player movement. (it will be up shortly)

If any of you have made it this far ... do me a favor and leave a comment or sign up to my mailing list so that I can gauge the interest in this type of content.

What I learned in 10 weeks of trying to teach myself how to touch type.

nineismine — Mon, 17 Feb 2020 01:28:56 +0000

10 weeks of trying to learn how to type.

Part 1

Hello all!

This is a multi-part series that will attempt to detail the things I learned trying to teach myself to type. I will detail the process of learning, the tools that I used and how they stack up. Today we will focus on a little explanation of the challenges of not knowing how to type. As well as my thoughts on the first typing teacher program that I used Typing.com. Over the next few weeks I will detail my experiences and the pros and cons of the tools that I have tried.

As of today I have used

Typing..com
Ratatype
TypingClub (if you don't want to wait for my full reviews just go get started on this one. )
Typing of the dead.I hope this proves useful for anyone stumbling across my site!

The unseen challenges of not knowing how to touch type.

Unlike most of the people reading this blog I didn't grow up around computers. As a matter of fact I bought and assembled my first computer at the age of 24. I quickly started to discover that I had a knack for all things computer (except maybe touch typing) . That unconventional history can come with some positives but no matter how you look at it there are some inherent downsides to starting so late.

For one when you start in your 20's you simply aren't afforded that responsibility free play / learning time that many of my peers have described to me. Another thing (and more to the point of this article) when you start to late that means you are always playing catch up! For me, the biggest, most glaring hole, in my ability to get things done on the computer was learning how to properly type. As I moved into development that one became more and more of a liability.

When you don't know how to touch type, you spend a good deal of time avoiding typing things. The sheer amount of time you spend correcting errors, backspacing, using the mouse, or embarrassingly assuring people you communicate with on Instant messenger that you REALLY do know how to spell you just can't type... It is tedious and a little humiliating.

Imagine trying to work in a bash shell / command line and you have to double check all of those patchwork , abbreviations for words that serve as your command language! Imagine not being able to look at the screen when you type... this means that most of your errors escape you, it makes proofreading your own word a chore and it makes having to transpose ANY sort of data from one source to another feel impossible!

When you don't know how to properly type you create work around for everything. You try to copy and paste everything, you hit enter on half sentences in your instant messenger (so that you have less words to work with when it comes to corrections), you avoid doing any sort of transposition, you live in fear of password policies that only allow X retries!

This year I decided that I have suffered enough, and have committed to learning how to properly type. I started with a simple goal of spending the first 15 minutes of every day working on a typing trainer. Now while I have missed that goal more times than I care to mention, I am slowly getting better by not quitting! It is empowering to, for the first time in my life be good enough at typing to be able to look at the screen, and see the words coming out as I type. I'm finally not staring at my hands and this helping me see each mistake as I make it.

So that all being said....how did it go?

Week one: Typing.com

I settled on typing.com as my first application to try to learn.

The pros:

Typing.com has a clean interface with lessons logically sorted into skill levels.

The lessons are skill based with standard beginner , intermediate, advanced lessons plans. Typing.com extends the basic lessons by having sections of the program devoted to real world categories of words. They offer lessons which are labeled Digital Literacy. These lessons are focused on Tech Readiness, Career Prep, and Coding essentials.

In addition to the ones listed above they have a practice section. This is a dedicated section which lets you practice some kinda off the wall drills. They have a whole section devoted to "Common Medical Terms" which I guess if you are into medical billing would be pretty useful. Some of the other lessons in this section are "Jokes and Laughs" , "Interesting Facts" and "Alpha numeric data entry". Some of the lessons seem like they would be very useful but I sure gotta wonder why they decided to create 17 lessons for Medical Terms. (Is there really that much demand?)

Finally they have a limited reporting section which will show you your problem keys. And you can do lessons based on the keys that they have detected you are having issues with. I only did the beginner level course and the majority of the intermediate course before I moved on though. I do plan to come back and do some more of these courses (and update this article when I do) though.

They show you your hands and which finger you should be using for each key in real-time.

The cons:

The beginner lessons focus too much on repeating key patterns that you would never type in real life.

Missed opportunities to teach you while having you practice sentences that explain how to use the app / teach you about typing.

Very limited reporting options.

Doesn't force you to learn keys / words by making you correct mistakes.

My feelings about Typing.com in detail

Typing .com at first seemed like a great teacher for me. It has a pretty nice user interface and that shows you your hands. It also gives you visual input as to what fingers are used for each key.

They have lessons broken up into exercises with 11 exercises per lesson. You can view how you did on each and how many "Stars" you got which can help you target lessons that you need to repeat.

Typing.com is pretty great at some things. But to me it was lacking in too many others.

Within no time I had progressed past the beginner lessons and was on to intermediate. The problems started , when I tried to use my new typing paradigm in the real world. For me, progress through lessons occurred a little too quickly. (maybe this was worse for me since I started with such bad habits) It became obvious I was moving too quickly through this program when I realized that I didn't (and over a month later still dont) know all of the home row keys.

As a matter of fact, on the day that I realized how far away I was from making progress that could carry over into my day to day duties, I really only KNEW a few of the 8 home row keys. Typing.com uses a method that you see in many typing teacher programs, where you are given keys to practice, and then you are drilled on those keys. This has you using those same keys over and over. The problem for me on this is that it is easy to alternate over a few keys like this "ddfd ffdf ddkk kjjk", but then totally forget which keys were when they turn around and have me do a similar drill with two different keys. The root of the problem is ...

Practicing real words is more effective than drilling keys...

Using the "2 key per finger" learning method. you only really have to remember 4 keys at a time. This first leg of the course really didn't teach me where these keys were on the keyboard and there is some actual science behind this.

You see, your brain doesn't naturally learn things this way. Practicing these types of drills didn't teach me where the "d" key was! This method doesn't focus on what your brain does do well. Your brain is better at remembering the specific movements and where your fingers have to move when you type out whole words. Those patterns become one of those automatic things that you do without thinking about it. You might eventually become such a good typist that you can remember where every key is. I'd bet you will never be as good at finding one key as you are at finding all of the keys that it takes to create words.

The problem with these 2 finger drills is two fold

(and I can't say any of these programs except typing of the dead is good at feeding you whole words and skipping the drills)

You aren't really learning much during these types of drills. (at least if my experience is common and the quoted article is correct).
Because you aren't learning words early on, you tend to revert back to bad habits and don't know why.

It seems to me that typing.com spends too much time on these types of exercises at the beginning. It took me so long to get to a point where they had me practicing typing real words, that I often felt frustrated. When I went back to doing my normal typing activities I would find myself reverting back to my old habits. Making sure that new students understand how their brain will start to commit these lessons should be a priority for Typing.com. If those early lessons are needed, then they should at least prepare their students for that feeling of frustration.

If you take anything from my diatribe today take this with you , you will not really start learning how to touch type until you start using the correct form to practice typing full words.

To accent that further, if you have attempted to learn to type in the past and reverted... do you remember one day feeling like you were getting it and then suddenly after changing the TYPE of thing you are working on not being able to type at all? This is what got me each time. All of a sudden being ineffective left me feeling like I wasn't progressing and in a sense I wasn't! If I had understood earlier that the trick to learning was really just commiting enough words to muscle memory so that I could stay somewhat efficient, I probably wouldn't have quit trying so many times.

Typing.com doesn't(really) make you learn from your mistakes.

Another thing I do not like about Typing.com is when you make a mistake, it just let's you move on to the next key. This is great for progress through their lessons, but terrible for learning where keys are in relation to one another. It gives you a false sense of security and a feeling that the practice isn't paying off. If you get 2 keys in a row wrong it WILL make you find correct key. But too often that troublesome key will be the only one I missed over and over and over.

I could tell pretty early on that this SEEMED like a liability. I always try to convince myself that I shouldn't presume to know more than the experts when trying something new and uncomfortable. (Isn't it human nature to look to escape things that are uncomfortable?)

Here is the worst part about this weakness.... I later discovered that when I make a mistake I can backspace. (In my mind if you type anything other than what the typing tutor is telling you , that is an error!) Why wasn't this spelled out better?

Some simple things would fix some of their issues

I think Typing.com could learn a couple things from TypingClub.com . Typing.com should probably try to spend more time teaching sentences and words. (like TypingClub does) They should also bake information about their service into the lessons.

TypingClub actually uses real sentences in their practice lessons that tell you things like "Did you know you can backspace to correct?" As a matter of fact I learned about how your brain learns words better than individual keys in a lesson from a lesson on TypingClub.com. This is a missed opportunity. It is likely one that has contributed to frustrations and maybe even caused people to give up.

Weak Reporting

Lastly, Typing.com seems to have very little useful reporting. As you grow and progress, detailed reporting can help you understand where you you need to focus your attention. This detail is an important part of being efficient in any learning program. This is literally all you get

I am working on completing my reviews of the other teaching tools that I mentioned above. Follow my blog to see these reviews and more on the overall experience of learning to type in the coming days.

12 tips, tricks, and Visual Studio 2019 shortcuts to increase efficiency - Part 1

nineismine — Fri, 07 Feb 2020 15:03:38 +0000

Visual Studio 2019 shortcuts

Quickly add public properties

You can add properties to your classes the quick way by typing prop and then tab tab

In this case were going to make a property and name it hitPoints

Quickly populate a full property with public and private members

you can do the exact same thing except type propfull to get the full property

public int MyProperty
{
    get { return myVar; }
    set { myVar = value; }
}

Quickly add a new class to your project

CTRL + Shift + A

Go to the definition of any object

This is a quick way to navigate to the definition that is under your cursor. For bonus points try ALT + F12 which brings up the "peek" dialog for that item. From within that dialog box you can also CTRL click other items to go straight to them.

F12

Move lines up and down in the editor

You can move lines just by pressing

Alt + up/down arrows.

You can also Shift-Select a bunch of lines and then Alt-Arrow them around as a group.

Quickly Launch a new project or search your solution , add a class and lots of other stuff.

Most of the things that you use in the menus, you know, when you open the menu Tools>Options and then just start until you find whatever you are looking for..

CTRL + Q

Quickly populate Console.WriteLine()

Type

CW TAB TAB

Quickly populate an IF statement, for loop , foreach loop , do , while, enums and others

This works for many of the common things we do in Visual Studio

Type any of the above keywords and TAB TAB

There are probably some others that I missed. (let me know in the comments!)

Open Quick actions and Refactoring (from here we can do a whole host of things)

CTRL + .

(control key + the period)

Quickly Navigate to... well anything

Another useful shortcut to remember is the NavigateTo command , this command lets you search for class names, files, members, types or even method names. This is super useful when working in a large project with many methods and classes

Press CTRL +, and start typing.

Once you learn this command you will not really even need the Solution Explorer. As long as you already know the name of the item you want to see.

(Control + comma)

Quickly search your solution explorer

While I don't use this one very much because of the last tip. You CAN use this tip to search explicitly in the solution explorer.

CTRL + ;

Quickly run an automated test

if you are using automated testing you can run a test from the keyboard by pressing

CTRL + R , T

I really hope these Visual Studio 2019 shortcuts help you as much as they have me. I only recently learned some of these and I sure wish I'd have know them earlier.

If you like this or other posts by me check out the rest of my blog site TheDevelopingDeveloper.net and subscribe for updates!

How to use Visual Studio 2019 to access and check in code to GitHub in 15 minutes

nineismine — Mon, 03 Feb 2020 14:46:19 +0000

Are you ready to learn how to check in code to GitHub in 15 minutes?

Over the last couple years in my organization we have been tasked with moving from TFS to Git. While Git is an awesome tool , it can be a little daunting if you have to pick it up and learn it on your own. There are plenty of great resources that explain WHAT git is.There are even plenty of articles that will go into detail about all of the things I am going to cover here! For that reason we are just going to focus on how to use it in, and specifically how to check in code to GitHub in 15 minutes!

One of the first things you will want to do is create a GitHub account if you do not already have one.

Adding your GitHub Account to Visual Studio.

One of the first things we need to know about when using Git is how to access it. While there is a stand alone Git client and it can come in handy for certain things. The built in client for accessing Git In Visual studio really simplifies the steps required to download and check in code.
To access Git related options in Visual Studio we need to look no farther than the "Team Explorer". Under the Team Explorer we have several options that we will be covering throughout this article.

In the menu select View > Team Explorer

Here you will be presented with the "Connect" dialog box. If you have created a GitHub Account for yourself now would be a good time to connect it.

Team Explorer > Manage Connections (it looks like a green plug) > Connect to Github

Fill in your account data

That's it! You are connected and can now sync your local projects to GitHub! Speaking of which....

Now that I am connected how do I get started with this GitHub thing? I'm Glad that you asked!

How to create a local repository

When it comes to GIT and creating and updating code in a repository we first need to understand the concept of the local and remote repository. The Local repository is the collection of files in their current state on your computer, git keeps track of the changes that occur on your local system, and then you give it the correct command it updates the local repository to a new version on your local system. After updating the local system however you still need to push your changes to the remote repository to complete the process of updating your remote repository.
In order to get started with GIT this means that we need to either create a local repository or import one to our machine so that Git knows what files it is keeping track of. To do this with Visual Studio it's actually a pretty simple task.

Open Team Explorer:
Navigate to the lower pane of Team Explorer to the section labeled "Local Git Repositories"
Click "new" and specify a location.
Hit the "Create" button.
This simply adds adds git tracking to your local repository.

How to import a remote repository.

Now that we know how to build a project and create a local repository , let's look at how to pull a remote repository so that we can modify it. For this example we will use Github as the example.

Navigate to Github
Find a repository that you want to clone. In this example we will use one of mine.
Hit the "Clone or Download" button.
Hit Open in Visual Studio.

Copy the URL that is in the Clone with HTTPS dialog
Go back to Visual Studio > Team Explorer > Connect > Clone >
Paste the URL into the Open from GitHub
Choose a Local Path
Hit Clone

Remote... Local? What's the difference?

I said I would avoid getting too deep into HOW Git works but I want to make sure I touch on this topic really quickly because it is important.

I essence when you add a project to a Git Repo we now have 3 stages that we are tracking in terms of your stored files..

1. 1. Your active workspace. This is where your current files live any time you make a change and save it, you make real changes to your active workspace but they do not automatically apply to your Local repository. (I think that this is one of the places people get confused with GIT)
  2. Your Local Repository. You can think of the magic behind git as a change tracker.. your local repository is a record of the last changes you made to any file that is being tracked by GIT as of your last commit.
  3. Your Remote repository. After making changes to your local repository you have to then commit them up to the remote repository. These are the three states of files being tracked by git. Understanding this process will make it much easier to understand what you are doing with GIT and WHY.

Ok! Now that I have a repository... What the heck do I do with it?

So keeping in mind the last section , we need to make changes to our code (our active workspace) > Apply them to local and then apply them to remote.

How to modify your active workspace

This is the easiest one, just make a change and save it like any other file. When you make an uncommitted change to the active workspace you will see a red checkbox next to the uncommitted file in the Visual Studio Solution Explorer.

How to commit your changes to the Local Repository.

Open Team Explorer > Click Changes > Enter a commit message to the Commit Dialog > Hit the "Commit All" button.

After the commit you get a message that shows you that you have made a Local Commit.

Now Sync by clicking the blue text that says Sync in the message. (you can see it in the screenshot above)

If we keep with the above explanation of the stages of git we are now in stage 2 , we have committed our changes locally.

On the Synchronization tab, under outgoing, we have an uncommitted change that is waiting to be pushed to remote.

Click push and it will push your changes to the master branch. That's it! you have learned how to check in code to GitHub in 15 minutes!

Let’s build a basic Blackjack App using C# and the Console Part 1 - The Design

nineismine — Sat, 01 Feb 2020 15:46:32 +0000

Designing a Blackjack App

Software design practices and good habits!

When you are just starting out as a new software engineer it can be tempting to skip over some of the things that not only make your job easier , but also tend to make the quality of your code a little higher. As a freshman engineer I would often find myself skipping right to coding without even planning what I was going to code. So in the spirit of teaching you the RIGHT way to do things let's talk about the bare minimum we need to do , and then let's get to coding a more complicated app. We're going to build a Blackjack app using the Console the quickest way that we can and then after we will talk a little bit about some better ways to build this app. Designing a Blackjack App will be a good way for us to talk a little bit about some of the different variable types, do some basic math functions, create and use methods, and even start to talk about classes. This will all be used to further our goal of learning about C# and software engineering.

Requirements

Normally in a professional environment you will start with requirements for your project. These requirements will typically be provided by a stakeholder. Since we don't have an external stakeholder lets take a second and write down some basic requirements for designing a BlackJack App and get a little closer to our goal of learning about C#.

The player will receive 2 cards
The dealer will receive 2 cards
Ask the player to hit or stay (and maybe split of double in a different version)
The players cards will be totaled and displayed
The cards will emulate a the typical cards you see in a card deck
Do not display Suits.
New cards will be from 2 to ACE
If the card is an ace the player or dealer will select 1 or 11 (out of scope for first build)
If any hand is over 21 the owner will bust and lose
Display all output to console
At the end of the game display an option to play another game or quit

Designing a Blackjack App- The Technical Design

Now that we are on to talking about design. It's good a good idea to mention there are many ways to complete a technical design. Some software development methods require very detailed technical designs others just focus on creating a rough idea of the application. In these cases you usually focus more on the acceptance criteria than writing out details about how we will get to the end result.

Because we want to get to the coding as soon as possible we will just do a basic design. There are a lot of ways to tackle this so one persons design for a game like this might vary greatly from another persons.

Things that we will need to manage the game

Create a class or some way to represent a card
- a card has a value
- a type (king , queen , numeric etc)
Create a collection for the players cards and the dealers
Create a method to calculate the numeric value of "hand"
Determine if the hand is over 21
Create a method to display the cards in a hand (possibly for the advanced version only)
Create a method to get a new card from the dealer by rolling a random number from 2 to 14 with 11 representing a jack 12 a queen 13 - king and 14 Ace

[caption id="attachment_241" align="aligncenter" width="300"] The Loop[/caption]

Designing a Blackjack App - The game loop

When the game starts we will get 2 new cards for the player and 2 for the dealer
Display the dealers second card to the player
Total the players cards and display them
Ask the Player to type H for hit or S for stay
- Accept a uppercase or lower case response
If the player chooses to "hit" another card will be drawn and the loop will continue until the player stays or busts
After the player decides to "stay" the dealer's turn will commence
The dealer will follow Standard black jack rules
- When the dealer has served every player
- The dealer's face-down card is turned up
- If the total is 17 or more, the dealer must stand.
- If the total is 16 or under, the dealer must hit.
- The dealer must continue to take cards until the total is 17 or more, at which point the dealer must stand.
When the dealer stands, or busts the game is over.
If the dealer busts, the player wins
If the dealer does not bust, the total of the two hands is compared and the person with the highest total wins.
Ask the Player to quit or play again

Now lets get to the learning about C# part...Next up... lets code a basic version of Blackjack utilizing as few C# features as possible.

7 essential tips for the developing developer!

nineismine — Sat, 01 Feb 2020 15:36:12 +0000

7 tips on how to become a better software engineer

So you fancy yourself a software engineer? Maybe you've built an app, graduated with a degree, or heck maybe you have been working in the field a number of years. You feel like you have made to the end of the road. Well I hate to break it to you, but that road is just beginning!

It's easy to be a software engineer but much hardware learning how to be a GOOD software engineer!

If the above statement applies to you, I can assure you that you are not alone. Early on in my career as a software engineer I felt the same way. "The hard work was done and now I could go out and find a job". From that point on I would learn everything I needed to know while making fat stacks of cash!

That isn't what happened to me and it probably isn't going to happen to you. In my experience, while the company you work for might have good intentions, they are likely not going to be effective at fostering an environment where you can stay up to date with current software engineering practices. In addition over time as you start to learn the code base, the types of work you will find yourself doing is likely going to cause you to stagnate in things that aren't specific to your current position. I don't care how good you are at your current engineering role, you are likely on slow walk to getting really good at working for the company you are employed with, while losing touch with the current developments and frameworks.

If you don't believe me ask yourself a few simple questions.

What version of your preferred language are you using?
Is it the latest version?
What are some of the differences between the version you are on and the most current version?
What version of .net framework are you using? How many versions have been released between that one and the current? How many breaking changes have been circulated between them?

These questions will likely go a long way toward showing you just how far behind you are on just the baseline stuff. This says nothing about open source and supporting frameworks, new development styles, new development tools and all of the other wonderful stuff that is constantly changing in the software engineering world.

I used to think that these things didn't matter.

It didn't matter to me that I was developing on Visual Studio 2013 instead of Visual Studio 2019.

I didn't realize that all those things that I saw in job postings we ACTUALLY big gaping holes in my knowledge. These things are important to hiring managers (I'd done some work in ASP.net. That's close enough right?). But once I started finding the avenues to easily start learning these things it really opened my eyes as to the sheer volume of information that I was missing just because I wasn't working on my craft outside of work.

So what should we do to become a better software engineer?

Start listening to Podcasts.
Podcasts huh? If you'd have told me 5 years ago that I'd be here today recommending that someone else , or even that I myself would become a regular podcast listener. I would not have believed you. But here is the thing with podcasts, if you can find a few good podcasts tailored to your industry and listen to a few episodes a month on your commute or some other designated alone time, you can find yourself with a ton of great "pointers to things for yourself to learn and explore later when you have focused time to study" What I find is that when I am working on a training course, these courses tend to focus on the small details, and often I find myself having memorized a set of instructions which I might be able to repeat later but with a tenuous grasp on the higher level stuff. It's almost like I have a pocket full of arrays of data when I was hoping to have a neatly organized jagged array of new cool things I learned. I think it takes a mix of these two elements to really learn something and this is where the podcasts come in, while you are doing essentially nothing you can start priming yourself for what you need to learn and then taking that learning to a higher level. This really helps to hone in on where your attention needs to be while studying the details. If time is money then this is free money!
Get an Audible account.
Ok so you have bought in on the podcasts idea and you've started to learn how to learn passively, now it's time to take it up a level! Get an Audible account! Audible is a service by amazon which costs $9.99 a month and allows you to choose ANY audio book in the library each month. You are awared 1 credit a month to purchase a book and after your purchase it you own it. Podcasts are great for absorbing general discussions about things you want to learn about, but they don't always have more specific informationThey often don't go into detail about the topics discussed. For that reason, I suggest you get an Audible account and start amassing a collection of technical material. The $9.99 a month cover charge for Audible is a great investment!
Get a PluralSight account.
(Or another service that provides the same thing) PluralSight is a video training sight with a wealth of video course that can teach you about just about anything in the technical field. Get a PluralSight account and designate some time to work through a course or at least a few sections of whatever it is you have decided is important for your professional development. I have likely learned more from PluralSight than I have from the bulk of the college courses I have taken.
Start looking for Meetups around you.
Meetups! Meetups are local groups, usually dedicated to specific technical disciplines that that allow you to sit down for a period of time and talk shop with your peers. Even if you are working consistently with peers at your day time job you likely aren't replicating this experience. As a bonus meetups allow you to extend your professional network which is going to make finding a job and gaining new perspectives much easier in the future.
Force yourself to practice.
Practice , practice and more practice. If you want to be good at something you have to make yourself practice. I recommend making a goal to practice programming every day. This isn't always fun and it is easy to fool yourself into thinking that it is not necessary. It's easy to convince yourself after spending all day working on code, it isn't reasonable to come home and work on more code. My advice here is to look ahead to projects or responsibilities that you expect to tackle your current job. (or your future job) Use PluralSight to target courses that teach you NEW ways to tackle these projects! Start working on classes that prepare you for your immediate future as a developer. Complete the work, become good at it , and then go pitch your solution as THE solution for the upcoming problem. This helps you to stand out to your peers and your boss! Go get that money guys!
Constantly look at job postings
Even if you aren't looking for a job (and you should be always) start looking at postings. Looking at job postings give you an idea of what skills you are missing should a time come that you NEED to find a job, using all of the aforementioned tips on how to self study, if you are doing them right, you are less likely to find yourself in the oh too familiar situation of looking for a job but only having experience in half of the common concepts and frameworks that are currently in demand. Also, don't fool yourself into thinking that these requirements are beneath you , or the skills you have already learned make up for not having them or even that due to your vast experience a hiring manager will choose you instead of a candidate that already has them. That is self sabotage at it's best!
Refactoring is your friend. Do not settle for your first solution.
Lastly learn to love to refactor your code. Do it once, make it pretty and then refactor it again. keep a list of items you want to improve while you are building your code and then do them when you have time. I can't stress enough how important it is to be able to critique your own methods or how much you learn from rewriting your code and chipping away are assumptions while you implement best practices.

Demystifying the C# Interface

nineismine — Thu, 30 Jan 2020 18:57:23 +0000

Interfaces in programming are a subject that I have sometimes grappled with in C#. When should I use them? Why would I want to spend time writing this extra code that doesn't seem to do anything? How many methods does it take to make a good interface(and justify their existence)?

I've spent a good bit of time puzzling over thee questions. (and even outright avoiding interfaces)

I finally have a grasp on them and hopefully over the course of this post, I can explain them in a way that will demystify the concept for you.

If these are the types of questions that you have struggled with or you are just new to the concept then read on! I got you covered.

How do interfaces work in C# and what is this contract nonsense?

Interfaces in C# are often described as:

An interface is a contract that guarantees to a client how a class or struct will behave. When a class implements an interface, it tells any potential client “I guarantee I’ll support the methods, properties, events, and indexers of the named interface.”

An interface offers an alternative to an abstract class for creating contracts among classes and their clients. These contracts are made manifest using the interface keyword, which declares a reference type that encapsulates the contract."

Pardon me while I put on my "What the heck does that mean face". So while this is technically correct I had a really hard time puzzling those words into actionable code or a solid understanding of when to use them.

Interfaces started making more sense to me when I started thinking of them as behaviors.

As a beginner I tried to reconcile interfaces into a similar bucket as classes , abstract classes and other constructs. Interfaces aren't really like them at all though!

While classes define how a construct behaves , interfaces simply just ensure that we know that the construct will have a behavior .

OK, so what does that mean?

The two main questions that I needed to understand about interfaces we're not well defines in any of the material I viewed when reading about them.

When do I use an interface?
- When I have a group of objects that I want to be able to collect and ultimately use based on the Interface defined behavior(s)
How many methods do I need to apply to an interface to justify the work of building one?
- Just 1! (if you have the need to loop over disparate types based on their behavior)

Often when I have seen interfaces explained in other mediums they use examples where similar things have behaviors that are similar and then they try to explain to us that the interface just means each of these similar things.

In Head First Design Patterns (which I think is a great book) they explain interfaces in the context of animals, and the need for those animals to make sounds.

This example was really difficult for me to wrap my head around because why would I do this? Where would I use this?

It took a long time of my playing around with interfaces to really put together a good example of when and why I would use them.

Finding this understanding also helped me answer the question I had about "How many methods justify the use of an interface?". (hint the answer is 1!)

Here is an example that explains a situation that helped the idea click for me.

Instead of thinking about cats and dogs lets thing about all the different things that we can power on in our house.

In the above example we can see that each of the different types of devices turn on in a very different way.

Let's look at some code

Now what if we wanted to write code to play a prank and turn on everything in the house at once?

Let's assume that we have a program which has a list of all of the devices in the house. Oh wait! How do we even add a Computer , a Car and a Motion Activated Light to a collection? Don't we need to cast a List by type?

So I guess we can make three lists (and one more for every type of other device)

List<Computer> computers = new List<Computers>();

computers.Add(cpu1);

computers.Add(cpu2);

List<Car> cars = new List<Car>();

cars.Add(car1);

cars.Add(car2);

List<MotionActivatedLight>  mals = new List<MotionActivatedLight>();

mals.Add(mal1);

mals.Add(mal2);

Then we could do something like this :

Program Main()

{

foreach (Computer computer in Computers )

{

computer.TurnOn();

}

foreach (Car car in Cars)

{

car.TurnOn()

}

foreach (MotionActivatedLight mal in mals)


//turn them on

}
}

The thing to note here is that we need to treat each object as their own type, put them in collections by type and then iterate through each one to turn everything on.

This is where interfaces can be used to make your job sooooooooo much less tedious.

See with an interface what we are doing is guaranteeing that an object will know how to do some behavior. The objects don't really need to be related by anything other than the interface (or the shared behavior) ...

So how does this make our programming task easier???

Instead of making a list object for each type (Computer , car, Light, TV , Hair dryer, Washing Machine etc) we can make one collection and cast it as the Interface type

Then we can add every device in the house to this one collection! Let look at what the code above would look like using this knowledge.

List<IPowerable> powerableDevice = new List<IPowerable>();

powerableDevice.Add(cpu1);

powerableDevice.Add(car);

powerableDevice.Add(Light);

powerableDevice.Add(TV );

powerableDevice.Add(Hair dryer,);

powerableDevice.Add(Washing Machine );

As you can see we have already simplified things now because we have ONE list but now lets look at the code to turn it on.

Program Main()

{

foreach (IPowerable powerable in powerableDevice )

{

powerable .TurnOn();

}

}

See how much easier that is? This is where the "contract" that people mention comes in . See we know that IPowerable anything will always have a TurnOn() method and even though the means to do it might be totally different for each type we know that the device will know how to manage it. That is what the interface gives us.

Visual Studio: How to Quickly Instantiate classes

nineismine — Thu, 30 Jan 2020 16:46:33 +0000

Visual Studio: How to Quickly Instantiate classes

Early on in my career I found myself questioning the Object Oriented approach at every turn. Implementing and using classes can be a little intimidating when you are first starting to use them . It can also feel like a waste of time, because not only do you need to spend time planning them out, and utilizing precious extra keystrokes to create them. Each time you want to use a class, it requires you to remember each of the member variables and exactly how you spelled them. If we go a little deeper into an actual use case it can be troublesome having to write test cases for each class that we built. To build test cases we need to populate sample data into each of our classes. How can we do that quickly and easily?

Here is a quick tip that will help you quickly and efficiently instantiate classes while using Visual Studio.

Let's say that we have a Customer class that has a whole range of members defined and now it comes time to instantiate a customer object in our program.

One way to do this is to create a new Customer object.

Customer customer = new Customer();

and after instantiating the customer object we can fill in each of the members with test data like so.

customer.Address = "something";

customer.TelephoneNumber = "something";

customer.NextMember = "something";

This is not a real world example, most of the business objects we use in the workplace have 20+ members. On top of that we often create classes in batches.

When it comes time to write test cases it can be difficult to remember what all the naming conventions were if we attempt to populate them as I did above.

A simple trick to make this process a little more palatable is to instantiate your class as i do below.

Instead of creating a new empty class and then assigning the members after. Use curly braces after the "new Customer" declaration.

Customer customer = new Customer

{

};

Then place your cursor somewhere in the body of the curly braces and hit "ctl + spacebar". This will bring up auto complete which will display a list of all of the member variables that are available to the class.

Then hit "Tab" which will auto select and populate the first member.

Then "spacebar" , "=" and give it a value.

Hit comma "," and then repeat the process until you have finished.

Visual Studio is smart enough to only give you values that you have not set. You can use this method to work your way through every member until you have them all filled out.

7 Tips to get into IT without experience

nineismine — Fri, 03 Jan 2020 03:25:29 +0000

A common question I am asked is how to get into the IT field with no experience?

Computers are part of everything that we do on a day to day basis at home and in the workplace. In addition the industry is facing a massive shortage of skilled employees , the IT industry as a whole has seen steady growth in salary over the last decade. So how do you get into the IT field with no experience?

If you are a regular reader of my blog than you may know that I am a software engineer by trade.

You may have even read one of my other blog posts:

How to get into the IT field with no experience.

The next decade will likely consist of a transformation in the IT Industry.

As government agencies complete a transition to more digitized record keeping and workflow which means more jobs. Information Security is becoming front and center in the industry. All the while machine learning is starting to take off and these are all signs that point to a very busy decade for people in this field. If you are thinking about transitioning, now is a great time!

Ok sounds good but how can I do it?

As a guy who grew up in a small town with very little technology footprint, in a family that didn't even own a computer, it's fair to say that I started at the bottom. I didn't own a computer until my 20's and even after I got one that idea that I could break into this industry seemed like a pipe dream. Never the less I did it and I'm here to share some of the ways that I used to get into the IT field with no experience!

Make friends with "computer guys"
Jim Rohn famously said "you are the average of the five people you spend the most time with" . While I don't think this is necessarily a hard and fast rule there is some truth to it for sure! You want to get into computer science right? Well one of the easiest ways to get started is to simply immerse yourself in it! There is probably a department at your work where people are already doing the kind of job that you are hoping to land so why not: - Make an effort to chat some of them up. - Spend more time in their work area. - Find assignments that get you near those work areas. - Make it a point to make conversation and let people know that you are interested in computers! These are some of the things that I did (mostly organically) when I was working outside of the IT field. These things are effective for multiple reasons. When you surround yourself with people in the field you are both networking, and immersing yourself with the day to day terms and operations of people who are working where you want to be. You are also building a support system which will be useful when you stumble at trying to learn on your own.
Get a computer and build it yourself.

My story
My first job was in warehousing, I worked many hours doing manual labor. Doing this I quickly realized that I was more interested in the computer inventory systems , than I was picking and packing orders. Luckily for me I had made friends with a "computer guy" at work. I can't even say that I know what he did there but I knew it had to do with computers.
Getting Started
I asked him if he could help me pick out my first computer. How he chose to tackle that request changed my life forever. Instead of getting some "off the shelf" computer that I could just walk into a store and buy. He gave me a list of parts from a local PC store (shout out to PC Club in Arizona) and I over the next couples months went in on my payday and purchased as many parts as I could. After several weeks (man this part sure was tough! I wanted that computer sooooooo bad!) finally one day I had them all.
Putting it together
I was so excited to bring them over to my friends house and watch him put it together. (We hadn't talked about this part and myself not really being handy at putting anything together, didn't even consider that I could take my pile of computer parts that I had been so diligently collecting and then risk putting them together) I called him up and he told me "Ok put it together", and then proceeded to walk me through how to do that over about an hour on the phone. He explained to me what things looked like, why they were and how they went together.
The Payoff
Putting a computer together is really easy if you just get over the feeling that its some high tech thing! It's easier than working on a car, or wiring up power in your house, it is certainly easier (and less smelly) than replacing or maintaining your toilet! After I put a computer together for the first time, from that point on I was no longer afraid to get under the hood. I had taken my first step toward becoming one of those "computer guys" we mentioned earlier. If you are asking how to get into the IT field with no experience... this is one of the most important steps.
Install Windows and then break it , then reinstall it.
(OK, you don't really need to break it but that's how it went for me. ) After I got my shiny new computer put together I still needed to install Windows on it. While it has gotten much easier to install Windows over the years. It is an important step toward getting over the fear of not knowing things about your computer AND doing this is going to have you touching on some important things that you should understand about how all that magic happens on your computer.
The Bios?
Get in there , install it, break it, fix it! One of the things that you learn about while doing this is the BIOS. I'm not going to go into any detail here but to me the BIOS is like an underlying operating system that controls the hardware of your machine and allows it to boot up to a real operating system. Understanding how to access the BIOS, and configure it (they are all pretty similar in my experience) is going to take you a even farther down the path of getting ready for your new career. Understanding how to install and configure Windows is another important step in our goal, how to get into the IT field with no experience.
Find a project / Start learning / Pursue a degree?

OK so which one?
How you tackle this can really vary and I would suggest that you do what is right for you. I will tell you about some of the first things that I did though! Let's tackle college first. I am just about to wrap up my Masters Degree in Information Technology. When I look back at my time in school it definitely is not the deciding factor in my success. If you have to pay for your own schooling and work while doing it, without a doubt, you will learn far more from personal projects than from anything else in my lifetime (especially college).
Is college for me?
Colleges these days are pretty far behind current technologies. (Books take a long time to write publish and get approved for curriculum! ) The new fad seems to be online college in compressed time frames to churn students through the rankings. On top of that you could very easily come out of a degree program (like me) owing a ton of money. I'm just not sure that it is necessary. While the structure of a college curriculum can take away the burden of self-motivating and self-directing. If you aren't careful you will find yourself pushed down the wrong path, learning the wrong things. It's easy to find yourself with a schedule that's been assembled by a student support system whose main goal is to enroll students , not ensure they are taking the right classes.
OK so if not college then what?
I think it is a good idea to start some personal projects! Do some free online classes , set up something in your home that stretches what you know! Take control of your networking environment , set up your router , make a network diagram, find a video series and follow it but put your own spin on it! Adapt that tutorial to something specific in your home environment.
Start reading job postings (and applying to them)
Here is the thing about job hunting. It takes up a bunch of time, employers have more tools than ever to screen out candidates and there is more information then ever out there about what skills employers are looking for than at any time before.
So what does that mean for us?
First off , one of the hardest things about getting into the IT field is just how many different avenues of learning there are to pursue. In addition, how much do you need to know about each? How do you find a good learning path to ensure you have the required skills?
This is where job hunting comes in.
Looking over job postings (at least monthly) will give you an idea of what kinds of jobs are available and what skills are required for them. Start looking and applying as soon as possible. Even before you feel 100% that you can land a job get the process going. Understand that this time is an investment in your career and while it might not land you a job. You will see over time how much more prepared you are as a result of it.
Don't forget about networking

First off get on LinkedIn... NOW.
I know I know , you are anti conformist and you "Don't do that social media stuff".. well you do now! Every job I have accepted since my first job in the technical field has been at least partially due to networking. Get on Linked In, start giving your coworkers referrals and start making connections. The more people you have access to the more information you have about jobs and the better chance you have of landing them. This doesn't mean that you should make an effort to create superficial connections. We aren't looking for an "instagram likes count" we want to make strong connections with people who know what kind of worker you are and can vouch for you. Also remember to do the same for others too!
Start looking for crossover positions

Last but not least start looking for things in your current role, that work as a crossover into the IT world.
- If there is a spreadsheet to maintain... maintain it. - Look for a manual process in your area and automate / digitize it. - Find a pain point in your department, find a solution and sell it to your manager. If you can do these sorts of things long enough, ask for a title change to reflect the work you are doing. Even if you can't get a title change (bigger companies often have inflexible title structures) these kinds of activities can go on your resume. Do them long enough and you now have real experience which might actually qualify you for a new job in your chosen field. If you do this you can go from "how to get into the IT field with no experience" to "How to find a job in the IT field WITH experience".

Forem: nineismine

Demystifying Methods and Functions in C# - When should I use them?

When should I create a new method when programming in C# (or other languages)?

What's that? A Verb? I hated English class!

Let’s break that down a bit!

Let’s take this one step farther now.

Create your first game using Unity and C# – Part 2 Creating your first script to handle player movement.

How to build a game in Unity and C# part 2 - Player Movement.

Lets add some physics!

Add a RigidBody component to the player object

Make a script for the player movement.

Add the script

Modify the Script in Visual Studio

Let's add our script to our player!

Coding the Player Movement

Let's talk about variables! - (explanation)

Let's assign our variables

Get a reference to the Rigidbody component that we set up earlier.

Whats is happening with this change variable? - (explanation)

Make the changes to the change variable

Let's talk about the code that makes the player move..(explanation of functions/ methods)

When should I create a new method?

Writing the movement code.

Breaking the code down

Finally! We are done and we can test.

One last thing for fun!

Create your first game using Unity and C# - Part 1 Getting your environment set up and importing some art.

Creating your first game in Unity and C#

Get the tools you need and install them

Create a new project

Getting to know the Unity Interface

Create folders to store your work

Import a sprite set for your character

If any of you have made it this far ... do me a favor and leave a comment or sign up to my mailing list so that I can gauge the interest in this type of content.

What I learned in 10 weeks of trying to teach myself how to touch type.

10 weeks of trying to learn how to type.

Part 1

The unseen challenges of not knowing how to touch type.

Week one: Typing.com

The pros:

The cons:

My feelings about Typing.com in detail

Practicing real words is more effective than drilling keys...

The problem with these 2 finger drills is two fold

Typing.com doesn't(really) make you learn from your mistakes.

Some simple things would fix some of their issues

Weak Reporting

12 tips, tricks, and Visual Studio 2019 shortcuts to increase efficiency - Part 1

Visual Studio 2019 shortcuts

Quickly add public properties

Quickly populate a full property with public and private members

Quickly add a new class to your project

Go to the definition of any object

Move lines up and down in the editor

You can move lines just by pressing

Quickly Launch a new project or search your solution , add a class and lots of other stuff.

Quickly populate Console.WriteLine()

Quickly populate an IF statement, for loop , foreach loop , do , while, enums and others

Open Quick actions and Refactoring (from here we can do a whole host of things)

Quickly Navigate to... well anything

Quickly search your solution explorer

Quickly run an automated test

How to use Visual Studio 2019 to access and check in code to GitHub in 15 minutes

Are you ready to learn how to check in code to GitHub in 15 minutes?

Adding your GitHub Account to Visual Studio.

In the menu select View > Team Explorer

Team Explorer > Manage Connections (it looks like a green plug) > Connect to Github

Fill in your account data

How to create a local repository

How to import a remote repository.

Remote... Local? What's the difference?

Ok! Now that I have a repository... What the heck do I do with it?

How to modify your active workspace

How to commit your changes to the Local Repository.

Let’s build a basic Blackjack App using C# and the Console Part 1 - The Design

Designing a Blackjack App

Software design practices and good habits!

Requirements

Designing a Blackjack App- The Technical Design

Things that we will need to manage the game