Geek Spot 101

The IDXGISwapChain

2011-02-06T09:02:00.001-08:00

IDXGISwapChain *g_swapChain = NULL;

Since we will be creating them together lets explain the swap chain. A swap chain is one or more back buffers used to make rendering more smooth. While the device renders one image on your screen the swap chain buffers another image in wait which can be swapped out with the last image. When you think that your game has to process AI, movement, player and enemy health, and more as well as graphics that update 60 times a second you can see why processing the screen image early and often can be useful. It is recommended to have at least 2 buffers.

The ID3D10Device

2011-02-06T09:01:00.000-08:00

ID3D10Device *g_d3dDevice = NULL

Declares an ID3D10Device pointer as NULL. Later when we initialize D3D10 we will actually create it with the function D3D10CreateDeviceAndSwapChain(), but for now this is sufficient. But what exactly is the ID3D10Device? Our d3dDevice will be the access point to the video hardware. All of the methods involved in drawing to the screen and accessing VRAM are handled through this device.

DirectX 10 Programming Tutorial 1.2

2011-02-06T08:35:00.000-08:00

/******************************************************************************
Our first program with DirectX! Let's jump straight into code and then explain what is going on as we go.
If you are just joining me you should start here to get an idea of basic Win32 applications as this code just fits on top of that code.

******************************************************************************/

#include <D3D10.h>

#include <D3DX10.h>

//D3D Global variables

ID3D10Device *g_d3dDevice = NULL;

IDXGISwapChain *g_swapChain = NULL;

ID3D10RenderTargetView *g_renderTargetView = NULL;

//Function Declarations
bool Initialize(HWND hWnd);
void Render();
void ResizeWindow(int width, int height);
void ShutDown();

/***************************************************************************

To save space I've decided to put the definition of each of these on a separate page so click on each new type to go to a description of what each is and why we need it. Now, we have declared our device, swap chain and render target view and have functions to intialize, render, resize and shutdown. I'll start by defining these functions and then we'll go back through our Win32 app code to put them to use.

****************************************************************************/

bool Initialize(HWND hWnd)
{
DXGI_SWAP_CHAIN_DESC scDesc;
ZeroMemory(&scDesc, sizeof(scDesc));

    //We need to define and create the swap chain
    scDesc.BufferCount = 2;
    scDesc.BufferDesc.Width = WINDOW_WIDTH;
    scDesc.BufferDesc.Height = WINDOW_HEIGHT;
    scDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    scDesc.BufferDesc.RefreshRate.Numerator = 60;
    scDesc.BufferDesc.RefreshRate.Denominator = 1;
    scDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    scDesc.OutputWindow = hWnd;
    scDesc.SampleDesc.Count = 1;
    scDesc.SampleDesc.Quality = 0;
    scDesc.Windowed = TRUE;

    //Setup the debug utility for testing
    unsigned int flags = 0;

#ifdef _DEBUG
    flags |= D3D10_CREATE_DEVICE_DEBUG;
#endif

    //Create a loop to test for availability of Reference or Hardware
    //Driver type
    D3D10_DRIVER_TYPE driverType = D3D10_DRIVER_TYPE_NULL;
    D3D10_DRIVER_TYPE driverTypes[] =
    {
        D3D10_DRIVER_TYPE_HARDWARE,
        D3D10_DRIVER_TYPE_REFERENCE,
    };

    HRESULT hr = NULL;

    unsigned int numDriverTypes = sizeof(driverTypes) / sizeof(driverTypes[0]);
    for (unsigned int i = 0; i < numDriverTypes; i++)
    {
        driverType = driverTypes[i];

        hr = D3D10CreateDeviceAndSwapChain(NULL,
            driverType,
            NULL,
            flags,
            D3D10_SDK_VERSION,
            &scDesc,
            &g_swapChain,
            &g_d3dDevice);

        if(SUCCEEDED(hr))
            break;
    }

    if(FAILED(hr))
        return false;

    ID3D10Texture2D *buffer = NULL;
    hr = g_swapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), (LPVOID*)&buffer);

    if(FAILED(hr))
        return false;

    //Create the render target view

    hr = g_d3dDevice->CreateRenderTargetView(buffer, NULL, &g_renderTargetView);

    buffer->Release();

    if(FAILED(hr))
        return false;

    //Set the render target
    g_d3dDevice->OMSetRenderTargets(1, &g_renderTargetView, NULL);

    ResizeWindow(WINDOW_WIDTH, WINDOW_HEIGHT);

    return true;
}

void ResizeWindow(int width, int height)
{
   if(g_d3dDevice == NULL)
       return;

   D3D10_VIEWPORT vp;

   vp.Width = width;
   vp.Height = height;
   vp.MaxDepth = 1.0f;
   vp.MinDepth = 0.0f;
   vp.TopLeftX = 0;
   vp.TopLeftY = 0;

   g_d3dDevice->RSSetViewports(1, &vp);
}
void Render()
{
   float col[4] = { 1, 0, 0, 1 };

   g_d3dDevice->ClearRenderTargetView(g_renderTargetView, col);

   g_swapChain->Present( 0, 0 );
}

void ShutDown()
{
   // Release memory
   if(g_d3dDevice) g_d3dDevice->ClearState();
   if(g_swapChain) g_swapChain->Release();
   if(g_renderTargetView) g_renderTargetView->Release();
   if(g_d3dDevice) g_d3dDevice->Release();
}

/***************************************************************************

The Initialize() function is the longest function so far and it just gets us set up so we can do the fun stuff. Again it's description is posted separately, as well as the resize, render, and shutdown functions. Now we should put our code to use in our window.
****************************************************************************/

//To WndProc() we add:

int height,width;

//In WM_DESTROY... break;

case WM_SIZE:

    height = HIWORD(lParam);

    width = LOWORD(lParam);

    if(height == 0)

        height = 1;

    ResizeWindow(width, height);

//In WinMain()

//Replace old message loop from while(msg.message != WM_QUIT)

//to DispatchMessage(&msg) } } with:

if(Initialize(hWnd))

{

    while(true)

    {

        if(PeekMessage(&msg, 0, 0, 0, PM_REMOVE))

        {

            if(msg.message == WM_QUIT) break;

            TranslateMessage(&msg);

            DispatchMessage(&msg);

        }

        else

        {

            Render();

        }

    }

}

/***************************************************************************
And you're done! When you compile this code you should get a blank window filled with red. You can change this color by changing the values for col in Render() realizing that the values are Red, Green, Blue, and Alpha. Alpha is the opacity and values range from 0 being none to 1 maximum See the wiki article on RGBA for more information.
***************************************************************************/
DirectX 10 Programming Tutorial 1.1

DirectX 10 ProgrammingTutorial 1.1

2011-02-05T18:32:00.000-08:00

DirectX is a collection of APIs(Application Programming Interfaces) that give you advanced control of video, sound, and input on the Windows system. ***NOTE*** DirectX 10 is only available for Windows versions Vista and later. The hardest part of starting with DirectX so far for me has been, well, starting with DirectX. I'll get the code in word for word from some book or tutorial and get a whole slew of errors. I kept thinking it was poor authoring or something but I realized I just did not know how to set DirectX up properly for my IDE. To start out you should go here to download the DirectX10 SDK. Also, so that you can create shaders which will be needed as we progress through DX, I recommend downloading NVIDIA's FX Composer 2.5.

There are a few ways we could start but I like the way Allen Sharrod started in Ultimate Game Programming with DirectX, Second Edition so that is how I will start. But first, let's get VC++ set up for DirectX. If you have your skeleton file created from the last tutorial you should now:

1. Go to Project->Properties->Configuration Properties->VC++ Directories->Include Directories.
2. Select the down arrow and then edit.
3. Click the folder Icon. Click the ... button.
4. Navigate to the folder you installed the DirectX 10 SDK to.
5. Navigate into the folder to the Include folder.
6. Click Select Folder click OK.
7. Repeat steps 1-6 for the Library Directories navigating to the lib/x86 folder.
8. Go to Project->Properties->Configuration Properties->Linker->Input
9. Select Additional Dependencies
10. Select the down arrow, then edit
11. Add "d3d10.lib; d3dx10.lib" not including the quotes.
12. Accept the changes and you are done. You should now be able to start working on our first DirectX Program!

First Win32 application

2011-02-05T17:47:00.000-08:00

/****NOTE****
The following code has been borrowed from many sources which I will try to note as I go through this. This blog is to benefit my learning and if it helps others at the same time, all the better. Each author has their own way they like to code and I have taken things from each which makes the most sense to me. I am not just copy and pasting other people's code, I could just give you a link if I was doing that, but I will not claim anything as to be straight from my own mind either.
****ENDNOTE****

The following is a very basic Windows program using no DirectX to start with. This is the basis, the palette, upon which the rest of the DirectX will lay upon. So to start... Open up Microsoft Visual C++ 2010 Express (click the link to download if you do not have it). When you first open up VC++ there is an option on the front screen to open a New Project, or you can click File->New->Project. You will see a screen like that below.

Click Browse to select the folder you want to put the project in, name your project, and select Empty Project, then OK to begin. You will then have an empty project in front of you that needs a file. Select File->New->File... or <CTRL>+<SHIFT>+<A> . Select ".cpp" as the type and name your .cpp file. I will use "main.cpp" to refer to this file from here on. Before we start coding let's go to Project->Properties->Configuration Properties->General->Character Set and change the character set from "Use Unicode Character Set" to "Use Multi-Byte Character Set".

Let's add some code:*/

#include <Windows.h>

#define CLASS_NAME     "First Window" 

#define WINDOW_NAME    "First Window"

#define WINDOW_WIDTH    800

#define WINDOW_HEIGHT   600

HINSTANCE hInstance = NULL;

HWND hWnd = NULL;

bool InitWindow( HINSTANCE hInstance, int width, int height );

LRESULT CALLBACK WndProc( HWND, UINT, WPARAM, LPARAM );

/*This first part defines some global variables to create this first window. WINDOW_NAME, WINDOW_WIDTH, and WINDOW_HEIGHT are self explanatory. HINSTANCE is a windows type that holds the application instance(the executable module). HWND is a global variable that holds a Windows handle. I'll go more into what this is when we define it in InitWindow() but the handle holds the name, size, and style of the window we are creating.*/

int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE      hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)

{

    // Initialize the window

    if( !InitWindow( hInstance, WINDOW_WIDTH, WINDOW_HEIGHT))

{

        MessageBox(NULL, "Initialization Failed!", "Error!",

            MB_ICONEXCLAMATION | MB_OK);

        return 0;

}

    // Main message loop

    MSG msg = {0};

    while( msg.message != WM_QUIT)

{

        while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) == TRUE)

{

            TranslateMessage(&msg);

            DispatchMessage(&msg);

}

}

    return (int)msg.wParam;

}

/*That code above is what takes the place of the typical C++ main() function.The first thing we do in our main function is initialize our window. We place the function bool InitWindow() call in an if statement which will pop up a message box error and end our program if initialization fails. We then create a MSG handle which we will use to handle messages (mouse clicks, key strokes, etc.). PeekMessage() can be replaced by GetMessage() however PeekMessage() is faster and is recommended in every game programming book I have read so far. Now let's define our InitWindow() function there is a lot that goes into it but it's not as difficult as it looks at first:*/

bool InitWindow( HINSTANCE hInstance, int width, int height )

{

     WNDCLASSEX wncl;

    memset(&wncl, 0,  sizeof(WNDCLASSEX));

    wncl.cbSize = sizeof(WNDCLASSEX);

     wncl.style = CS_HREDRAW | CS_VREDRAW;

    wncl.lpfnWndProc =  WndProc;

    wncl.hInstance = hInstance;

    wncl.hIcon =  LoadIcon(NULL, IDI_APPLICATION);

    wncl.hCursor =  LoadCursor(NULL, IDC_ARROW);

    wncl.lpszClassName = CLASS_NAME;

     wncl.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

     if(!RegisterClassEx(&wncl))

{

         MessageBox(NULL, "Window Class Registration Failed!", "Error!",

         MB_ICONEXCLAMATION | MB_OK);

        return 0;

}

     //Create the window from the class definition above

     hWnd = CreateWindowEx(NULL,

        CLASS_NAME,

         WINDOW_NAME,

        WS_OVERLAPPEDWINDOW,

         CW_USEDEFAULT,

        CW_USEDEFAULT,

         width,

        height,

         NULL,

        NULL,

         hInstance,

        NULL);

     if(!hWnd)

{

        return false;

}

    //Display the window

     ShowWindow(hWnd, SW_SHOW);

    UpdateWindow(hWnd);

     return true;

}

/*A lot of new stuff there, all describing your window from the cursor type to Icons used and the background of your window. The explanation for this I think is better left to another post as this one is already getting lengthy. The process you see here you will begin to get used to using DirectX as you Create and Object-> Define the Object->Register the Object. After defining and registering the window class, we then create a RECT object which is defined by the WINDOW_WIDTH and WINDOW_HEIGHT we input as variables to the InitWindow() function and sent to AdjustWindowRect() to resize the window. We then create the window with the call to CreateWindow()*/

LRESULT CALLBACK WndProc( HWND hWnd, UINT message, 

                          WPARAM wParam, LPARAM lParam )

{

    //Handle Messages

    switch(message)

{

    case WM_KEYDOWN:

        switch(wParam)

{

        case VK_ESCAPE:

            PostQuitMessage(0);

            break;

}

        break; 

    case WM_DESTROY:

        PostQuitMessage(0);

        break;

}

    return DefWindowProc(hWnd, message, wParam, lParam);

}

/*You should be able to copy and paste this entry as a whole into your IDE and compile without any modifications. If you receive an error similar to "Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast ... error C2440: '=' : cannot convert from 'const char [13]' to 'LPCWSTR'" Then you have not set your character set to multi-byte. You can use the TEXT("Your text here") function instead but this is tiresome and unnecessary.

I hope this has helped someone else in creating their first windows application. I recommend this site to get a more in depth understanding of the Win32 application we just created. */

New Direction

2011-02-05T12:17:00.000-08:00

Happy New Year Coders!
I have not posted in a while as school and life have been pretty busy but I'm going to try starting this up again. I would like to change focus, however, to C++ and more specifically game programming and... hopefully... DirectX. I have heard a lot about how DirectX has a steep learning curve and I don't think it will be easy, but I think it is the direction I want to take for now. So, since my last posts I have completed Programming Logic and my first Computer Science class (C++). I will be starting on the second semester of C++ soon on my way to a Computer Science degree. I'm also in Calculus 2 and from what I have seen of DirectX I will need a whole lot more math, so I can't wait to take Differential Equations and Linear Algebra in the coming semesters so I might understand the matrix translations I'll be dealing with in DirectX while programming my games. But that is getting ahead of myself.
The main reason I wanted to start this up again is to help myself and give myself some practice as I am learning DirectX 10 on my own. I am going to try and start from the very beginning using the book Ultimate Game Programming with DirectX, Second Edition as my main guide using Microsoft Visual Studio 2010 .Net Express Edition as my IDE. When I get back I will post begin with getting started on the IDE and setting up a Win32 application.

Rock, Paper, Scissors, Pythons....?

2010-09-21T19:22:00.000-07:00

Here's assignment for Logic turned Python. We were to describe the logic for an easy childhood game and I chose Rock, Paper, Scissors.

import random
choices = ['Rock','Paper','Scissors']
oppChoice=0
playerChoice=0

def rock(oppChoice):
    if oppChoice == 'Rock':
            print("It's a tie!")
    if oppChoice == 'Paper':
            print("You Lose! Paper covers Rock!")
    if oppChoice == 'Scissors':
            print("You Win! Rock smashes Scissors!")

def paper(oppChoice):
    if oppChoice == 'Paper':
            print("It's a tie!")
    if oppChoice == 'Rock':
            print("You Win! Paper covers Rock!")
    if oppChoice == 'Scissors':
            print("You Lose! Scissors cuts Paper!")

def scissors(oppChoice):
    if oppChoice == 'Scissors':
            print("It's a tie!")
    if oppChoice == 'Paper':
            print("You lose! Paper covers Rock!")
    if oppChoice == 'Rock':
            print("You Lose! Rock smashes Scissors!")

def choice(playerChoice,oppChoice):
    if playerChoice==1:
        rock(oppChoice)
    if playerChoice==2:
        paper(oppChoice)
    if playerChoice==3:
        scissors(oppChoice)

def RPSgame():
    oppChoice = random.choice(choices)
    playerChoice = input("Make your selection:\n[1] Rock\n[2] Paper\n[3] Scissors\n...")
    playerChoice=int(playerChoice)
    if playerChoice not in(1,2,3):
        print("Please input 1, 2, or 3 only!")
        RPSgame()
    print('You Chose', choices[playerChoice-1])
    print('Your Opponent Chose...',oppChoice)
    choice(playerChoice,oppChoice)
    playAgain = input("Try again? (Y,N)")
    if playAgain== 'Y' or 'y':
        RPSgame()
    else: return

The first 44 lines are the game's logic, just telling you if you won or lost based on your choice vs. opponent's choice. The "main" code is RPSgame() which, if you ran this code, is all you would have to type to start the game. I tried to account for incorrect input (not using 1,2, or 3 for initial input and disregard for capitalization for "y" to continue playing). The only thing in here we haven't covered thus far on the GeekSpot Blog is the use of lists. I will go into that more in depth later this week when I have more time. In the mean time, I'll leave it at:

Lists are built in brackets: []
Lists are mutable: They can be changed... added to, taken away from...
List elements are numbered starting from 0: choice[0] thus equals Rock.

There is much more to lists, lists can be used for many things and have much potential in your programming. Thanks for stopping by! If anyone has suggestions, comments or concerns about the above code, please feel free to leave a post or shoot me an email.

Defining Functions

2010-09-18T21:07:00.000-07:00

Functions. What are they?

In math you know a function as f(x)=3x+3. substitute any number for x and you get a value. Typically a function is used to define something, such as the rate of change in speed of a car, or a runner. One variable is time, the other is speed. If you plug the value in for one your can get the other, as long as they follow the rules of the function created to define their motion (which for now we are assuming they do). If you wanted to write that same function in Python, and all you wanted it to do is print out the value, you could write:

>>>def function(x):
    print(4*x+2)

Now every time you want to call the function, you only have to type, say...

>>>function(3)
14

The value x in "def function(x)" replaces the x in the indented lines following the defining statement and your function runs, printing 4 * 3 + 2. But the function doesn't have to take a value.

>>def declaration():
print("When in the Course of human events.")

Here the function just prints out what the function is. A benefit to functions is that you can modularize your program. You can break it up into it's basic functions which can then be used over and over again, not only in that program but in others as well. If you create a function that asks for a user name, you can use that in any program that requires the user to input their name.

You can also nest functions. Such as...

>>>def repeat(f):
    f()
    f()

This function takes a function name as it's input and outputs that function twice.

>>repeat(declaration)
When in the Course of human events.
When in the Course of human events.

You may have noticed when you typed repeat( ... a helpful box comes up with (f), reminding you that the function takes f as it's value. But this isn't always helpful. You could instead write a docstring, or documentation string, giving more helpful information to remind you and others what to input here. You do this by placing three double quotes before and after as shown.

>>>def repeat(f):
    """Input a function name here"""
    f()
    f()

This is what it should look like. There are many, many uses for functions in programming. We'll be using functions in most, if not all, of the posts from here on out.

Random Number Game - Python

2010-09-15T20:11:00.000-07:00

In my logic class we were instructed to produce psuedocode for a program that produces a random number 1-10, asks the user to input a number, and outputs both numbers. Here is my version and the python code for it:

Start
Declarations
int randomNumber = random(10)
int guess = 0
output "Guess my number! (1-10)"
input guess
while guess != randomNumber
if guess == randomNumber
output "Good Job!"
else
    output "Sorry you're wrong"
    if guess < randomNumber
      output "Guess too Low. Try again."
    else
      output "Guess too High. Try again."
Stop

The nice thing about Python is that it is not much different than psuedocode, we just have to pay attention to the syntax. The only thing new here from previous posts is the random number generator which you will see below.

#Start
import random    # Necessary to call random later
randomNumber=random.randint(1,10)
guess=0
while guess != randomNumber:
    guess=int(input("Pick a number 1-10: "))
    if guess == randomNumber:
        print("Good Job!")
    else:
        print("Sorry you're wrong.")
        if guess < randomNumber:
            print("Guess too low. Try again.")
        else:print("Guess too high. Try again.")
#Stop

I used random.randint(x,y), x and y being low and high values respectively, to generate my number. You could also have used random.randrange(x,y,z) with x as low value, y as high value, and z being step. For example:

>>random.randrange(0,100,10)
80

The above code generates a random number 0 through 100 at steps of 10 (i.e. 10, 20, 30,...). How would you produce the above "game"?

Finding the 1000th Prime

2010-09-14T15:53:00.000-07:00

I mentioned the other day the homework assignment for MIT OCW Intro to CS course was to find the 1000th square root. Here is a possible solution to the problem:

primeCheck = 5
primeCount = 3
while primeCount <= 1000:
    for divisor in range(2, primeCheck//2+1):
        remainder = primeCheck % divisor
        if remainder == 0:
            break
    else:
        primeCount += 1
    primeCheck += 1
print(primeCheck - 1)

*Note - Thanks go out to Nallo who helped make my original code with clarity.

You can see we've got a few new things here. The while loop on line 3, the for loop in line 4, and a few new uses for our operators. I started explaining everything new here and it became a fairly long explanation I split into two other posts so if you want the explanation you can go there and if you just wanted to see the code you can stop here. We could also have changed 1000 to variable and inserted >>>variable = input("What prime number do you want") in the front to make this code find just about any prime.
The result is 7919 which you can also see here: List of 1000 Primes

Related posts:
Finding the 1000th Prime: Explanation
While Loops
Declaring Variables with Python
Order of Operations

Finding the 1000th Prime: Explanation

2010-09-14T15:52:00.000-07:00

This is the explanation for the code for 1000th prime.
Here's the code again:

primeCheck = 5
primeCount = 3
while primeCount <= 1000:
    for divisor in range(2, primeCheck//2+1):
        remainder = primeCheck % divisor
        if remainder == 0:
            break
    else:
        primeCount += 1
    primeCheck += 1
print(primeCheck - 1)

I started our prime checker with 5 which is the 3rd prime. This is why the variable primeCount is 3, as it is checking for the 3rd prime. If 5 passes the test (which it does) the count will go to 4 and it will search for the fourth one. I'm using the while loop to continually repeat everything below and indented right of the while. The test for primality I have used is checking to see what the remainder is when applying the modulo operator to the possible prime and numbers 2 through half of the possible prime. It is not necessary to go further than this since all numbers above are inherently tested by testing the numbers below half.

The while loop was explained here, so I will move on to the for loop. The for loop is used when you know when you want your loop to end. We have a starting point (here it is 2) and an end (primeCheck//2+1). There are many ways to use a for loop, and the nice thing about it is you do not have to specify a counter (a variable that continually increases with each repetition of the loop, our while loop uses primeCount as the counter), it goes to the end and repeats until the end value is met.

Our end value to our for loop is primeCheck//2+1, which takes the number we are checking, 5 for instance, and does integer division on it ( // ), which gives us 2 rather than 2.5 if we used /. (Unless you are using pre-Python3 which divides based on your type and would also give two unless we changed a value to float).

Our next line is remainder = primeCheck % divisor, which performs modulo division on primeCheck by divisor. What is the modulo operator? The modulo operator is the % sign and it gives you the remainder after division of any two numbers. Here's a few examples to help you understand:

>>>4%2
0

This is because 4/2=2 with no remainder.

>>>5%2
1

Because 5/2=2 with a remainder of 1.
This is why it makes sense to use it in our test, because a prime should not be divisible by a whole number integer evenly. If it does (if x==0) then the number is not prime and break is called which stops the loop there and starts again at the next value. The first 0 remainder we find is proof enough that that number is not a prime.

And that's as simple as it is, our for loop is nested within our while loop, every time the for loop finds another prime the counter for primes goes up and when it meets our requirement of 1000 it stops and prints the value. The reason for the -1 at the end would be because even after if finds the 1000th prime it finishes with the primeCheck+=1 which we have to negate at the end.

1000th Prime = 7919

Here is a list of the first 1000 primes if you want extra validation.
See more interesting Python below:

The While Loop in Python

2010-09-12T08:42:00.000-07:00

The while loop says that while one thing is true, do something. Here we can count to ten:

counter=0
while counter < 11:
print(counter)
counter=counter+1

What did we do here? First we initilized counter as 0, this is where our counter is starting. It is important to initialize the variable you are using in your while loop outside of the loop. After we have initialized counter to 0 we say: While the value of counter is less than 11, do something. In our case, do something is print(counter), which the first time through would be 0, and then we set counter equal to itself plus one.

Our loop will now continue with counter as 1 print one and add 1 to itself. When counter is equal to 10, it goes through one last time, prints 10 adds one to 11 and then passes through the while test again. This time it is not less than 11, because it equals 11 and so it stops. Your output should be:

0
1
2
3
4
5
6
7
8
9
10

We can say this same thing but, in my opinion, make it look nicer. We can do this by making use of multiple operators. The first example will be in line 2, instead of < 11, we can use <=10, which is less than or equal to. A list of such comparison operators is:

<= If left operand is less than or equal to right operand, condition is true.

>= If left operand is greater than or equal to right operand, condition is true

== If left operand is equal to right operand, condition is true.

!= If left operand is not equal to right operand, condition is true.

Notice the difference between the assignment operator = and the conditional operator ==. The first makes one operand equal another, the other tests the equality of the two operands.

The second way we can simplify the program is by using the compound assignment operator +=. In line 4, where we say counter=counter+1, the same thing could be said with the expression, counter+=1. This takes the value of counter, adds one and assigns that value to counter. You can see how this be of use. Here are some more compound assignment operators:

+= Adds left and right operand and assigns total to left operand
-= Subracts right from left operand and assigns total to left operand

*=Multiplies left and right operand and assigns total to left operand
/= Divides right from left operand and assigns total to left operand
**= Takes left operand to the power of the right operand and assigns total to left operand
%= Finds remainder of division between left operand and right operand, and assigns total to left operand.
//= Performs integer division between left and right operand and assigns total to left operand.

Our "improved" code would now be:

counter=0
while counter <= 10:
print(counter)
counter+=1

Order of Operations and Naming Conventions

2010-09-11T14:08:00.000-07:00

Order of Operations

Yesterday we went over operators and operands. Today I'd like to go over Order of Operations. When you were going through elementary or middle school math you may have learned a similar way to remember it and mathematical order of operations is the same here. I learned it as, Please Excuse My Dear Aunt Sally, or Parenthesis, Exponents, Multiplication/Division (both have the same precedence), Addition/Subtraction (so do they). You can also remember, as offered by Thinking Like a Computer Scientist, the acronym PEMDAS. I like mnemonics so the former works better for me. I made it a point to list them in order in the last post.

Here are a few examples. Try to figure out what the results should be. You can also test it (and me) by putting the operation into the Python Shell to see for yourself what it comes out to.

8*1**4 = ?
3-6/3 = ?
(8*2)**4 = ?
12*2/4+4-2 = ?

The first example comes out to... 8! Because 1 exponent 4 is still one, times 8 is still 8. The second example is 1, because we first divide 6 by 3 then subtract the result from 3. Making sense? This next one is the same as the first one but notice the parenthesis. This will now do the parenthesis first, giving us 16 and taking 16 to the exponent 4 which gives us 65536. For the last one we have multiple operations with the same precedence. How will Python evaluate it? The same as you would read it, left to right. It would take 12*2 to get 24, 24/4 to get 6, 6+4 to get 10, and 10-2 to get 8.

We've also gone over variables, but not the naming conventions of them. There are some rules, and there are some style suggestions. Some rules are:

Variable names cannot begin with a number.
All numbers are legal (Just not to begin the variable name)
Variable names cannot contain the character $.
Variable names cannot be a keyword (see list below)
Multiple variabls cannot share the same name.
Variable names are case sensitive. (i.e. name is separate from Name)
Variable names cannot include a space.
Variable name must be on the left side of the assignment operator.

False      class      finally    is         return
None       continue   for        lambda     try
True       def        from       nonlocal   while
and        del        global     not        with
as         elif       if         or         yield
assert     else       import     pass
break      except     in         raise

As for style, there are a few general suggestions. One is to use meaningful names. This helps you when you have to go back to your code later on and interpret it, and it helps others know what is going on. This goes along with leaving comments in your code. Another suggestion is to use _ to break up words in a variable name, such as coffee_made = no. You can also use what is called camel case. Camel case is what I prefer and is when you capitalize the first letter in each word excluding the first and include no spaces, such as coffeeMade = no. According to Wiki, if you capitalize the beginning as well it is known as Pascal case.

Sorry, I like the camel.

Converting Data Types in Python

2010-09-10T21:02:00.000-07:00

If you remember so far we have mentioned three types, int, float, and str. For those who don't remember int is integer and is a whole number integer (3 and 91 for example). Float is floating point and has a decimal value (7.2 or even 9.0) and str is string or a string of characters ("Hello, World" is a string). To convert between types Python allows the following:

Convert to integer:
>>>int("29")
29

>>>x=5
>>>int(x)
5

>>>int(3.14159)
3

Convert to float:
>>>float("3.14159")
3.14159

>>>float 5
5.0

Convert to string:
>>>str(3.14159)
'3.14159'

>>>str(42)
'42'

You can also test to see what type you have. You do this by using the type() function call. Here are some examples.

>>>type('42')
<class 'str'>

>>>type(4.2)
<class 'float'>

As the class I am following online is using an older version of Python I'm trying to keep up with the new rules but I may (will) miss some. I started running them on the new one so I can learn it better and hopefully this will fix the discrepancies I've been having. Here is a site that has a lot of the new changes.

Input and Output in Python

2010-09-10T16:15:00.000-07:00

Computers have three major operations, the sole reason they exist. These are input, processing, and output. If they computer couldn't do one of these it would become practically useless. You input data with every movement of the mouse and every button pressed on the keyboard. The computer processes that data into something, a movement of the cursor, a character typed, and outputs that data to the screen so you can see where the computer thinks the cursor is and what character you typed on the monitor. So far we have placed our variables and their values within the program itself so the user has no interaction with it. They click, it runs. Now let's try building an interactive program.

If you checked out the MIT OCW Introduction to Computer Science and Programming course you may have seen the first homework assignment was to create a program with the following requirements:

Problem 1.
Write a program that does the following in order:
1. Asks the user to enter his/her last name.
2. Asks the user to enter his/her first name.
3. Prints out the user’s first and last names in that order.

Before we start writing code, we can create pseudocode.

Start
input lastName
input firstName
output firstName lastName.
Stop

This would do the job, but how does the user know which name to put first or that you want them to enter a name at all? You can ask them, with:

Start
output "What is your Last Name? "
input lastName
output "What is your First Name? "
input firstName
output firstName lastName
Stop

This is better, but I think we can do even better. Here is the Flowchart and Psuedocode for a simple answer to that problem.

Start
output "What is your Last Name? "
input lastName
output "What is your First Name? "
input firstName
output "Is your name " firstName lastName ?
Stop

And finally in Python:

##This program asks for Last Name, then First Name and then gives
##First and Last name in that order.
lastName = input("What is your Last Name?")
firstName = input("What is your First Name?")
print("Is your name" , firstName , lastName ,"?")

*Note - Apparently raw_input() has been disabled for Python V3.0 (I have updated my code to reflect this).

**Edit** Thanks to bernd-petersohn. Here is his Python3 code:

#!/usr/bin/python3
lastName = input("What is your Last Name? ")
firstName = input("What is your First Name? ")
print("Is your name {0} {1}?".format(firstName, lastName))

We still do not act on our data or have decisions, but you can input some data, the data is saved into variables, and the data is then output for your viewing pleasure. His next assignment gets much more difficult and I'll pose the question to you now to think on it... How would you design a program that finds and outputs the 1000^th prime number?

Operators, Operands, and Hello, World!

2010-09-10T04:14:00.000-07:00

Good morning! I couldn't sleep so I'm going through my Python tutorial before work. This morning we'll talk about manipulating variables. We used operators and operands yesterday, but I did not explain them. Operators are symbols, like + and - that manipulate data. The data being manipulated is the operand. So in the statement:

>>>x*3

We are multiplying the variable x (The value of a variable is substituted prior to evaluation by the computer) by 3. 3 and x are operands and * is the operator. You can remember this easily by remember the operator of a piece of machinery is the person doing the work. In this case the * is doing the work on the two operands. The following are legal operators:

** = exponent/power

* = Multiply

/ = Divide

+ = Plus

- = Minus

Another operator we have used already is the assignment operator or =. Using = assigns the value on the right to the variable on the left. It is similar but different from the equals sign which we will go over later. First let's remember the different types we have gone over (int, float) and let's add another one 'str.' Str, or string, types are strings of characters such as "Hello, World." The "Hello, World" program is a popular first program and so we can use it today to create our first saved program while learning about strings.

First open IDLE (Python GUI). Select File>New Window. A new window with a text editor pops up and here we can write our program.

##This is a Hello, World! program.
##It prints "Hello, World!" on the screen.
print "Hello, World!"

*Note - Remember the # is the comment designator and is not necessary, but a tip for later when writing longer more complex programs is to always include good notes in your program. You can include these comments for your own benefit, put comments of your own or simply start with print.

Select File>Save>> HelloWorld.py (or any name followed by the .py extension) >Save. Now, let's run our program! Do this by selecting Run>Run Module, or pressing F5. If you have made changes it will let you know you need to save it to run it. When you click Run Module a Python Shell will pop up if you didn't have one up already and you should see this:

Hello, World!

You now have a program you can run over and over again as long as you want! It doesn't do a whole lot, but it's all yours. Hope everyone has a great Friday!

Declaring Variables w/ Python

2010-09-09T17:56:00.000-07:00

Hello again! It's Thursday, which is one of my favorite days, if only because it means Friday is almost here! I'd like to end my Thursday with a lesson on variables. Before we get started however I thought it would be a good learning experience, for myself and perhaps others, to do my logic work in psedocode, and actual code (and perhaps a flowchart). For the "real code" I'm going to use Python.

There are a few really good links for help on Python programming. One is from the Python website itself here. As well as from the Introduction to Computer Science and Programming course on MIT's OpenCourseWare (OCW) website. The MIT OCW website has many classes and programs you can go through free of charge and look very interesting. Harvard also has a similar setup here and it looks like they use C whereas MIT is using Python in instruction.

If you want to follow along with me you should go to the Python website and download version 2.7 If you prefer to use 3.0 that's fine but 2.7 is backward and forward compatible whereas 3.0 has gotten rid of some things that I may be using since I'm following the MIT OCW course, recorded in 2008.

Once you've installed Python, bring up the Python Shell also called IDLE (Python GUI) which should look like this:

IDLE (Python GUI) / Python Shell

From here you can input all the commands which I will preface with >>> to look the same as the Python Shell.

Now, onto the lesson: Variables are memory locations, the contents of which may vary throughout the program. For example:

          >>>numberOne = 1 #Hit Return

*Note - # is Python for comment. Meaning, typing it would not hurt, but does nothing for you. I am only letting you know here to hit return to enter 1 as the value for numberOne.

This sets a memory location, nicknamed "numberOne" to the value of 1. To write this in pseudocode you can write it the same "numberOne = 1" since this is a simple statement, or to be more clear:

          set numberOne = 1

Remember I said variables can change. We can now type in the Shell:

          >>>numberOne = numberOne + 1

This may look weird, but it should be simple enough to see what is happening. We are taking numberOne and setting it equal to numberOne + 1, or just adding one to it. If you type:

          >>>print numberOne

You should now get the result: 2.

The last thing I want to mention briefly is the data type of this number:

2

The number 2 is an integer or int, and has no decimal value. In Python, and most other programming languages, this is important. The type is decided when you initialized the variable. To make this make sense try typing 7/2 into the Python Shell and hit return. Notice the answer is not 3.5 but 3! An integer has no decimal value, and your attempt at dividing, which would create a decimal is ignored and it throws out the remainder.

If you are writing a program that requires the decimal values, you can use what is called a floating point or float. To make it a float, just type 7.0 (the .0 part making it float) and divide that by 2. What do you see? 3.5!

Be careful when writing your programs that you keep track of this. There are ways in many programming languages to change the type, but doing so unnecessarily can cause leaks and bugs in your program.

Lastly, a neat trick to see the remainder of the integer division is by using the % sign. Using % divides one side by the other and gives the remainder.

          >>>7%2
          1

Tomorrow I'll try and post something a little more... interesting to program. Until then enjoy the tutorials and let me know what you think!

Integrated Development Envioronments

2010-09-08T20:23:00.000-07:00

When you're first getting into programming you may hear the term integrated development environment (IDE) and wonder: What is it? and Do I need one?

An IDE is a common toolsuite for programming combining all the necessary tools (editor, compiler, and other programming tools)into one. Many will now help you with your programming guessing at what you are going to type and helping you complete it. Microsoft Visual Studio and Eclipse (Along with a whole lot of others) are popular IDEs that support multiple languages.

Some beginning programming books have you learn programming from a text editor, save the file, put it through a compiler (in a command window) and then run your program (as well in the command window). With the IDE all of that can be done with the click of a button. This makes it much easier to debug and test changes in your program.

If you want to get started, how about trying the C++ guide (a free download) from Microsoft's Development for Beginners site. and downloading one of these programs:

Visual Studio can be downloaded by language (VisualBasic, C#, or C++) as a free version here.

Eclipse is a free open-source program available here. It is written primarily in Java and is built by the non-profit Eclipse Foundation. Eclipse is also the development environment suggested by Android for programming Android applications. I've tried some basic programming in both Visual Studio and Eclipse and personally I like Eclipse better. What do you guys think?

Introduction to Pseudocode

2010-09-07T16:39:00.000-07:00

First off, what is pseudocode? It is merely a combination of: pseudo (meaning almost, approaching, or trying to be) and code (the language you are writing in; the set of instructions in a program). It is an informal written representation of your program. In pseudocode you don't need to follow syntax requirements, and really as long as it makes sense to you it doesn't matter how you do it. Here are a few guidelines you can follow however to get the most use out of your pseudocode:

Begin and end your code with terminal statements (i.e. begin,end,start,stop).
Don't use terminal statements if you don't like them.
Use indentation freely to increase readability.
Don't overuse indentation.
Make it make sense to you.

Basically it all boils down to, how do you want to do it? As you learn more about if then, while, do while, statements it becomes more clear what to do. Here is a short example using the same program in my Flowchart introduction.

         start
           input phoneNumber
           call phoneNumber
           if phoneAnswered = no
                 call phoneNumber
         else output "Hello"
       end

Does anyone else have some tips or pointers when using pseudocode?

Flowchart

2010-09-06T14:11:00.000-07:00

Flowchart Example

Here is a simplified example of a flowchart for a program that calls a number for you until someone answers and says "Hello" for you. You'll notice at the beginning and the end there is the racetrack shaped symbol:

Terminal Symbol

This is called the terminal symbol and denotes the beginning and end of a program.

After the terminal symbol you should notice the parallelogram shape:

Input/Ouput Symbol

This is the input/ouput symbol. Anytime a new constant or variable needs to be input or output, use this symbol. Here we use it to input phoneNumber and ouput the phrase "Hello".

Next in the flowchart is the plain rectangle shape:

Processing Symbol

Here is the processing symbol. This is where something is done, input is used, and/or data is manipulated. Here we use it to call the input phoneNumber.

The final shape looks like a diamond:

Decision Symbol

The diamond shape denotes the decision symbol. Here the computer checks to see if a statement is true or false and acts on that truth value as you have determined. Here we have said if the phone is not answered then call again. If it is, then the program finishes by saying "Hello" and ending.

Note: The does not equal could have also been written as !=, <>, or simply "does not equal". This is your preference. Sometimes using does not equal makes it easier to understand what the program, rather than using "= no."

Note 2: Yes and no can be denoted as 1 and 0 respectively.

Structured Programming

2010-09-02T11:53:00.000-07:00

Structured programming states that any program can be created through the use of three procedures: sequence, selection, and repetition.

1. Sequence: One thing happens, then another, then another... Get bowl, Place bowl, fill bowl with 1 cup cereal, put 1/4 cup milk in bowl, scoop cereal, eat cereal. To make this work each process must be done in order, else you may be eating your cereal off of the table.

2. Selection: Selection is the decision portion of your program. If you don't have a bowl in front of you, then grab a bowl. If you have a bowl to put on the table, then put it on the table. If there is no cereal in your bowl, then put cereal in the bowl... by now I'm sure you get the gist.

3. Repetition: Repetition tells the program to do something again and again as needed (or specified by you, the programmer). At the end you can add a selection, if hungry repeat. You already have a bowl, so the program continues to the next step. The bowl is filled (because you have only taken one bite), you continue until you are either no longer hungry or the bowl is empty, in which case the bowl would refill and you would eat until no longer hungry.

Anything else you want to do can be done by placing one or more of these within themselves (i.e. nesting statements) but every programming element is a composition of one or more of these three.

The examples given are not necessarily complete, there are practically an infinite number of steps that could be inserted (breathing between bites, wait time between bites, chewing, swallowing, etc. etc. etc.), but you should have a general understanding of structured programming.

An introduction to Computer Program Design

2010-08-31T17:14:00.000-07:00

The computer program design life cycle is simple, yet probably not something one would think of when first learning programming. Remember, major programming is done in teams of people working to create a product for an end user.

1. Understand:
   -You must understand what is required of you, where the program is going and what your part in all of this is.

2. Plan:
   -Write it down! Whether you use flowcharts or psuedocode you need to have a plan before you start programming.

3. Code:
   -This is where most people want to start, but it is important to follow through with the first steps. This is true in more than just programming. Planning will save you headaches here!

4. Compile:
   - Here is where you use a compiler to translate your code to machine language. If you have followed proper programming protocol (syntax) you now have a working computer program!

5. Test:
   - You thought you were done there??? Not quite yet! Now it's time to test the product, fix any bugs, and if necessary go back through the previous steps until you have a workable bug free (to the greatest extent possible, all sizable programs will have bugs) program.

6. Launch:
   - Your program finally gets an audience. Months of staring at a screen and 4 cases of Red Bull later and you have the satisfaction of watching your program in action. Ahhh yesss....

7. Maintain:
   - If only that were it. Many customers will want support, updates will have to be put out as new bugs are found. This step lasts as long as there is a reasonable need and as long as the program's design is still reasonably usable. As new technology emerges your program may (will) become obsolete and need to be brought into the new generation. And the cycle begins anew...

An introduction to Computer Logic

2010-08-31T16:41:00.000-07:00

Logic is defined as the study of arguments. In logic you are finding the proper way to make a statement that is understandable and is a true statement. A computer program is exactly that, a series of arguments, all with a value of true or false. This makes sense when you think that computer code, binary, is a string of ones and zeros. The computer circuit can read the presence of electrical current as a 1 and absence as a 0. Even the most complex programs can be broken down into strings of true and false.

Learning to Program!

2010-08-31T15:33:00.000-07:00

Computer programming has always been a fascination of mine. A dream always just beyond my reach due (mostly) to laziness. Learning to program takes time, persistence, and many long hours in front of a computer. So lets get into it.

What do you need to begin programming?

First you should have a solid grasp of computer logic and program design. As a beginner programmer most colleges require you take a logic class either before or as you take your first computer science courses. Structured programming takes you through the software development process and helps the programmer design code that can be easily read by himself and others. Why this is important will become clear as we go along. Interestingly, the hardest part is designing the logic, or figuring the "how" of the program. After that you only have to translate that logic into computer language.

Computer language is achieved more simply by using a programming language. Though arcane, programming language is not computer language. Computer language is a series of 1's and 0's or binary bits. Programming languages in human language (or close to it), and are structured to be transformed into computer language by the compiler as long as proper syntax is used. Some programming languages include, Java, C, C++, C#, Python, and many others.