DEV Community: Tech Elevator

What Does ChatGPT Mean for New Software Developers?

Matt Eland — Mon, 19 Dec 2022 21:54:04 +0000

I spend my days teaching new developers how to code at Tech Elevator’s fantastic programming bootcamp. My evenings and weekends, however, belong to my study of data science, artificial intelligence, and conversational AI.

Recently I’ve watched these two worlds crash together with the sudden revelation of OpenAI’s ChatGPT chatbot and the incredible things it can (and can’t) do.

In this post we’re going to explore what ChatGPT is and what it means for current and future software engineers.

What is ChatGPT?

ChatGPT is a new conversational AI chatbot developed by OpenAI that reached public visibility in late November of 2022. Unlike traditional chatbots, ChatGPT is able to take advantage of advances in machine learning using something called transformers, which give it a greater contextual awareness of the documents it has been trained on. This allows it to generate responses that mimic those you might see from a human.

What makes ChatGPT different from anything that has come before is its breadth of responses and its ability to generate new responses that seem to have a high degree of intelligence behind them. This means that I can ask ChatGPT to tell me stories, outline an article, or even generate code and it will give me something that looks convincing and may even be usable.

However, ChatGPT is not human-like intelligence, though it’s the closest I’ve ever seen a computer come to emulating it.

What ChatGPT Can’t Do

ChatGPT is open about its limitations and displays it on its landing page:

ChatGPT’s intelligence is in its contextual awareness in conversation and the breadth of information it’s been trained on. But this is historical information.

I’ve certainly seen ChatGPT make mistakes. It’s given me factually incorrect information about software libraries, has even made up libraries that don’t exist and referred me to libraries that have long ago been retired.

ChatGPT is not human and lacks the ability to:

Understand that what it generates may be incorrect (or communicate its lack of confidence in its answers)
Understand the emotional / practical needs of humans
Understand the basic characteristics of our world

As a humorous example, I gave a conference talk this year entitled: “Automating my Dog with Azure Cognitive Services.” It was a fun exploration of using artificial intelligence to recognize objects in images, generate speech responses from text, and interpret human text.

When I asked ChatGPT how it would structure that talk, it gave me a beautiful outline that was perfect … except it suggested that artificial intelligence could listen to my dog’s spoken words and respond appropriately. For all of its intelligence and impressiveness, it failed to grasp the basic fact that my dog cannot speak English.

It’s incredible that ChatGPT can generate content for you, but that comes with some limitations as well. First of all, ChatGPT is not truly synthesizing new things. Instead, it is arranging things it has encountered before in creative ways.

It may be arranging aspects of the English language, story structures, or answers it sees posted in locations it deems trustworthy, but it is arranging content and structure that it knows about already in new ways.

This means that if we stop creating new articles, stories, programs, and works of art, ChatGPT and systems like it will not be inventing anything new on their own.

Another severe limitation of transformer-based systems like ChatGPT is that they are very hard to understand how they came up with content. This means that if ChatGPT generates a response, that response may be a word-for-word quote from someone else and you wouldn’t even know.

However, ChatGPT and systems like it can generate some very good starter code and give you answers that are often more helpful than they are not.

Will People Still Need Software Developers?

Since transformer-based systems are only five years old at this point, it begs the question: in five more years, will we need developers at all?

Let me tell you a little secret: since I’ve been a programmer, people have been talking about no-code and low-code approaches to software development that remove those pesky software developers from the equation.

Thus far, none of these systems have delivered on their promise. This is because software development is an incredibly complex field that requires you to think about many different aspects of development including:

Meeting the business needs
Quality / testability
Speed of delivery (deadlines, project plans, etc)
Ease of maintenance
Performance as the number of users or volume of data scales up
Security
Explainability

It turns out that in order to meet the varying and competing requirements of a software project, you need to be able to understand people, balance those competing concerns and deliver a creative solution that meets those needs in both short and long term ways.

Because ChatGPT doesn’t actually understand the content it generates, it has no idea if its responses will work or are relevant to all of your business needs.

Because the code ChatGPT generates is based on code it has encountered before, it cannot make any guarantees that the generated code:

Is free of bugs
Is well-documented
Is easy to understand and maintain
Is free of security vulnerabilities
Meets the entire requirements set out by the business
Is not an exact duplicate of code encountered on the internet
Performs adequately at scale in a production environment

Perhaps most crucially, ChatGPT cannot modify code that it has previously authored or understand large solutions and modify them as needed.

This technology is only five years old, and it will evolve and become more transparent, easier to control and even more useful in the future, but it will never:

think for its own,
understand your business context,
or understand the humans involved with and invested in your system.

Even if a successor to ChatGPT overcomes many of these limitations, you still need someone with a deep technical understanding to be able to tell it what to do and evaluate the quality of its output.

How can ChatGPT help me on my Journey into Tech?**

Instead of replacing developers, I see ChatGPT, GitHub CoPilot, Amazon CodeWhisperer, and systems like these (as well as those that follow) as new tools in the developer’s tool belt.

These code generation tools are good at generating basic “boilerplate” code that can then be refined and modified by a professional developer to meet your needs.

However, as a new learner, I’d encourage you not to use ChatGPT excessively to generate code. This is because you are still building the mental muscles needed to generate for loops, methods, and variable declarations. You are still learning to think critically about things to build your own understanding.

At Tech Elevator, we move quickly and I have seen a few students resist the requirements of daily homework practice thinking that it was beneath them or not worth their time—only to discover that by skipping this work they had not developed the skills and understanding necessary for the more complex aspects of software development. I see ChatGPT offering this same temptation to new learners.

I’m not saying that ChatGPT is dangerous or to be completely avoided. I’m saying that I would use it as a refresher on concepts you’ve already learned and only use it to generate code as a last resort. In fact, I’d recommend seeking help initially from a human instead of ChatGPT, especially when it comes to code that doesn’t work.

Using ChatGPT before you’ve internalized the mechanics of programming is like asking a preschooler to learn to ride a bike by giving them a motorcycle instead of a tricycle or bike with training wheels.

ChatGPT can be incredible, but you are going to be far better off finding a qualified developer to mentor you early on in your journey instead of relying on its code. Not only can a human understand you and tailor their answers to your experience, needs, and emotional state, but frankly you won’t even know the right questions to ask an AI system until you have enough experience.

ChatGPT as a Tool for Software Engineering**

As a seasoned developer I know many things about programming and have the syntax and methods I use on a regular basis committed to memory. However, there are infrequent tasks that I often need to search for a quick refresher periodically.

In this regard, ChatGPT meets my needs quite nicely as an alternative to Google. ChatGPT generates simple code for me to use as reference (not to copy / paste) and refresh myself on its syntax.

Additionally, ChatGPT is invaluable when using a new library or language. I might know how to do a for loop in one programming language, but forget the syntax in another language. ChatGPT helps me transfer my existing knowledge more easily between languages.

Ultimately, ChatGPT and the systems that follow it signal the advent of new code generation tools we’ve not seen before. These tools are incredibly powerful and appealing, but they require the guidance of a trained professional. Learning to program will help you know when, where, and how to use this tool to build the best software you can.

Personally, I’m incredibly excited to see where the future takes us and see if we can improve and harness these incredible tools to build even better things as software engineers.

This post was originally published at Tech Elevator on December 19th, 2022.

Do I need to be Good at Math to be a Software Developer?

Matt Eland — Mon, 14 Nov 2022 17:00:38 +0000

Editorial note: This article was originally published to Tech Elevator’s blog on October 31st, 2022

As a software engineering instructor at Tech Elevator, one question I hear most often from new and prospective students is this:

"Do I need to be good at math in order to be a software developer?"

Thankfully the answer is a resounding No.

What I've found in my time teaching is that every student has different strengths and weaknesses and a unique way of thinking. Some students are naturally inclined towards math, while others dread it (as I suspect you might be if you're reading this article). And yet, they make fantastic software developers.

Personally, I have found aspects of math that I love and aspects of math that make me panic and shut down. Regardless of my weaknesses, I enjoyed a very successful career as a software engineer.

Let's talk about what you actually need to know and the skills you do need to be a successful programmer.

Why You Don't Need to be Good at Math to be a Programmer

Many people assume that because many lines of code resemble algebra at a glance that you need to be good at math in order to program.

This is very much not the case. Mathematics is all about following formulas and theorems to calculate values by simplifying and reducing values.

Programming, on the other hand, is about setting up a series of simple instructions for a computer to follow and carry out to achieve the task you're trying to accomplish.

For example, a program might follow this series of instructions:

Display a greeting message to the user.
Prompt the user to type in their age in years.
Wait for the user to type in their age in years, then store the result.
Multiply the number the user entered by 365 and store the result.
Display a message to the user informing them that they're at least that many days old.

While there is math here (multiplying a number by the number of days in a year), as a programmer you don't even need to be able to do that multiplication yourself; you just need to tell the computer what task to complete.

Much of software development follows this flow: figure out a path for the program to take to accomplish a specific task. This path may involve mathematical operations such as calculating totals, but it doesn't have to.

Logical Thinking in Software Development

Instead of asking yourself if you're good at math, ask yourself the following questions:

Am I able to break down large tasks into a series of small steps?
Do I like improving things?
Do I enjoy using creative thinking to solve problems?
Do I enjoy making little changes that add up over time to build larger things?
Can I consider many different possibilities?
Do I like to learn new things?

Programming is all about telling computers to calculate and store values, making decisions based on what something currently is and interacting with the user, files, databases and other systems.
Let's take a look at a small piece of code that gets a temperature from the user and displays a message:

// Display a message to the user
Console.WriteLine("Please enter a temperature in degrees Fahrenheit");

// Store a value from the user
string userInput = Console.ReadLine();

// Convert from text to a number
double temperature = Convert.ToDouble(userInput);

// Display a message to the user indicating the temperature range
if (temperature >= 85)
{
   // 85 degrees or more
   Console.WriteLine("It's pretty hot today!");
} else if (temperature <= 50) {
   // 50 degrees or less 
   Console.WriteLine("It's cold today!");
} else {
   // 51 to 84 degrees
   Console.WriteLine("It's a nice day!");
}

This is similar to the material we cover at the beginning of our curriculum at Tech Elevator, so it's perfectly fine if you can't read this code yet. I included this to illustrate what typical code looks like and how different it is from math.

This C# code lets the user type in a number and converts that number from text (a string) to a numeric value (a double). Next, we use conditional logic to display a message to the user based on the temperature. The user will then see a message indicating if it's hot, cold, or nice weather.

As you can see, there's very little mathematical notation here. Instead, we see programming syntax and commands to check if numbers are greater than or less than a value and display those values to the user.

This is what 99% of programming is about: controlling program flow through logic and guiding the program to accomplish a specific task through a series of instructions.

Math That Is Helpful for Software Development

So, what aspects of mathematics are helpful for software developers?

While we don't do traditional mathematics in software development, it is often helpful to understand mathematical principles.
For example, if you don't understand the concepts of addition, subtraction, division (including remainders), multiplication and division, it's going to be difficult to write code that takes advantage of those concepts.

As developers, we occasionally need to work with absolute values (removing a negative sign if one is present), averaging, getting the largest or smallest value and a handful of other mathematical operations.

If you are interested in specialized types of development, there may be other aspects of mathematics that will help you. For example, in game development I frequently found myself challenged by being weak in trigonometry. However, recent years have actually made it easier to do game development tasks without requiring a heavy understanding of trigonometry.

Finally, as programmers, we do sometimes talk about something called "Big O notation," which is a mathematical notation illustrating how much slower a program gets the more you add items to a list of data. This topic is beyond the scope of this article, but at its core Big O is centered on understanding how sharply the amount of time will increase the more you add data.

Mathematical knowledge will help you with software development and may show you possibilities that you wouldn't have considered without it. However, the majority of programming is logical thinking, not pure mathematics.

Ultimately, only you know what you are capable of and how you best solve problems. If you've never tried programming before, you should try following a few tutorials to see how you like it.

One of my greatest joys as an instructor is seeing students who didn't think they could be developers get jobs, thrive and succeed in those jobs. At Tech Elevator we are very skilled and passionate about helping students discover what they can and can't do. Don't let fear of mathematics stand in your way from becoming part of something amazing and enjoying a profoundly rewarding career in tech.

Ready to Kickstart Your Career Transformation?

If you're ready to take the next step and think a career as a software developer is the path for you, then take our Aptitude Test to get started.

If you still have unanswered questions, schedule some time to talk with our admissions team. We're happy to help explore your future career options in tech.

How to Build a Game & Learn C# - Loops & Finishing the Game

Matt Eland — Tue, 23 Feb 2021 14:39:10 +0000

In this final part of a four-part tutorial series we'll complete our "Guess the Number" game that we've been developing.

This final tutorial brings everything together and also introduces the key concept of loops and shows you a way to generate random numbers in .NET.

By the time we're done, you'll have a working game where the program secretly selects a number between 1 and 100 and asks the player to pick numbers until they've guessed it.

This article is also available in video form:

Note: This series is based loosely on some of the content from the 1st week of Tech Elevator's 14 week C# curriculum

Our Code as we last saw it

This was our code by the end of the last tutorial:

using System;

namespace GuessTheNumber
{
    class Program
    {
        static void Main(string[] args)
        {
            // The program's secret number that the player has to guess
            int secretNumber = 42; // TODO: This should be random between 1 - 100
            int guess = 0;

            // Let the player enter a number
            Console.WriteLine("What is your guess?");
            string guessText = Console.ReadLine();

            // Evaluate the player's guess and respond
            guess = int.Parse(guessText);
            if (guess == secretNumber)
            {
                Console.WriteLine("You guessed the secret number!");

                Console.WriteLine("The application will now close.");
            }
            else if (guess > secretNumber)
            {
                Console.WriteLine("The number is lower than " + guess);
            } 
            else // If we got here guess must be < secretNumber
            {
                Console.WriteLine("The number is greater than " + guess);
            }

            // TODO: Loop until the player gets the answer right

            // After this line is reached, the program will end
        }
    }
}

At present, the application lets us guess a number and then tells us if that number is correct, too high, or too low. You currently only get a single guess, and the number you're trying to guess is always the same.

Let's fix that, starting with the problem of the player only getting one guess.

While Loops

If we want the user to keep guessing numbers until they guess the correct one, we'll need something called a loop.

When writing code, often we'll want to either do something a specific number of times or even do something continuously until a specific condition is met. In C# we have a surprising number of ways of writing loops, but one of the simplest types of loops will work fine for our application here: the while loop.

A while loop will do something while a condition is true. So, for example, while the user hasn't guessed the number, ask the user what number they want to pick and then tell them if their guess was right, high, or low.

In fact, that's exactly what we want to do. Let's do this by going to where we declared our guess variable (not guessText) and adding a pair of lines after that:

while (guess != secretNumber)
{

If this looks a little like an if statement from the last tutorial, that's because they're very closely related. While an if statement would look like if (guess != secretNumber) instead we use the while keyword.

The while loop will execute the code between it's { }'s as long as the condition in the parentheses is true at the beginning of the loop.

A quick note on != - this is very closely related to == meaning two things are equals, but instead != indicates not equal. So here we're essentially saying "while the guess is not equal to the correct answer".

You may have noticed that we haven't closed our loop yet. We'll need to add a matching } to the program for the compiler to be happy, so let's do that now.

Add a } to the line just before the final comment in the application.

Your Main method should now look like this:

        static void Main(string[] args)
        {
            // The program's secret number that the player has to guess
            int secretNumber = 42; // TODO: This should be random between 1 - 100
            int guess = 0;

            while (guess != secretNumber)
            {
                // Let the player enter a number
                Console.WriteLine("What is your guess?");
                string guessText = Console.ReadLine();

                // Evaluate the player's guess and respond
                guess = int.Parse(guessText);
                if (guess == secretNumber)
                {
                    Console.WriteLine("You guessed the secret number!");

                    Console.WriteLine("The application will now close.");
                }
                else if (guess > secretNumber)
                {
                    Console.WriteLine("The number is lower than " + guess);
                }
                else // If we got here guess must be < secretNumber
                {
                    Console.WriteLine("The number is greater than " + guess);
                }
            }

            // After this line is reached, the program will end
        }

And when we run it, you should be able to guess numbers until you arrive at the secret number (which is still always 42)

Randomization

Now that we've got everything working properly in the loop, we have one final step: our program needs to secretly pick a random number when it runs for the first time.

To do this, we'll introduce a new part of .NET development: the Random class.

Lets replace the int secretNumber = 42; line at the top of our program with the following two lines:

Random randomizer = new Random();
int secretNumber = randomizer.Next(1, 100);

These final two lines complete our program, but what do they do?

The first declares a new variable named randomizer that will store a Random class instance, which is then created and assigned into the randomizer variable.

This syntax and classes in general are beyond the scope of this tutorial series (and are something that we devote entire weeks of our curriculum to at Tech Elevator), but for now understand that a class is a collection of related functionality and data around some sort of programming concept.

In our case, the Random class contains a lot of related methods around random number generation, and that's exactly what we use it for on the second line. int secretNumber = randomizer.Next(1, 100); generates a random integer between 1 and 100 and stores it into our secretNumber variable.

With that, our program is now able to generate a random number.

Putting it All Together

Let's take a step back and look at our program as a whole:

using System;

namespace GuessTheNumber
{
    class Program
    {
        static void Main(string[] args)
        {
            // The program's secret number that the player has to guess
            Random randomizer = new Random();
            int secretNumber = randomizer.Next(1, 100);
            int guess = 0;

            while (guess != secretNumber)
            {
                // Let the player enter a number
                Console.WriteLine("What is your guess?");
                string guessText = Console.ReadLine();

                // Evaluate the player's guess and respond
                guess = int.Parse(guessText);
                if (guess == secretNumber)
                {
                    Console.WriteLine("You guessed the secret number!");

                    Console.WriteLine("The application will now close.");
                }
                else if (guess > secretNumber)
                {
                    Console.WriteLine("The number is lower than " + guess);
                }
                else // If we got here guess must be < secretNumber
                {
                    Console.WriteLine("The number is greater than " + guess);
                }
            }

            // After this line is reached, the program will end
        }
    }
}

Here our program picks a random number. We then loop until the user's guess is equal to that number. Each time we loop the player is prompted to guess a number. The text they type in is then parsed into an integer which can be compared to the secret number. The program then compares the guess to the secret number and displays an appropriate response.

What's Next?

Congratulations! If you followed along, you wrote a fairly simple console game in C#.

This app, while short, illustrates some key programming concepts:

Variables
Expressions
Basic Data Types
If / Else Statements
Loops
Console Input and Output

This is by no means everything that C# has to offer. In fact, this series based off of a small portion of the first week of Tech Elevator's 14 week curriculum.

While this was just a small taste of C# and .NET development, it should give you a feeling for what it is like to work with code and structure programs.

If you'd like to learn more, there are plenty of books, articles, and courses on software development. Of course, I have to plug Tech Elevator's 14 week C# and Java curriculum. Both are centered around learning full stack development with JavaScript and Vue.js on the front-end. Both emphasize learning by building things with regular individual exercises, pair assignments, and larger projects. Tech Elevator also supports students through this journey by giving them ready access to veteran industry professionals (such as myself) who are heavily invested in their success.

If you'd like to learn more about Tech Elevator, I strongly encourage you to take a free mini-aptitude test or check out a number of our other Learn to Code resources.

On a more personal note, however you wind up learning, I wish you the best success. I can't imagine my life without programming and the ability to be able to imagine something and then make it a real thing by writing on a computer is something that still amazes me after 3 decades of writing code.

How to Build a Game & Learn C#: User Input & If Statements

Matt Eland — Tue, 23 Feb 2021 14:35:30 +0000

In our last two tutorials we discussed creating a new C# project and the concepts of variables and expressions as we moved towards programming our first application: a Guess the Number Game.

In this tutorial, we'll expand our bag of tools to get text from the user, interpret it as a number and perform some basic mathematics with it. We'll close by introducing if statements, an extremely powerful tool in our toolbelts as programmers.

This article is also available in video form:

Note: This series is based loosely on some of the content from the 1st week of Tech Elevator's 14 week C# curriculum

Let's get started.

Cleaning the Slate

In our last article we wrote some basic code to illustrate string and int variables. That was good as a learning exercise, but it won't be useful for our final application, a game where the user can guess a number from one to one hundred and be told if their guess was high, low, or correct.

Let's clear out the existing Main method and replace it with this:

static void Main(string[] args)
{
    // The program's secret number that the player has to guess
    int secretNumber = 42; // TODO: This should be random between 1 - 100
    int guess = 0;

    // TODO: Let the player enter a number

    // TODO: Evaluate the player's guess and respond

    // TODO: Loop until the player gets the answer right

    // After this line is reached, the program will end
}

Here we have a mostly empty method that has major comments for the logic we'll need to do in this tutorial and the next one in order to get the game working properly.

We also have a secretNumber integer variable that is set to 42 for now, but we'll have the program generate a random number next tutorial.

This secretNumber represents the number that the player has to guess. By the end of this tutorial, you'll be able to enter a number into the console and be told if it is less than, greater than, or exactly the "secret" number.

Note: We're declaring our guess variable here to save us some time and confusion later on. Don't worry about why this line is here yet.

Getting User Input

Let's expand the // Let the player enter a number comment to include the following code:

// Let the player enter a number
Console.WriteLine("What is your guess?");
string guessText = Console.ReadLine();

Console.WriteLine("You guessed: " + guessText);

Before we talk about the code, let's run the program with these changes. You should now be able to enter some text and see the result in the console as shown below:

This works because Console.ReadLine() causes the program to wait for the user to type in some text and type enter. The program then takes that value and assigns it into the guessText variable.

So, if the user typed in "I'm Batman" (remember, ReadLine allows the user to type in any text), guessText would store that string and the following line: Console.WriteLine("You guessed: " + guessText); would evaluate to Console.WriteLine("You guessed: I'm Batman"); and display that message.

Next, let's look at how we can interpret the user's input as a number.

Parsing Strings to Integers

While we can't change Console.ReadLine to have it return an int instead of a string or require a numeric input, we can try to interpret the string the user typed in as a number.

We do this via the int.Parse method.

Add the following code below the code you wrote earlier:

guess = int.Parse(guessText);

Console.WriteLine("2 x " + guess + " = " + (guess * 2));

There's a decent amount going on here, so let's take it a line at a time.

guess = int.Parse(guessText); sets the guess variable we declared earlier to be the result of int.Parse on the user's text. int.Parse is a method provided by .NET's base class libraries that takes in a string and attempts to convert it to an integer.

Note: There are ways of handling cases where the user types in random text instead of something that is a number. However, for the purposes of keeping this tutorial focused, we'll assume that the user is providing valid input

Revisiting Expressions

Next let's talk about that Console.WriteLine("2 x " + guess + " = " + (guess * 2)); line.

This is similar to what we've seen before, but a bit more complicated. We have a few new things that we've not seen before in the (guess * 2) expression.

The * operator means multiplication, so this will multiply the current value of guess by 2.

When this line runs and guess is 5, it will first evaluate to

Console.WriteLine("2 x " + 5 + " = " + (5 * 2));

This simplifies down to

Console.WriteLine("2 x " + 5 + " = " + 10);

This is a lot more familiar and simplifies to

Console.WriteLine("2 x 5 = 10");

Which is exactly what is displayed on the screen.

Getting Ready for Conditions

Okay, now that we've demonstrated that integer parsing works, let's remove the last two Console.WriteLine statements. Your code should now look like this:

static void Main(string[] args)
{
    // The program's secret number that the player has to guess
    int secretNumber = 42; // TODO: This should be random between 1 - 100
    int guess = 0;

    // Let the player enter a number
    Console.WriteLine("What is your guess?");
    string guessText = Console.ReadLine();

    // TODO: Evaluate the player's guess and respond
    guess = int.Parse(guessText);

    // TODO: Loop until the player gets the answer right

    // After this line is reached, the program will end
}

We should now be in a good place to start looking at interpreting the user's guess.

If Statements

Now, let's look at some new syntax for conditionally doing things in code: the if statement.

If statements let us do specific logic if an expression evaluates to true.

Below the int guess = ... line, add the following code:

if (guess == secretNumber)
{
    Console.WriteLine("You guessed the secret number!");

    Console.WriteLine("The application will now close.");
}

Now when we run the application, if you type in "42" you should see the console message indicating you guessed the number:

So let's look at how this works. We'll start at that first line: if (guess == secretNumber)

The if statement requires parentheses. Inside these parentheses, C# needs an expression that evaluates to either true or false. If the expression evaluates to true, any code inside of the { }'s will be executed.

The code inside the {}'s can be any C# code you can write - variable declarations, Console calls, etc. The key here is that it only is executed if the expression in the if statement is true.

Let's look a bit more at that expression: guess == secretNumber. We've not seen == before. The "double equals" operator is a way to compare the left side to the right side. If the two sides are equal, the expression will evaluate to true, otherwise the expression will evaluate to false.

As an example, if the current value of guess is 35, the line becomes if (35 == 42) which evaluates to if (false). Since this value is false, the code inside the { }'s will not execute.

Conversely, if guess was 42, the line becomes if (42 == 42) or if (true) and the code inside the {}'s will work.

If / Else Blocks

So, if statements are powerful, but they can do a bit more than we just did. We can add an else statement after our if as shown below:

if (guess == secretNumber)
{
    Console.WriteLine("You guessed the secret number!");

    Console.WriteLine("The application will now close.");
}
else
{
    Console.WriteLine("Nope. That wasn't the number.");
}

Here one of these two { } blocks will always be executed. If the expression in the if statement is true, the first block will execute as before. Otherwise, the else block will execute and the user will see the message indicating that they guessed incorrectly.

Chaining If / Else Blocks

But wait, there's more!

Remember that the app we're building will tell the user if their guess was exactly correct, too high, or too low. Right now we only give the user information on whether their guess was correct or incorrect.

We can take advantage of else blocks to chain together if statements by replacing that second { } (and its code) with another if statement as shown below:

if (guess == secretNumber)
{
    Console.WriteLine("You guessed the secret number!");

    Console.WriteLine("The application will now close.");
}
else if (guess > secretNumber)
{
    Console.WriteLine("The number is lower than " + guess);
}

Here we go directly from the else statement into another if statement. This is entirely legal C# code and will only execute if the guess is not the secretNumber.

C# will then evaluate that second if statement and check if (guess > secretNumber).

We haven't looked at > before, but this is a comparison operator that evaluates to true if the left side is greater than the right side and false otherwise. Similarly, there is also a < operator for less than as well as >= and <= for greater than or equal to and less than or equal to.

Now, if we run and guess 50, we'll see a message indicating that our guess was too high.

Accounting for All Possibilities

Our code is still missing something, however. If the user guesses a number below the secret number, they won't see a message. Let's add an else to the end of our logic as shown below:

// Evaluate the player's guess and respond
guess = int.Parse(guessText);
if (guess == secretNumber)
{
    Console.WriteLine("You guessed the secret number!");

    Console.WriteLine("The application will now close.");
}
else if (guess > secretNumber)
{
    Console.WriteLine("The number is lower than " + guess);
} 
else // If we got here guess must be < secretNumber
{
    Console.WriteLine("The number is greater than " + guess);
}

This finalized if / else chain handles cases where:

guess is exactly equal to secretNumber
guess is greater than secretNumber
All other cases (less than secretNumber)

Now, no matter what the user enters, they should see a message letting them know how close their guess was.

Next Steps

As you can see, we're starting to get to a workable application, but we're still missing a few key pieces.

In the final tutorial of the series, we'll introduce random number generation, loops, and tie everything together into a single application.

This article is based on abridged content from a few days in the first week of Tech Elevator's 14 week full stack C# development curriculum. Learn more about Tech Elevator, take a free aptitude test to see if you might be a good match for development, or check out our other Learn to Code resources

How to Build a Game & Learn C#: Adding Variables & Expressions

Matt Eland — Tue, 23 Feb 2021 14:30:03 +0000

Last time we got started learning C# by creating a new C# project.

When we last left off, our code looked something like this:

using System;

namespace GuessTheNumber
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

That's fine for making sure our code runs, but let's see what else we can do on our way to making a larger project.

In this tutorial we'll take the code from the previous tutorial in this series and introduce variables and expressions.

This article is also available in video form:

Note: This series is based loosely on some of the content from the 1st week of Tech Elevator's 14 week C# curriculum

Variables

Right now, when we run our code it displays the message "Hello World" as pictured below:

Let's make this do something a bit more than that.

Change your Main method to match the following code and run your application again:

        static void Main(string[] args)
        {
            string message = "Hello Variables!";

            Console.WriteLine(message);
        }

Now, when we run the application we should see something like the following:

What we've done here is create a string variable named message and then set it equal to "Hello Variables!".

In programming, a string refers to a sequence of letters, numbers, or other characters. Strings can be anything from a single letter to the entire contents of a book. For simplicity's sake, when you think of a string, think "some text".

A variable, on the other hand, is something that holds on to some value, whether that is a number, a string, or potentially more complex things like classes or lists of data.

Understanding Expressions

Variables can be read from and written to. Here, when we say string message = "Hello Variables!";, we're both creating a variable and writing an initial value to it.

Conversely, when we say Console.WriteLine(message); we're reading the current value for the message variable when it gets to that line.

These things are referred to as expressions. When C# runs your code, it evaluates the contents of each line as an expression. When it sees Console.WriteLine(message) it will evaluate the things inside of those parentheses to get their current value.

When your program sees message, it substitutes the current value of the message variable so the code being executed looks like Console.WriteLine(**"Hello Variables!"**); which is why we saw the message we saw.

Integer Expressions

Okay, now that you have some understanding of variables and expressions, let's explore those a little bit more by looking at a different data type: the integer.

Integers are whole numbers without the possibility of any decimal places (.NET also has data types which support decimal places, but we will not explore these in this article). In C#, we represent integers with the int keyword, much like we used string to represent some text.

Let's create two integer variables, display them to the screen, and then display the results of adding the two numbers together.

After the existing Console.WriteLine(message); but before the } that indicates the end of the method, add the following code:

            Console.WriteLine();

            // Integer Variables
            int num1 = 4;
            int num2 = 2;

            Console.WriteLine("First Number: " + num1);
            Console.WriteLine("Second Number: " + num2);

            int result = num1 + num2;
            Console.WriteLine("Result: " + result);

When you run, you should see something like this:

Understanding Integer Expressions

Let's look over that new code line by line.

Console.WriteLine(); is similar to code we've seen before, but instead of writing a message, it just adds an empty line to the console. This lets us space out our results so things are a bit more readable.

// Integer Variables is a comment. When C# sees the // characters together, it ignores everything to the right of it on that current line. This lets you write helpful notes while you organize your code.

Combining Expression Types

int num1 = 4;
int num2 = 2;

Here we declare two integer variables named num1 and num2, then assign 4 into the first and 2 into the latter. This is very similar to our message variable earlier, but the syntax is different since we're working with numbers and not text.

Console.WriteLine("First Number: " + num1);
Console.WriteLine("Second Number: " + num2);

Here we're writing out two values to the console. What's different about this is that we're using + to add two things together.

Here we add the string "First Number: " to the current value of num1. When this code runs, num1 is evaluated and replaced with its value, so the line effectively becomes "First Number: " + 4.

C# knows how to add a string and an integer together. It does this by converting the number 4 to a string and then adding it to the end of the first string, so our final expression becomes "First Number: 4".

Adding Integers

Similarly to how we can add integers and strings, we can also add integers together.

int result = num1 + num2; declares a new integer variable named result and sets it equal to the current value of num1 plus the current value of num2.

When this line executes, it is evaluated as int result = 4 + 2; which then combines to int result = 6;.

Important Note: Even if we were to set num2 to some other value after we declared the result variable, result does not change since it only looked at the value of num1 and num2 at the time it was created. This is why we stress current value when looking at expressions.

Next Steps

Now that we have a basic understanding of what variables and expressions are and some familiarity with the string and int data types, we have the groundwork needed to start exploring user input.

All of these things are important as we work towards building our final application: a "guess the number" game.

An Open Letter to Our Bootcamp Grads

Matt Eland — Thu, 13 Aug 2020 15:50:49 +0000

This is an open letter to Cohort 11 of Tech Elevator‘s Columbus Campus. Tech Elevator is a 14 week programming bootcamp teaching .NET or Java, SQL, HTML, CSS, JavaScript, and Vue.js. This particular cohort was the first class I was privileged to teach software development to.

Congratulations, You did it!

As graduates of Tech Elevator, you have completed a very intense 14 week programming bootcamp designed to help you understand and be able to apply fundamental programming concepts on back end API servers, front end websites, and the databases that power them.

First of all, it has been my immense pleasure to teach you and invest in you this past quarter of a year. As an instructor, I do what I do for the pleasure of seeing people move on to achieve great things and continue to learn and grow. Sadly, this means that there is a date that people do move on and I must say goodbye, but I know it is just “goodbye for now”.

Secondly, your journey is not yet done. We teach you as much information as you can reasonably retain (and then a bit more) over 14 weeks, and I firmly believe your education was better than what I got from my own 4 year degree. However, even if I could teach you every single thing I’ve learned from two decades of professional development, technology would have changed significantly by the time we were done going over it.

We teach you programming, but we also teach you how to learn more about programming and how to continue to learn and grow. You will need to continuously keep learning on your job for literally your entire career in development. You may think this is an exaggeration, but every night this past week I have learned something new about JavaScript development over the course of explicitly practicing software development while working on side projects.

Keep Practicing

One of my esteemed colleagues says simply to “code every day”. He’s not wrong. As a new developer, without regular practice your skills will deteriorate and it will become more difficult to remember exact syntax, class names, method signatures, etc. These things do become much harder to forget with regular practice and so I implore you to continue to practice regularly.

I like to try to convey to new developers that programming is fun.

It really is.

It’s hard to convey that in an intense bootcamp where we give you a lot of homework and projects to help you build the muscles you’ll need to succeed as a developer, but the reality is that programming is an act of creating something out of an idea, ingenuity, and determination.

So, pick something fun to build and start building it.

Keep Learning

You’ll find new things to learn and what ways of structuring applications work and what ways don’t. You’ll see what you like and what you don’t and be able to continuously grow your skills until you can take on larger and more complex tasks. And, if you’re looking for some ideas of things to continue to learn, I have a few areas to consider:

C#

LINQ (The syntax with the arrow functions, not the other syntax)
Entity Framework
MVC Razor Views
Async / Await & Task

JavaScript

Vue.js

Vuex Actions and Modules
Routing with Named Views
Vue Watchers

Git

CSS

SASS / SCSS
Bootstrap (Check out the components on the left sidebar)

Closing

There’s so much more out there to learn, and you will feel overwhelmed and like an impostor out there interviewing and on your first, second, third, fourth, and fifth jobs. It gets better over time, but understand that this is normal. We do not expect you to know everything because technology is broad, deep, and continuously expanding. We do expect you to be able to continue to learn and grow.

This message is long already, and so I will close simply by saying that I am so very proud of what you’ve accomplished, I will miss you greatly, and I believe in you – perhaps more than you may believe in yourself at times.

Go and build awesome things.

The post An Open Letter to Our Bootcamp Grads appeared first on Kill All Defects.

How to Build a Game & Learn C#: Self-Paced Workshop - Getting Started

Matt Eland — Fri, 12 Jun 2020 21:17:00 +0000

Overview

In this short series of articles you'll follow step-by-step basics to learn the fundamentals of C# programming by building a "guess the number" game.

This tutorial is intended for people who are interested in learning to code for the first time, but it will also be helpful to those coming to C# from another programming language.

If video learning is more your thing, this content is also available in video form.

The App You'll Build

We'll be building a game in which the player is asked to guess a number between 1 and 100.

Each time the player guesses a number, the game will tell you if your guess is too low or too high. The game will continue to run until you correctly guess the randomly-generated number.

Learning Objectives

Over the course of this series you'll get a glimpse of Tech Elevator's 14 week full-stack C# / JavaScript curriculum and learn:

What C#, .NET, and Visual Studio are
How to Create a New Project in Visual Studio
What variables are and how to create and use them
How to display text to the user and get a response
Expressions and how code works when running
Executing conditional logic with if statements
Doing repetitive logic with loops
Generating random numbers

This specific article covers:

Installing Visual Studio
What C# and .NET are
Creating and Running your first C# program in Visual Studio

Prerequisites

In order to follow along with this article, you need to first download and install Visual Studio on your PC or Mac.

The latest version of Visual Studio is available online, and the Community version is free and perfect for those learning a new language.

NOTE: Make sure you download Visual Studio and not Visual Studio Code as these are two separate products. As of the time of this writing, the latest version of Visual Studio is 2019

When installing Visual Studio, you will be provided with many choices for things to install. In general, the defaults are good, but the important thing for this article is to make sure that .NET desktop development is checked as pictured below:

Introducing C# and .NET

The program we'll be creating today uses the C# programming language. C# is the flagship programming language of Microsoft's .NET development platform.

C# was released in 2001 as a modern object-oriented programming language inspired by C++ and Java. Using C# we can develop mobile, desktop, and web applications.

C# runs on the .NET platform and can talk to code written in other .NET programming languages, such as F# or Visual Basic .NET.

You'll hear the terms .NET Core, .NET Framework, and .NET 5 (and beyond) thrown around. Each one of these is a different version of .NET. This article is written using .NET Core which is the latest version of .NET as of the time of this article. However, these concepts and code translate well to other versions of .NET.

Creating the Application

Open Visual Studio and choose to create a new project.

When prompted, find the Console App (.NET Core) option in the list of projects. Make sure that C# appears in the icon and list of tags as pictured below:

Click Next to continue.

From there, you will be prompted to name your project and select where it should be stored on your machine. The name and location don't matter, but I'm using GuessTheNumber for mine.

Click Create when ready and your project will be created.

If you followed the previous steps, you should now see something like the following if you're running on Windows:

You'll see something like this if you're on a Mac:

Understanding our Program

Let's take a look at the code that Visual Studio generated in more detail:

using System;

namespace GuessTheNumber
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

We start with the using System; statement. using is how C# knows what other pieces of code are going to be needed for this specific file. In this case, we want the System namespace so we can use Console later on in this file.

The next line, namespace GuessTheNumber, contains a namespace with the name of our project in it. This would be used by other code to add using statements to pull in our code. However, in this article we'll only be working with this single file.

The class program declaration and its opening and closing {}'s denotes a class. A class is too complex to get into in an introductory article (we dedicate over a week of curriculum at Tech Elevator to the things you can do with classes).

For now, know that classes can be used to organize related pieces of code. In this case the Program class represents the application we are writing.

Next, we have a particularly frightening static void Main(string[] args) line. This is syntax defining a method named Main that can be run by other code. The main method is a special method that will be run when we run our application.

Later on in programming we use different methods to organize pieces of code and calculate and return values, but for now, think of Main as the thing that will be executed when your program runs.

Finally, we see Console.WriteLine("Hello World!");. This line tells .NET to display a message on the command line when the program is run.

Hello World

Let's run the program now and see how it works.

In order to run your program, click the green arrow in your toolbar as pictured below:

Once you click run, Visual Studio will show some new windows to indicate that it is building your application. This will take a few seconds, but once complete you should see a window appear with the text "Hello World":

Congratulations! You just created and ran your first program.

Next Steps

In the next article, we'll discuss variables and expressions and how .NET evaluates our code when the application runs.

If you're looking for more resources, including videos, articles, and even a learn to code aptitude test, check out Tech Elevator's Learn to Code program.