Randy's blog

ESP32 - Trials with setup in Windows 10

2017-07-24T12:35:00.000-04:00

After hearing about the little micro-controller called the ESP32 ("successor" to the ESP8266), I was finally able to get my hands on an ESP-WROOM32. The specs read like an IoT developer's dream - multiple ADC, I2C, I2S, DAC, LED output controller, PWM, touch input, Infrared send/receive, Bluetooth, wifi, built in temperature sensor, low power usage, among many others...and the price is relatively cheap and ranges from $10-20.

One complaint I do have for the board is its size in relation to the breadboards - inserting it into a breadboard leaves one row of pins available on one side and none on the other - pretty much have to straddle across two different breadboards to be useful. I'm using Dupont cables as an alternate, which works well.

Getting this thing running in a Windows 10 development environment, well, that's been the fun part. This is some of the struggles I had and what I had to eventually do to get it working.

Arduino IDE

Using the Arduino IDE, setup wasn't too bad.
I originally had an older version of the Arduino IDE installed, version 1.6. So I upgraded that to the latest (1.8.3 at the time of this writing) and then followed the instructions on adding the ESP32 board to the Arduino board list. This is not as simple as adding the ESP8266 but still wasn't bad. I used a page similar to Installing the esp32 board in arduino ide windows for the instructions on how to set that up. The WifiScan example worked well. The standard LED blink example did not - according to what I've found, it seems the pin # for the onboard LED doesn't exist for the ESP-WROOM32. I added a normal LED, set the pin, and it worked great.

The problem with coding with the Arduino IDE is it's a bit limited, especially when it comes to the ESP32. There are very few libraries out for the ESP32, so that eliminates most of the advanced features of this controller. Bluetooth, DAC, etc cannot be easily programmed within the environment. Wifi works as well as input/output of the pins - all the stuff you can do with the ESP8266. Most everyone online mentioned using the ESP-IDF.

ESP-IDF in Windows

Following the various online how to's on how to set up the Windows environment for using ESP-IDF, including installing MSYS32 (which is basically an embedded Linux like environment btw) did not go well at all. Eventually gave up on it. The use of an embedded pre-setup Linux environment was kinda a big hint that setup is not easy on Windows.

Ubuntu - HyperV

Since I'm running Windows 10 and already had HyperV setup, I tried running Ubuntu 14 in Hyper-V. In general, setup went well but I noticed it was awfully slow. Played around with the settings and found that RemoteFX greatly improved performance of Ubuntu...but, one big catch - I was stuck at 800x600 resolution max. After doing some searching online, people had mentioned to edit one of the files and force a resolution - which did not work. Another mentioned to not use RemoteFX for Ubuntu - well, that worked but now performance wise it was unusable. So, next to try is VirtualBox.

Windows 10 HyperV and VirtualBox

Found out the hard way a year ago that HyperV and VirtualBox do not play nice together on my main PC - start up a VM on either and the host machine reboots without warning. So, had to uninstall HyperV and then install VirtualBox.

Ubuntu - VirtualBox

Ubuntu installed extremely quickly in VirtualBox and performance was also very good so I continued to go down this route. I set it up myself but a good walk thru on how to do this is at http://iot-bits.com/esp32/getting-started-with-esp32-esp-idf-part-1/

USB to serial port issues Ubuntu

The ESP32 worked great in Windows and was at virtual Com3. In Ubuntu, finding which port and getting it setup to work has been a pain. The ESP-WROOM32 has a built in USB to serial converter (if it was a true serial device I do not believe this would be as difficult). By default, USB pass thru is turned off in VirtualBox - change USB settings with the VM off. That was the easy part. Tell the VM to use Silicon Labs C2102 device and my KVM switches devices to a completely different computer or I lose keyboard/mouse entirely on my main machine and have to forcibly reboot (disconnecting/reconnecting does not work).

Outside of those issues, when I do finally see a USB device on the /dev/tty path (in my case, /dev/ttyUSB0), try to connect to it in Putty and I get a dreaded "Unable to open serial port" - ok, is this a "port is not working" or something else? After doing more digging, it seems this may be a permissions issue, not a com port not working type issue. After doing an "ls -l /dev/ttyUSB0" command, I find this is probably the issue. Following the direction from Jesin's blog, I added myself to the dialout group and this seemed to fix the issue. Just remember to log out or the changes do not happen.

ESP-IDF Setup and test in Ubuntu

For setup for the toolset, I used http://iot-bits.com/esp32/getting-started-with-esp32-esp-idf-part-2/ - had no issues with this setup.

For the IDF, I used part 3 of their tutorial, which also works great up to the point of their examples. The most recent version of the IDF (v2) moves "HelloWorld" and "Blink" to a "get-started" directory - you won't see them under examples as the tutorial states. The link to part 3 is http://iot-bits.com/esp32/getting-started-with-esp32-esp-idf-part-3/. For my setup, I did not have to install the flash utility ("make flash" worked just fine) - just remember to not have anything else open (Arduino IDE, Putty, etc) that could already have the port open.

Exceptions and Performance

2016-11-14T18:29:00.000-05:00

First, let me put out this disclaimer - the tests and improvements shown here are a worst case scenario done with "out of bounds" testing. While the tests and solutions here show 4,000x+ performance improvement, this is not a typical real world scenario. The information learned here, though, can help gain significant performance improvements in most typical applications. Don't expect the results shown here in a normal real world application as there are normally a lot of other factors affecting performance other than just one or two pain points.

In a prior post, I discussed the issues with string equality and how to easily increase performance around those areas. Recently I ran into another problematic problem that seems to plague code - the exception.

Exceptions, in languages such as .Net and Java, are there to let the code know when something has happened the code has not accounted for. This could be something such as an attempt to divide by 0, a file missing, or even a network/database connection lost. Exceptions are good things - they allow the programmer to work around the problem. For instance, with a database connection is lost and an exception happens, the program could attempt to reconnect when it receives the exception. Of course, there's an exception to this, there are some exceptions that can't easily be handled in user code, such as out of stack space or out of memory - most languages simply abort the program at the point of these exceptions as it's normally a sign something seriously went wrong. But, exceptions are generally meant to be handled and accounted for, or, if at all possible, avoided entirely as they're extremely slow.

How slow? Here's a comparison of various loops against an exception. For the tests, the tests are executed 5 times with an inner loop that performs a simple calculation 250,000,000 times - yes, I did say 250 million. I used 250 million as the loop count as I'm trying to get to get a baseline of approximately 1 second for the specific tests.

First, though, a walk-thru of the performance test code.

int iterations = 5;

int loopCount = 250000000;

Stopwatch sw = new Stopwatch();

int sum = 0;

for (int k = 0; k < iterations; k++)

{

sw.Start();

for (int j = 0; j < loopCount; j++)

{

//code to test goes here

}

sw.Stop();

System.Console.Write(sw.ElapsedMilliseconds + " ");

sw.Reset();

}

System.Console.WriteLine();

In general, there's nothing really special about this code. It sets up the variables, creates a stopwatch timer (more on that in a second), and then does the loops, with the stopwatch being stopped and reset at the end. The only interesting thing here is the stopwatch timer.

Date/time calculations, such as those done with DateTime.Now.Millisecond, are notorious for not being very accurate - they can vary and are often off by as much as 100ms (on top of DateTime.Now being fairly slow itself). The calculations we need here need to be more accurate. The Stopwatch timer, which is in the System.Diagnostics namespace, is normally very accurate and often to as low as 1ms. Hence, the stopwatch timer is used here for that reason.

Now, back to the timings.

The simplest case is an empty loop that does nothing. The results, for an empty loop, are around 754ms to do the entire loop 250 million times. The exact times I received were:

785 742 769 748 727

Next, let's see what affect a simple calculation will have on this timing. To help prevent the compiler from possibly optimizing the calculation away, we'll put a variable named sum (shown above) on the outside of the loop and print out the calculation of the summation of j*k, through the entire loop, at the end of the loops. Here's the code for this simple calculation.

sum = 0;

for (int k = 0; k < iterations; k++)

{

sw.Start();

for (int j = 0; j < loopCount; j++)

{

sum = sum + j * k;

}

sw.Stop();

System.Console.Write(sw.ElapsedMilliseconds + " ");

sw.Reset();

}

System.Console.WriteLine();

The results for this one, as we'd expect, are slightly higher than the loop with no code - average of around 938ms (so we come very close to the 1-second test I intended). The exact results were:

959 927 911 942 953

Ok, now let's see what affect a conditional has on this - we'll check to see if j (inner loop) is 0, if so, just add k (outer loop) to sum, otherwise do the j*k calculation. The code –

sum = 0;

for (int k = 0; k < iterations; k++)

{

sw.Start();

for (int j = 0; j < loopCount; j++)

{

if (j == 0)

{

sum = sum + k;

}

else

{

sum = sum + j * k;

}

sw.Stop();

System.Console.Write(sw.ElapsedMilliseconds + " ");

sw.Reset();

}

System.Console.WriteLine();

For this one, we have roughly 1324ms of time used for this summation. Almost double the empty loop and a little over 300ms than the prior example. Still, 1.3s for 250 million calculations isn't bad.

Since we're on the topic of conditionals, can we get better speed out of the C# conditional operator (?:)? The code technically should be roughly equivalent to the code above when it converts to IL. So, for this code:

sum = 0;

for (int k = 0; k < iterations; k++)

{

sw.Start();

for (int j = 0; j < loopCount; j++)

{

sum = sum + ((j == 0) ? k : j * k);

}

sw.Stop();

System.Console.Write(sw.ElapsedMilliseconds + " ");

sw.Reset();

}

System.Console.WriteLine();

The results are a bit surprising:

2308 2245 2286 2274 2317

Wait! What? Why? Why is the code above twice as slow as the "equivalent" inline code? Good question but that's one to investigate at a different time since the goal of this comparison is exceptions. The hint on this, though, is to look at the IL that's generated between the two conditional methods. [but, oh, you thought that using the newest way of doing things makes it better and more condensed? Uh, nope - can't assume anything like that - using this is almost twice as slow as the verbose code in these circumstances].

Ok, so now we have our baseline, some simple code, and two ways of doing conditions. Now, to the meat of the matter - how bad is the exception? Let's try with throwing an exception within a try/catch block. The catch block does nothing mainly for the sake of trying to get accurate timing of the performance test.

sum=0;

for (int k = 0; k < iterations; k++)

{

sw.Start();

for (int j = 0; j < loopCount/2000000; j++)

{

try

{

throw new Exception();

}

catch(Exception)

{

}

sw.Stop();

System.Console.Write(sw.ElapsedMilliseconds + " ");

sw.Reset();

}

System.Console.WriteLine();

The results average out to be 1382ms - oh, so just slightly above the one for the conditional then, right? So, why am I even writing this blog to complain about something that's not a problem? Well, look closely at the inner loop - look at the count - loopCount (250 million) DIVIDED BY 2,000,000...yes, a for loop that counts from 0 up to 250,000,000/2,000,000, which means it counts up to 125! Yes, 125...not 100,000, just 125...so 1382ms average for just 125 exceptions! That's roughly 10ms each exception! Nah, exceptions aren't really a problem, they're a disaster! The exact times I received for this run were:

1801 1269 1248 1245 1351

And, yes, 1801 seems a bit of an outlier but really it's right in line with the others at taking 14ms vs 10ms. Either way, it's over 1 second for just 125 exceptions.

Now, I'm doing these tests in debug mode and with any CPU as the configuration. I'm also running these tests within the IDE and with Intelitrace off (Intelitrace only makes things worse, with the worst hit coming to the exceptions test - up to a 3x further performance drop). So, can we get better results when run in x86, x64 or in release modes? Well, let's try:

Debug - x86

***Empty loop***

803 844 770 767 769

***Simple calculation***

901 900 899 903 905

***If conditional with simple calculation***

1248 1241 1241 1234 1234

***Conditional operator with simple calculation***

2215 2185 2196 2207 2206

***Exceptions (scaled down by 2,000,000)***

1100 1075 1070 1101 1086

Debug - x64

***Empty loop***

845 844 818 802 818

***Simple calculation***

1021 1021 1014 1023 1008

***If conditional with simple calculation***

1315 1320 1364 1371 1364

***Conditional operator with simple calculation***

2247 2204 2189 2211 2208

***Exceptions (scaled down by 2,000,000)***

2760 2922 2785 2807 2793

Release - Any CPU

***Empty loop***

136 145 138 131 132

***Simple calculation***

131 132 134 134 150

***If conditional with simple calculation***

277 266 270 271 271

***Conditional operator with simple calculation***

496 515 495 504 495

***Exceptions (scaled down by 2,000,000)***

758 793 762 816 872

Release - x86

***Empty loop***

134 142 146 134 150

***Simple calculation***

135 131 133 145 148

***If conditional with simple calculation***

267 272 258 269 260

***Conditional operator with simple calculation***

500 501 503 500 525

***Exceptions (scaled down by 2,000,000)***

794 781 816 811 763

Release - x64

***Empty loop***

240 224 208 204 203

***Simple calculation***

235 237 227 222 225

***If conditional with simple calculation***

336 332 331 334 339

***Conditional operator with simple calculation***

341 360 380 357 356

***Exceptions (scaled down by 2,000,000)***

1885 1883 1988 1973 2031

Ok, so, in general, if we're doing release mode and x86, we can get it down quite well, to roughly 6x slower than a simple calculation. Worst case performance seems to be on the x64 with almost a 9x performance drop compared to a simple calculation. Now, remember, the exceptions are actually only executing the loop 125 times compared to 250,000,000 for the others, so, in reality, we're talking 6x * 2,000,000 or 12 million times worse for the best case and 9x * 2,000,000 or 18 million times for the worst case. Are you having a performance issue in your application, you're debugging it in the IDE, and the app is throwing a lot of exceptions, and you're wondering why the app is so slow? Well, to quote a famous Myth Buster - "There's your problem!"

So, in the "real world," apps are not run in the IDE - they're started by the OS in various ways (ie command prompt, service/daemon, etc). What affect does the IDE have on exceptions? Well, let's see...same tests, same code:

Debug - x86

***Empty loop***

752 748 746 759 758

***Simple calculation***

887 890 895 890 883

***If conditional with simple calculation***

1213 1209 1202 1205 1186

***Conditional operator with simple calculation***

2162 2241 2164 2155 2162

***Exceptions (scaled down by 2,000,000)***

2 2 2 2 2

2ms for exceptions now? The entire loop ran in 2ms? The fun part here is 2ms for just 125 executions of the loop. Let's drop the scale down a bit and see how it does. For the following runs, I've set the scale to be 4,000, so the exceptions loop runs basically 62,500 times and we get the following results for each of the various build configurations. Remember this is outside the IDE (or also via Ctrl-F5 within the IDE).

Debug - x86

***Empty loop***

768 758 771 764 752

***Simple calculation***

888 901 891 889 890

***If conditional with simple calculation***

1216 1219 1254 1233 1227

***Conditional operator with simple calculation***

2162 2173 2157 2157 2170

***Exceptions (scaled down by 4,000)***

1287 1311 1352 1292 1479

Debug - x64

***Empty loop***

820 803 834 793 791

***Simple calculation***

1010 1018 1026 1014 1042

***If conditional with simple calculation***

1413 1290 1295 1315 1293

***Conditional operator with simple calculation***

2237 2235 2270 2314 2277

***Exceptions (scaled down by 4,000)***

948 949 1011 996 990

Release - x86

***Empty loop***

139 133 135 131 134

***Simple calculation***

131 131 130 135 132

***If conditional with simple calculation***

261 260 263 266 263

***Conditional operator with simple calculation***

504 519 503 514 513

***Exceptions (scaled down by 4,000)***

1407 1392 1446 1407 1358

Release - x64

***Empty loop***

133 141 134 133 152

***Simple calculation***

600 602 596 599 604

***If conditional with simple calculation***

597 603 607 612 592

***Conditional operator with simple calculation***

599 599 591 599 587

***Exceptions (scaled down by 4,000)***

885 901 883 855 931

So, about 500x faster outside the IDE (125x500=62,500). Still, though, at best case we're talking roughly 4,000x slower than the simple calculation itself... Still, a large enough difference to be a fairly major problem when exceptions are being thrown a lot.

Am I saying we should abandon exceptions? No, not at all (sure, abandon them and go back to what - the "on error gosub" of the VB era?). I am saying that we should use them for what they're there for - they were designed to give details about a problem that the code did not account for. They should not be used for control flow to break out of methods nor should they be "allowed" to happen "on their own" without code trying to find and avoid the problem first. The simple answer is exceptions are expensive - guard against them to keep them from happening in the first place, where it is possible and where it makes sense. If the code expects a file to exist, verify the file exists before you try to do something with it - don't assume that because you checked for the file 30 seconds prior that it still exists. Do the checks and guards where it makes sense in the code. If exceptions are extremely rare and should "never" happen, the guard does still cost so use judgment there, but, for things that are possible to happen, definitely try to guard against them to prevent the cost of the exception hit.

Just as an example, let's try a similar test to above but with a guaranteed failure for a certain percentage of the test. We'll do a 0-100% fail rate (for space, the results for only 0-10% will be shown) over a smaller loop count of 2,500,000. The code to do the test and avoid the division by zero exception looks like:

int sum = 0;

System.Console.WriteLine("***J/K summation***");

for (int l = 0; l < 101; l+=1)

{

double remainderValue = loopCount * (1.0 - l / 100.0);

double avg = 0.0;

sum = 0;

for (int k = 0; k < iterations; k++)

{

sw.Start();

for (int j = 0; j < loopCount; j++)

{

if (remainderValue < 0 && (int)remainderValue >j)

{

sum = sum + k * j / Math.Max(0,

(int)remainderValue - j);

}

else

{

sum = sum + k;

}

sw.Stop();

avg = avg + sw.ElapsedMilliseconds;

sw.Reset();

}

System.Console.Write(" " + (int)(avg / iterations) +

" (" + l + "%) ");

}

System.Console.WriteLine();

And the code that allows the exceptions to happen looks like:

System.Console.WriteLine("***J/K summation w/ exceptions***");

for (int l = 0; l < 101; l += 1)

{

double remainderValue = loopCount * (1.0 - l / 100.0);

double avg = 0.0;

sum = 0;

for (int k = 0; k < iterations; k++)

{

sw.Start();

for (int j = 0; j < loopCount; j++)

{

try

{

sum = sum + k * j / Math.Max(0,

(int)remainderValue - j);

}

catch (DivideByZeroException)

{

sum = sum + k;

}

sw.Stop();

avg = avg + sw.ElapsedMilliseconds;

sw.Reset();

}

System.Console.Write(" " + (int)(avg / iterations) +

" (" + l + "%) ");

}

System.Console.WriteLine();

The results, not performed in the IDE, for the first 10% without exceptions looks like:

***J/K summation***

26 (0%) 27 (1%) 25 (2%) 23 (3%) 25 (4%) 24 (5%)

25 (6%) 23 (7%) 32 (8%) 29 (9%) 32 (10%)

And with exceptions, also, not in the IDE, the timing looks like:

***J/K summation w/ exceptions***

28 (0%) 617 (1%) 1227 (2%) 1826 (3%) 2292 (4%) 2708 (5%)

3260 (6%) 3787 (7%) 4154 (8%) 5126 (9%) 5412 (10%)

So, at even 1% of the data failing (25,000 items out of 2,500,000), we're seeing roughly a 30x drop in performance and at 10% fail rate (250,000 items) we're seeing over 150x drop in performance - and this drop is already above the "slower performing" code that has the guard clauses in it to prevent the exceptions.

Hopefully, this makes the point fairly clear - exceptions are expensive, even when compared to adding in guard clauses to help prevent them. Even a small frequency of exceptions can cause substantial performance problems in an application so prevent them when you can.

Storage Pools, Dynamic disks, and software RAID experiences

2013-07-28T16:52:00.000-04:00

A quick disclaimer - I am no where near an expert on Windows Server nor on server equipment. As I have with programming, I'm learning and struggling on my own - best way to learn in my opinion. With that, I know I am not using recommended equipment nor recommended practices so some of this may be my own fault, but, if I'm out there trying to do this, there will be others as well - hopefully this'll help someone out there or help prevent others from wasting as much time as I have on this... But, as with anything else, your experiences may vary and I am not responsible for any data loss - this is what worked for me and may help or it may not.

As with many of us in the digital age, I have a TON of data that I want to keep and ensure it doesn't get corrupted or lost thru equipment failure. In my case, this was over 1TB of WinRar files of personal file backups (from files dating back to 1993), 500GB of pics and videos, among some Tivo files, etc. On top of being a digital pack rat, I also hang onto computer equipment and gather equipment as I come across it. So, two of my prior computers were not being used and I had a ton of spare [i.e. not being used] SATA hard drives so I decided to build two file servers from these pieces.

The first system was based on an Intel 975XBX motherboard. Since I planned on loading this thing with SATA drives, I decided to get a cheap server case and my first choice was the Rosewill RSV-L4500 (http://www.newegg.com/Product/Product.aspx?Item=N82E16811147164). This case is a beast with 15 internal drive bays. The case worked ok except when the drives failed or when I wanted to upgrade drives - having to open it up, find the failed drive (harder than it sounds with no indicator lights on which drive failed), and replace it along with moving the internal fan bar - anyway, it was a pain to replace drives in this case. Good case, keeps the drives cool, but would be easier with hot swap drive bays. In addition to the motherboard, I added 2 4-port SATA controllers but did not necessarily go after those controllers being RAID - I wanted cheap, with good ratings, with 4 SATA II+ ports. One of the controllers, a Koutech IO-PSA420 (http://www.newegg.com/Product/Product.aspx?Item=N82E16816104006) did include RAID support. One of the motherboard's controllers also supported RAID as well.

The second system was based on an Intel 975XBX2 motherboard (very similar to the prior one). Since I learned the lesson on needing hot swap bays, I went after a similar Rosewill case, the RSV-L4411 (http://www.newegg.com/Product/Product.aspx?Item=N82E16811147165). Again, had to get two additional 4-port SATA controllers - same story as before, none were specifically RAID - this time I went after SATA III controllers. I bought two of the Syba SI-PEX40064 controllers (http://www.newegg.com/Product/Product.aspx?Item=N82E16816124064). At least one of the controllers on the motherboard included RAID support.

Now, for the drives - the drives ranged from 60GB drives to 1TB sizes, a few being enterprise level drives, some being notebook drives (1TB ones taken out of new systems in favor of 120GB SSDs - yes, they're that much worth it!). Wide mix of brands and sizes. I had more than enough drives to completely fill both servers - 27 drives total with a total of about 5TB of storage space - all individual drives.

Initially these systems had Windows Server 2012 Essentials loaded on them. While nice and worked (kinda - domain issues with Essentials), I was not fond of the split usage of the drives - a backup share, for instance, was across several drives because the drives didn't have enough concurrent space to hold the entire folder. I looked at resolutions to this - my first discovery was data deduplication, which is a new feature in Windows Server 2012, but, of course, was not available to Essentials. Data deduplication claimed space savings as high as 75% or higher...so in theory a 1TB drive now becomes a 1.75TB drive? I figured it was worth the upgrade risk...

So, after the upgrade, I noticed the feature of storage spaces, which is also new to Windows Server 2012 (and available in Windows 8). I read up on it and essentially it is a software RAID, but with a bit more control. I took all my individual drives, added them to a mirrored pool, and copied data to the pool. While I had a nice big drive, and it seemed to be fairly safe, my transfer rates were horrible - I'm used to 30-60MB/sec transfer rates and I was getting 10mb or less per second, with often minutes at 0mb/sec.
After the failed storage spaces attempt, I tried data deduplication, which, in theory, would help on my space issues. I turned it on for several of my larger drives, ran a power shell command to force it to deduplicate the data and I later found I had 300GB extra on that 500GB drive - nice. I tried moving files and a similar problem happened with storage spaces - remove a 50GB file and I get back 50K of space? Yes, data deduplication worked but with that type of recovery after a delete, I needed to combine drives as I was still having the issue of the split share across drives.

So, now, RAID...something I've tried before but never had good success with but figured worth a shot again. Since I had few hardware RAID controllers, I figured I'd try software RAID - via Disk Management in Computer Management. Software RAID in Windows is done via dynamic disks - the disks can be spanned (JBOD), striped, mirrored, or RAID 5...there is no option for RAID 6, 10, etc.

On the hot swap server, I set up 2 1TB mirrors (on a pair of WD Green 1TB drives, and a pair of Samsung 1TB laptop drives). I moved all my data from my individual drives onto one of the two mirrors (one for the file backups, the other for the pics, etc). The performance was poor, again with lower than expected transfer rates (this is a mirror so I was expecting some slower). I read that RAID-5 and RAID 10 was a better solution for better performance so I decided to go that route.

After over a day of copying, I set up a software RAID 5 array with 3 500GB hard drives. My thoughts were to put the data there and then switch the 2 software mirrored 1TB's to RAID 10.

Performance of the RAID 5 was better than the mirror but still pretty sluggish at times (i.e. KB/sec) - but at other times I was able to get 150MB/sec, which is pretty good compared to what I had been seeing. I did not enable data deduplication on these drives as there was a clear warning to not do that on a dynamic volume - if the dedupe database got corrupted, it was possible to lose all data!

Once all the data was copied onto the RAID 5 array, I rebooted and set up the hardware RAID 10 array using the 4 1TB hard drives.

Upon starting up Windows again, the RAID 10 array showed up as a 2TB drive - as expected. I figured I'd get the data off the RAID 5 onto that single logical drive, but, one major problem - the RAID 5 showed as "failed." The good thing about RAID 5, in theory, is if one drive goes off the array or goes bad, the array can rebuild itself and recover. So, figured I'd reactivate or try to rebuild the array but everything I tried that was suggested on Google and Microsoft, failed. I was not able to get access to the data on the drive or even get the drives to rebuild. I tried switching the drives to a different controller (software RAID and Windows keeps track of the drives that are in the array) but still no luck. I even tried a few suggested software packages that were rated high for recovering data from corrupted RAID 5 volumes and after a week and a half of scanning from products such as Zero Assumption Recovery and ReclaiMe Free RAID Recovery, the most I was able to get valid was 4 50k files and 450MB of very corrupted RAR files. No luck.

Figured I'd pull the RAID 5 drives out, back them up at the sector level, and put them into the other Windows Server to see if I could import the array and get the data that way. During this, I also checked the drives and all were perfectly fine sector wise. But, one of my favorite products for partition/backup of drives, Paragon Hard Disk Manager 12, decided that it would not do a sector backup of any of the drives - never gave a good enough error message to determine why. At this point, I figured I'd already lost the 1TB of data so I was willing to try anything.

I put the failed drives into my other Windows Server and imported the foreign disks. It showed the correct number of drives for the array (3), as expected. I clicked ok and it came up with the size I was expecting as well - about 1TB, but the condition was "data incomplete." Figured, ok, this may work - except the next error message gave me cause for concern - "some of the volumes you are importing will lose data because you have not moved all your disks to this system. Are you sure you want to continue?" Um - WHAT? I imported all the drives! Can't do a sector by sector backup and now Windows tells me this. Did some research online and they said this error message was a bug and that it was "safe" to continue. Figured I'd go with the general crowd sourced info and go for it - clicked ok and now I was right back to where I started with the prior server - the entire RAID 5 showing as "failed." Like on the prior server, tried reactivating the disks (all of which showed as online). Kept getting the "the attempted operation cannot be completed. The selected volume is offline." I eventually found some documentation on the Window's diskpart command (a dos version of computer management, which has a bit more capabilities than computer management). The information it showed showed that everything should have been good and that the drive was ready...but, I still could not repair it (it didn't show it as failed), etc.

Then I came across a similar utility to diskpart that had directory and copy capabilities and was written in C# - all were pluses as I just wanted the data off the drive. The tool is called RAID5Manager and was written by Tal Aloni - (http://iknowu.dnsalias.com/files/public/RAID5Manager/Raid5Manager.htm). I tried the utility and was able to access the array without any issues...and doing a "dir" command, I was able to see directories! Changing to the various directories, I was able to also see the files I expected to see. I figured this was too good to be true so I copied a small file to another drive, opened it up and it worked! Tried a larger RAR file, since RAR has built in consistency checks, and to my surprise WinRar opened the file without complaint! Fun part was the utility only does single copies of files - no wildcards, etc, but, since the utility was written in C#, it wasn't hard for me to add that myself. After about 5 minutes of code changes, I redeployed the updated utility to the server and did a copy and all files went to the backup drive without any issues. I checked many files and all were in tact! This utility saved me from losing 1TB of backup data to a failed data redundancy RAID 5, that, according to diskpart, was not really failed. Not sure why/how this array got in this state (nor how to get it out except blow it away) but this tool helped recover all the data.

So, lesson learned, while I got "lucky" this time and was able to get my data back, ALWAYS backup data in multiple places - even things such as RAID that should recover data in case of failure will fail - the question is just "when." In my case, I believe a Windows Server bug bit me hard on this failed RAID 5 volume but no proof either way.

To sum up my experiences:
1. Storage pools - not a good idea, especially if you'll be moving files or need performance (i.e. media server).
2. Dynamic disks - good concept but RAID-5 seems buggy. Performance was ok but not consistent.
3. Data deduplication - good concept/theory, but do not use on a RAID/dynamic volume! Great returns for data that is rarely used (i.e. backups, archives, etc) but not great for those who move files often (a 50GB file deleted does not mean you get 50GB back - could be very little recovery).

All the suggestions out there always say use hardware RAID, if you need data redundancy, and use RAID compliant drives - which means more money.

Anyway, hope this helps someone out there, especially getting data off a failed dynamic RAID 5 volume that has failed.

New PC Build

2012-08-30T00:01:00.000-04:00

Been a while since I blogged or built a system. Figured I’d try to get back into it again by posting another build entry – this time for my own PC.
This will be my first “from scratch” build for myself in 7 years (AMD 939 system was that one), and about 4 years since I bought a couple used mostly-built systems (both Intel Core 2 Duos). Here’s what I decided on to replace all 3 systems and my thoughts during the build.

First off, the case:
I wanted a case that had tons of drive bays, was easy to install 2.5” SSD’s and included USB 3. There were several cases that fit these requirements but the Rosewell Blackhawk-Ultra really caught my attention. The biggest thing that grabbed my attention was that 8 fans were already included – and the system had capabilities of a total of 15 fans! I knew my new machine was going to run warm so included fans are a big plus as are optional additional fans. Also liked the fact that this case supports motherboards from ATX all the way to HPTX – nice feature especially if I wanted to do a dual or quad CPU system in the future. Also liked the fact that the power supplies can be mounted on top or on bottom – or both (must remove one of the top fans to install on top though). Overall, great case – HUGE and heavy. TONS of room. The case is also very well built.

Case (Rosewell Blackhawk-Ultra)

Clearance after casters added

Bottom of case

Casters on carpet - just enough clearance to move


View of Top Control Cables

View of Back side of case


External Drive "Quick Connect"

This thing is huge - just a bit over 2 ft tall and heavy even empty

Huge case but not as big as I had originally thought. For some reason I was thinking super tower would be a mid-tower (Antec P-180 size) plus the next size down from that in a single case – or, in other words a bit over 3ft. But, this is still pretty big, P-180 + the size of the quad drive cage of the P-180…or, a little less than 25” tall after casters installed. This case is also much deeper than the Antec case…so it does not easily fit on my desk without hanging off. This case also sports a huge 230mm fan - massive compared to the 120's I'm used to. Very quiet fan, nothing like I thought it would be. Low RPM speed as well.
Two Extended 12v power cables included. Would’ve been nice to include ATX motherboard power extension + a full range of extended length SATA/floppy/IDE (ok, scratch that on IDE :)) cables. An added plus would’ve been to include a molex to single multi drive (i.e. 4+ drive) - SATA cable (i.e. like this one - http://www.newegg.com/Product/Product.aspx?Item=N82E16812400127) . This is a pipe dream but would’ve been nice. Doubtful anyone does that, even on a $3k server case.
Fan "hub" - uses one molex to power multiple fans. There are two of these inside the case. Nice but no control over fan speed, etc. Added feature would be to take the fan PWM signal from the MB and amplify it using one of these hubs. Or, at least a fan controller per hub.
Side panel can use 230 or 9 120mm fans. Yes, 9 120mm fans on side panel! Power would be a pain. A hub for that would be nice – that is not included!
230mm fan very quiet but not a ton of airflow.
Casters included. Can be used without casters and still very stable.
3 positions available for each caster. Nice to not be restricted to a specific position.
With casters, case is still stable. Does not add excessive height to the case.
Just enough clearance to clear the carpet without dragging (~.5")
A plastic parts case for screws would be nice (like the Antec P180 series). Instead these are in a plastic bag, all mixed.
Separated screws would be nice - hard to find some – this is just a minor gripe. So many screws look so similar! All are pained black which is a plus as they match the case very well.
Manual included but minimal – sufficient though.
Top or bottom (or both) mounted power supply. If top mount, one of the top fans has to be removed.
All 10 internal drive bays as 3.5 or 2.5 capable. Would be nice to include standoffs, even if just paper ones, for 2.5” drives. Would be very nice to have “hot swap” drive cages.
Red LEDs on the visible external fans aren’t too bad- would be nice to be able to turn them off. The blue power LED is pretty bright though.
Lots of pass-thru areas for hiding cables. Lots of room for small to extremely large motherboards. I think a quad CPU board could easily fit.
Top-mounted controls and cables are more than ample length to reach motherboard. No firewire port on case though. Not a huge deal but worth noting.
Cables are arranged on the back-plate so no hanging cables by "default." These cables go to the top-mounted SATA drive mount, and the front-panel controls.
Fan power cables for the front drives were not protected and are easily caught in the back panel's channels – they really need protection or at least attachments or even channels to keep them in place without them getting caught
Stand off tool - used to take off standoffs instead of using a wrench/pliers – very nice addition. Manual said 2 were included, only got 1. Still, one is enough. Thought it would be easy to hand loosen the existing standoffs, but had to use a screw driver to get them loose. Configuration was not for a standard ATX board but the next larger size. Easy change and they are labeled but I still put the board in the case and verified positions.
Plenty of screws. Way too many at times due to them not being pre-separated.
Suggestion from manual is to bottom-mount the PS with fan down. Warning is to keep the bottom dust-filter clean or the PS may burn out early. Agree with what others said on Newegg/Amazon. If we should keep dust out of that area, make the filter washable and accessible from the front. Decided to still go ahead and point PS fan down.
Velcro strap - ??? Can't be to hold PS in place (not long enough). Had to undo caster to get it unstrapped. Still unsure of its function.
Bottom of case and where the power supply attaches to the case have rubber pads to keep PS vibration down - nice addition.
Top mounted SATA drive port – looks like only designed for 2.5” drives – opening not large enough for 3.5” drives. Manual does not state either if this is a SATA II or SATA III compatible port.

Next, the power supply:
I wanted a power supply that was modular (to keep air flow going), decent efficiency rating, and powerful enough to run an 8-core AMD system. Did the NewEgg power supply calculator and it stated I needed a minimum of 300w power supply. I know from experience that 300w won’t get you much in terms of tons of extra hard drives – so I doubled that just to be safe. Should have plenty of additional power if needed. Currently with the configuration shown here, it uses ~150w “normal/idle” use.

Power Supply (Coolmax ZU-600B )

140mm Fan w/ view of non-modular plugs

Modular plugs included

View of modular cable ports

Installed in case

600w - more than enough for what I plan to run initially. Extra traditional SATA drives may push it over its limit but at ~20w (or less) each, should be plenty even for a full case of drives.
This is a partial modular power supply - has cables for almost every system now (motherboard power + 4, 2 molex, 2 SATA, 1 8-pin PCI-Express power). Modular cables are for 3 extra SATA, 1 6-pin PCI-express (video card), 1 6 or 8-pin PCI-express (video card), and last modular is for 1 floppy and 3 additional molex. Found out the molex connectors aren’t exactly “standard” and wouldn’t work with the side fan’s connector. Molex worked in all other areas though.
Manual is online - not a big deal, just interesting.
No screws included - not big deal. Case came with plenty. But, that’s one thing I’ve come to expect over the years, even with “cheap” power supplies.
Power supplies and their cables are not designed for cases of this size. Just due to cable length, had to use the molex modular cable just for the fans since one fan panel is at top, one is near bottom.
Routing the power cables takes some thought with this case.

Have a case and power, now need storage space:
Being stuck at SATA II drives (and on the AMD, IDE drives), I wanted to try out all the new technology – from SSD to traditional SATA III. Went with a Blu-ray burner as well.
Drives

All 3 drives installed

Drive tray with 3.5 and 2.5 options

Mounted the drives in reverse of what I would normally think - power and SATA cables towards the back side of the case. A PAIN if you upgrade or add/change drives often to have to remove BOTH front and back panels. Oh well. Really would be nice to have a RAID-like or hot-swap bays. I did not check to see if the drive cages could be installed “backwards” so that you’d only have to take off the back panel when adding/upgrading a drive.
Decided to put a bit of space between the standard drive and the SSDs - heat has always been an issue with normal drives...even with the fans, I'm a bit cautious.

SSD (SAMSUNG 830 Series 2.5-Inch 128GB SATA III MLC Internal Solid State Drive (SSD) MZ-7PC128B/WW )

Wow, this thing is tiny - at first thought it was sample blank Blue-Ray discs. Totally sealed so no exposed circuitry. Surprised by the 1.5A power requirement (~8w) though - seems high.
Felt like I was going to break the power connector on both 2.5” drives – seems a bit flimsy compared to the 3.5” ones.
Boy is this drive fast! Never seen anything this fast! I was able to install Windows 7 Ultimate from DVD to this drive fully in ~13 minutes – with ~2 minutes of that being from the install wizard itself and human speed. Like a former co-worker told me, I will not want to go back to traditional drives after being on this drive!

Blue-ray (LG Electronics 14x Internal BDXL Blu-Ray Rewriter with Software WH14NS40 )

Drive itself

Exterior faceplate removed - after much coaxing

Empty drive bay - no steel plate, thankfully

Installed drive

Surprising - no manual, no sample disks – it is an OEM so not really expecting it. SATA cable and Molex to SATA power adapter though and software CD/DVD were included.
One of the things I always hate about installing external drives is the plate that normally shields that area. Rosewell was nice for the topmost drive and didn't install the steel plate - but the nice "shield" that covers the hole was a PAIN to get out. I did not remove the front panel of the case (come on, installing one drive here, not redoing everything front facing). Had to take a flat head and pliers to get it out after a bit of hammering on it with the flathead. Not easy - had much easier. Like another reviewer said, that ain't going back on there.
The "quick install" drive feature on the one side of the case is nice – very easy to do...other side, if you want the drive "stable" requires screws. The quick install feature is nice, but, um, I'd rather have this on the drives I'll change often such as the 3.5/2.5" ones - am not going to fight the case to do another external drive. Nice feature but not worth the money IMO.

Hybrid (Seagate Momentus XT 500 GB 2.5 Inch Solid State Hybrid Drive ST95005620AS )

Hybrid drive with paper spacers

Tiny little thing - about what I'd expect for a laptop drive (1.8/2.5"). Very nervous about putting this in the drive cage as is as there's very little separation between the exposed underside of the circuit board and the metal cage. Drive really needs a spacer of some sort. But, I guess it's meant as a laptop drive, not to be put in a desktop case. Found some old paper spacers from the age of the 486's - put those between the cage and the drive to add a micron more space. Rather not see a drive or power supply go up in smoke. Drive seems to be fine and works without issue. Have not tested speed yet but the hybrid is meant to store commonly used files in SSD and the rest on magnetic. With the SSD being master, not going to be easy to test raw performance of that.

SATA III (Western Digital 1 TB WD Blue SATA III 7200 RPM 64 MB Cache Bulk/OEM Desktop Hard Drive )

Now this is what I'm used to. SATA III 1TB WD Blue. Nothing at all new here other than SATA III. Drive installed fine.

Cooling:
Since I’m running an AMD processor and since it’s also 8-core and meant for overclocking, I decided to go water-cooled – also, a first for me. After reading many reviews, decided on the Thermaltake Water2.0 Pro. So far it’s keeping the stock-parameter AMD 8-core, when idle, at 32C – have seen it go as high as 48C under load. Not bad, especially when my Intel Core 2 Duo systems were sitting around 55C+. Prefer to keep temps below 40C – running a computer, not a stove :)

Water cooler (Thermaltake Water 2.0 PRO/All In One Liquid Cooling System CLW0216 )

Water cooler radiator and 2 fans

Parts for Intel or AMD

Pump itself (with installed brackets for AMD) showing thermal paste

Back of Motherboard with installed cooler plate

Water cooler installed

Another view of water cooler

Another view - notice the room in this case vs the motherboard

About what I expect for a after-market/non-stock air cooler. Misc parts for Intel/AMD, fans, radiator (i.e. heatsink), etc. So far so good...and one plus, no leaks in the box [blaming UPS, not mfg's/NewEgg] :) A plus - a manual :)
No thermal paste included though it appears to be some on the pump itself. Time to read the manual to make sure. And, yep, first page of the manual suggests "read this manual thoroughly and follow all steps in order"...hmm. Ok, first off it's install pump – but this is hard to do without a motherboard installed...
I do feel like I'm working on a car with this radiator though. Not huge, but still.
Instructions are not completely clear for first time water-cooler installers - backplate for CPU, does that come off or no? I voted for yes – and it is required to take that off first. Manual said read carefully and follow directions in order and that was one of a few steps they left out.
After getting the cooler installed (pain, btw) [but probably normal for users who're used to doing after-market air coolers - I'm not, been 4 yrs!]. And, yes, the thermal paste is on the pump - pretty clearly stated don't touch it in the manual. I did not add additional thermal paste.
Cooler is QUIET and so are the fans. Would like a bit more control over the cooler. Believe the next step from ThermalTake has that feature.

Now for the motherboard, CPU, RAM, and video card, then back to the cooler:
I really like all of Asus’ products – from their Netbooks to their tablets to their motherboards. Haven’t had a single problems with any Asus equipment I own or have built for others. Great company in terms of quality!
For the motherboard, one requirement I had was Firewire. Asus has 3 990-based boards (the 990 chipset was also one of my requirements). One of my requirements was a Firewire port – of which the Sabertooth has and so foes the M5A99X EVO. I liked the 3 PCI-express slots on the Sabertooth
Motherboard (Asus Sabertooth 990FX) and also the thermal radar, military spec components, etc. Extra USB 2 ports was also a nice feature.

Motherboard (ASUS Sabertooth 990FX TUF Series Motherboard AM3+ DDR3 1800 - 990FX )

Quick-connect headers

5 year warranty and cert of reliability

Various components included

Wow, tons of room in this case!

Installed motherboard

Motherboard install was pretty standard.
Motherboard set inside the case really shows how HUGE this case is.
Was surprised that only one side of the memory release levers went down – the other is fixed and doesn’t move. New feature to me.

CPU (AMD FX-8150 FX 8-Core Black Edition Processor Socket AM3+ - FD8150FRGUBOX )

Nice TIN box, not the cardboard ones I'm used to. Easy install - nothing new here.

Memory (G.SKILL Ripjaws X Series 32GB (4 x 8GB) 240-Pin SDRAM DDR3 1600 (PC3 12800) Desktop Memory F3-12800CL10Q-32GBXL )

Well, these were a pain - the plastic case was difficult to get the chips out. Got them out but prefer an "easier" container. Same old same old here.

Video card (GIGABYTE GV-R667D3-1GI Radeon HD 6670 1GB DDR3 DVI-D / D-Sub / HDMI CrossFire Ready Graphics Card )

Nice fan/heatsink on video card

Video card has a fairly nice heatsink and fan. The fan is pretty quiet.
Did not see a Crossfire port. From what I’ve read elsewhere, it uses “hyper-crossfire.”
One HDMI, one SVGA, one DVI port.
Performance is decent.
Actually have a 2nd video card coming – nice to have quad monitors and also experience crossfire (while it existed on prior builds, I never used it – didn’t see the sense as I don’t do a ton of high-performance gaming).

Final comments on case, water cooler, and power supply:
Case and PS

Additional comment on the 230mm fan and PS - the molex connector on the PS did not fit the molex for the fan - bit of a annoyance. Had plenty of motherboard connectors...but, the side panel fan is now relatively closely tied to the case. Oh well...
Did think I was going to have a problem with the 230mm fan and the water cooler - seems to be a good fit after all. At first thought the water cooler was in the way of the fan, but that is not so.

Water Cooler

Water cooler radiator as installed is opposite of what the book recommends - the tubes were just too close to comfort for me to the power regulators (which have heatsinks, which means they will get warm/hot) and the bends were a little too tight. Fits fine with the tubes towards the outside of the case.
Also, did not use the included Y connector - motherboard has plenty of fan connectors. One thing did concern me on the Y - one connector looked like it was missing a pin (and wire), the other had all 4 - book did not say which fan/pump should go where. Both fans and pump are on motherboard fan connectors. Cools pretty well as is so leaving alone for now.

Conclusion
About 4 hrs total to put together but was taking my time and documenting as I went. Everything worked first try. Win 7 installed in 13 minutes from a DVD. SSD card is handling Win 7, Visual Studio 2010 Ultimate and 2012 Ultimate, Office 2013, and SQL Server 2012. Still has plenty of room left. System goes from login screen to ready to use in ~2 seconds.
So far, it's extremely difficuly to get the SSD drive to get to100% usage - I can usually easily do this with a traditional drive. Drive rarely gets above 10% usage.
CPU also stays pretty low - usually around 20% total.
Motherboard's BIOS is nice - allows for easy overclocking. I haven't done so yet. The BIOS has a setting that allows the system to be overclocked into turbo mode, which is 4.2Ghz instead of the 3.6Ghz. Can't tell the difference either way.

Windows 7 Experience Index with stock settings:
Processor - 7.7
Memory - 7.7
Graphics - 6.8 (overclocked slightly for a 6.9)
Gaming Graphics - 6.8 (overclocked slightly for a 6.9)
Hard Drive - 7.9

UPDATES
Ordered a second ATI 6670 card with the goal to crossfire the cards and to get a quad-monitor system going. While in the case to add the card, I noticed the power supply itself was fairly warm so I removed the dust filter from the bottom of the case (it is relatively easy to remove - but would be a pain to do more than just a couple times). That should help open up the bottom of the case and allow more air into the power supply. I'd thought about flipping the power supply but the motherboard power cables are already pretty tight - will try it this way first for a while.

Also moved some of the fans to be motherboard-driven instead of off the fan hub. Should allow me to keep better control of the areas that don't have fans on them (such as the vcore's). They and the PCI-Express cards seem to run a bit hotter than I'd prefer. So far the moving of the fans to the motherboard along with adjusting the fan speeds seems to have dropped those temps down by 6C.

Unlike what I understood, the ATI 6670 card can not be crossfired as normal cards can (via the bridge) - there is no bridge connector on the cards! From what I've read elsewhere, they're "hyper" crossfired via the PCI-Express bus. The ATI software did allow me to enable crossfire but doing Windows experience testing did not show any improvement so not sure if it didn't work at all or just not seeing any gain. Even with 2 cards in the system (with crossfire on or off), the video performance stayed at 6.9. Have seen other reports that say the ATI 6670 cards aren't worth crossfiring as a single 6870 series card is faster than the dual ATI 6670's would've been and is actually cheaper total cost. Not in it for the graphics/gaming so not too concerned about it for now. Little disappointed but, oh well, crossfire is a feature I won't use much anyway. But, good news is that an additional video card only rose the wattage requirements of the system by 25W idle (from ~125W to ~150W) [as per the reading from my UPS]. With all 4 monitors running, total power draw sits around 300W total - course the monitors are adding 150w from the mains, not from the power supply. Really nice to have a quad monitor system and a system that has lower power draw than my prior system.

And the Asus motherboard, well, it seems Asus has relased version 2 of that motherboard with new features. Some neat features (i.e. single button to enter bios, etc) but sure it's not worth taking apart the entire system, and paying the extra for the newer board. Will stay with what I have.

Trial and Error–WCF Services Part 3 (split to IIS Hosting)

2011-07-23T21:59:00.001-04:00

After a bit of frustration with the WCF host and client, I decided it would be easier to split the client and service host projects. I did this, relatively easily but now the problem was getting the host to start first and then the client…and having the host start when doing work on the WCF service itself and keeping the client reference updated. Well, simply put, it was going to be a big pain (having 2 VS 2010’s open isn’t bad…but starting up the host every time I wanted to test or make a change would have been). I’ve also been considering having a web host to host these services – and the thing with most hosting providers, they don’t allow Windows services nor console/windows applications (and I wasn’t going to pay $45+/mo to have a hosted virtual server) so my only route was having the service hosting in IIS. Since most providers that allow WCF are running Windows 2008 or 2008 R2, this meant IIS 7 or 7.5, which means it’s compatible with my development environments within Windows 7, thankfully.

So, the client is now in it’s own solution. The client in this case is only for testing – the real client will be in the app. The client is “easy” to create as long as VS 2010 can get a service reference – with the client and host in one solution, that was becoming a pain. With IIS hosting, that pain should go away.

The service solution had a dll that contained the real “service” (the service contract and an implementation of that contract) and a console host. I’ve added a new WCF Windows Service project as described in the blog post (http://blog.lyalin.com/2008/04/creating-quick-sample-iis-hosted-wcf.html). Although this blog describes VS 2008, it applies to VS 2010 without any changes. I tried to cheat and extend my service library dll service class (with changing the SVC code behind as well) but, alas, when I browsed to the service, it basically told me that the ServiceContract cannot be inherited. So, to avoid that fight, I copied my library code into the new IIS hosted service project and removed the old library – I didn’t see a use for the old library outside of various hosting methods or for debugging…ah, debugging – hard to debug an IIS service with console write’s so I decided to keep the old console host so that I could see what was going on in the service though console writes (yes, archaic, I know – but works). I added a normal reference to the new Library dll in the host console application – no other code needed to be changed.

Now my hosting/service solution looks like this:

To publish the service to IIS, be sure to follow the instructions in the mentioned blog as VS will host it by default if those aren’t followed. Then right click on the WCF project and click Publish. A dialog box similar to the following should appear. For my settings, I set the service URL to my local machine and the site/application to one of the similar examples shown (eg Default Web Site/MyApp). Since this is a WCF service, I set the “Mark as IIS Application” and left everything else default.

After a successful publish, VS appears to update the Web.config file so it may ask if you want to update the file to the most recent changes.

To make sure everything works as expected, right click on the service file [yes, service file, not the project], then go to View In Browser. The familiar “You have created a service.” should appear. If not, check the Web config of the service and make sure the following line is set. VS 2010 creates the web config file and, by default, sets this to true for you.

<serviceMetadata httpGetEnabled="true"/>

Now, if we start the project, we should see the console host, as normal, which, according to it’s app config file will be using port 8000 instead of the IIS default of port 80. So, in the client, this will need to be changed accordingly depending on whether we want the IIS version or the console hosted version. For proof the host still works:

And with the client making a call against the console host

Unfortunately no easy way to tell if the IIS hosted version is working as expected (other than the fact it is using the exact same code, just a different hosting method). The easy way to check communication is to change the app config of the client to point to port 80.

Run the client again and we get:

Hmm…EndpointNotFoundException – but why? Well, let’s look at the service again in IIS – viewing the service in the browser we get and address of http://localhost/ExpressRecipeWCFLibrary/UserService.svc. But if we look at the client app config file we have:

http://localhost/UserService

Ok, two problems – application name we set when we published is showing in the URL and so is the .svc. Setting the app config service location fixes the problem, but, debugging with the console hosting app now goes away until it’s changed back. (just for curiosity sake, I tried to publish without the application name and my VS crashed…so, probably not a good way to get around this issue). Haven’t tried yet, but defining an endpoint for each the console and IIS host may be an option (an option which would have to be repeated for n services – could easily get nasty)… A workaround is to set the console base address to be that of the IIS service address, just be sure to change the port number – seems to work for this case. This may need a more elegant solution soon, maybe modifying the port or endpoint based on if it’s in DEBUG or just a normal build…anyway, something else to think about.

Trial and Error–WCF Services Part 2

2011-07-16T23:16:00.001-04:00

As promised in my last WCF post, in this post I’ll create the client that connects to the WCF service host that was created earlier. Since the host is pretty simple at this point, so will the client and test be.

First things first, I need to create a project that’ll use the client – figured it would be easiest to do that in the same solution as the host. So, I added a new project called ExpressRecipeServiceClient (technically this is poorly named as the client/proxy will be generated elsewhere).

Ok, so far so good – now to add the WCF reference, which in turn will generate the client/proxy code. So, at the client project, I right click, go down to Add Service Reference. Easy enough so far and is mostly the same as adding a project reference. The Add Service Reference dialog comes up and I click Discover – thinking VS would see I have a WCF host. Nope – nothing happens. Ok, so I go back to the book and it says I need to manually start the host project without using debug…ok, try literally exactly that, start the host solution using Run, not Debug but I run into the problem of not being able to add any new references to any project that way. I finally realize it means run it at the command line…so, I navigate over to the bin directory of the project and start the host there…host appears happy so I go back to VS and try to add the service through discover…still nothing. So, I try making sure the service host is running by accessing the WSDL through IE – yep, works as it did. I noticed on t e WSDL description that it says to use this URL to create a proxy – in my case, http://localhost:8000/UserService/?wsdl. I put that in where it asks for address, then press go. And, guess what, it appears to have worked.

Great…now, set the namepace something useful (ExpressRecipeService in my case) and then click ok (ignoring the advanced options – for now). A new reference will appear under Service Reference with the namespace that was provided earlier.

Now for the test. I still have the WCF host running from the command line. In the newly created client project, I make a call similar to this

ExpressRecipeClient.cs
 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace ExpressRecipeServiceClient
{
    class Program
    {
        static void Main(string[] args)
        {
            ExpressRecipeService.ExpressRecipeUserContractClient client = new ExpressRecipeService.ExpressRecipeUserContractClient();
            client.AddUser("test1", "test2", "test3", "test4");
        }
    }
}
 

Basically, create a new client for the host and call the only user-generated procedure, AddUser, with fake test parameters. My expectation is that those will be printed out on the host console screen. Guess it’s time to run, so F5.

Oops…”HTTP could not register URL http://+:8000/UserService/. Another application has already registered this URL with HTTP.SYS.” Guess we should kill the console running host and try again. Basically the error means something else is using that transport at that same port.

Kill the console host, then F5 again and here’s what I see from the host screen…well, nothing new – client never comes up but host does. Gotta make the solution start multiple projects so set the host to start first, then set the client to start. Run again and I get:

Ok, that wasn’t goo bad…going to need to do a bit more complicated things in the host but so far so good.

Factories in C#-Basic, Cached, and Dynamic

2011-07-16T19:23:00.001-04:00

Introduction

It seems that one of the more common operations in modern object orientated languages is creating new objects. In most languages, this is accomplished by using the “new” operator…this is nothing new for most of us out there who’ve been doing OO programming for any length of time. For those who haven’t been, here’s the general idea – we have a class we want to create and use (let’s say a “Dog”) in our main program. Here’s the Dog class:

Dog.cs
 public class Dog  
{  
    protected string AnimalType { get; private set; }  
  
    public Dog()  
    {  
        AnimalType="Dog";  
    }  
  
    public void IntroduceSelf()  
    {  
        System.Console.WriteLine(IntroductionLine);  
        System.Console.WriteLine(Speak);  
        System.Console.WriteLine();  
    }  
  
    protected string IntroductionLine  
    {  
        get  
        {  
            string introLine = "Hello, I am a " + AnimalType;  
            return introLine;  
        }  
    }  
  
    protected string Speak  
    {  
        get  
        {  
            return "Woof";  
        }  
    }  
} 

And to create a new Dog we do this in our main program:

Program.cs
 class Program  
{  
    static void Main(string[] args)  
    {  
        Dog dog = new Dog();  
        dog.IntroduceSelf();  
  
        System.Console.WriteLine("Press <enter> to end");  
        Console.ReadLine();  
    }  
} 

Ok, simple enough, right?

Well, let’s say the requirements expand and we now need to create a cat and a dog. [ok, now, you ol fogies – I know you already know this…just skim down if you’re bored]. So, we create a new class named Cat that does pretty much the same thing as the Dog class did, with obvious exceptions. [At this point, if you’re an OO programmer, alarm bells should be going off in your head – Cat class does pretty much the same thing as the Dog class].

So, here’s the Cat class -

Cat.cs
 public class Cat
    {
        protected string AnimalType { get; private set; }
 
        public Cat()
        {
            AnimalType = "Cat";
        }
 
        public void IntroduceSelf()
        {
            System.Console.WriteLine(IntroductionLine);
            System.Console.WriteLine(Speak);
            System.Console.WriteLine();
        }
 
        protected string IntroductionLine
        {
            get
            {
                string introLine = "Hello, I am a " + AnimalType;
                return introLine;
            }
        }
 
        protected string Speak
        {
            get
            {
                return "Meow";
            }
        }
    }
 

And our main program to create a dog and cat looks like this:

Program.cs
 class Program
    {
        static void Main(string[] args)
        {
            Dog dog = new Dog();
            dog.IntroduceSelf();
 
            Cat cat = new Cat();
            cat.IntroduceSelf();
 
            System.Console.WriteLine("Press <enter> to end");
            Console.ReadLine();
        }
    }
 

Ok, not bad…and we solved the requirements…but, look at all that duplicated code…what if the requirements change again (and, believe me, they will)? What if we added 50 animal types and then we found a bug that was common in all that code…50 classes would have to change to fix that bug. What’s the answer? Using the OO concept of inheritance.

Brief Overview of Inheritance (as it pertains to Factories)

One of the key features of inheritance is the ability to reuse code from a class higher up the inheritance chain (such as a parent or grandparent [or from a base class in C# terms]). This reused code can be in the form of functions/procedures, data members, or properties (I’m specifically referring to class inheritance here, not inheritance via interfaces). So, what does this have to do with factories and creation of objects – inheritance is a prerequisite to getting a factory to work for object creation. So, let’s go ahead and use inheritance and get rid of some of this duplicated code…and, while we’re at it, let’s create a new animal class for a pig.

We’ll start with an abstract base class. We really don’t want to be creating an animal by itself and there are some things the animals themselves will know how to do that this base animal class won’t (i.e. how to speak).

AbstractAnimalBase.cs
 public abstract class AbstractAnimalBase
    {
        protected string AnimalType { get; private set; }
 
        public AbstractAnimalBase(string type)
        {
            AnimalType = type;
        }
 
        public void IntroduceSelf()
        {
            System.Console.WriteLine(IntroductionLine);
            System.Console.WriteLine(Speak);
            System.Console.WriteLine();
        }
 
        protected virtual string IntroductionLine
        {
            get
            {
                string introLine = "Hello, I am a " + AnimalType;
                return introLine;
            }
        }
 
        protected abstract string Speak
        {
            get;
        }
    }
 

Ok, now for the dog, cat, and pig classes that will use this base class. Take a look at how much shorter these are than the original version that didn’t use inheritance.

Dog.cs
 public class Dog : AbstractAnimalBase
    {
        public Dog()
            : base("Dog")
        {
        }
 
        protected override string Speak
        {
            get { return "Woof"; }
        }
    }
 

Cat.cs
 public class Cat : AbstractAnimalBase
    {
        public Cat()
            : base("Cat")
        {
        }
 
        protected override string Speak
        {
            get { return "Meow"; }
        }
    }
 

Pig.cs
 public class Pig : AbstractAnimalBase
    {
        public Pig()
            : base("Pig")
        {
        }
 
        protected override string Speak
        {
            get { return "Oink"; }
        }
    }
 

Ok, now to the meat of this post.

Introduction to Factories

So, what is a factory anyway and what can it do for us? In layman terms, a factory is a piece of code that returns back a specific object from a given input. Ok, so what’s so special about that, right? – new does that for me. That’s correct, but, what if you don’t know what type of object you want while you’re coding? That’s where the factory comes in – you tell the factory what type of object you want and it will return the object needed for that type to you. In more programmer speak, a factory is one of the Gang of Four design patterns that is used to create objects without having to specify the exact class that will be created.

Yes, I know, you’re the programmer and you will always know what object you need and when - will you though? Let’s say you’re reading a config file and wanting to do certain operations or load certain values based on the config – do you always know what and how it will be configured? Or, let’s say you’re reading a database and you’ll have to load data from different tables depending on what the value of a specific field is…or, you’re looking at the file system for images and you come across a JPG and the next image is a GIF. Each of these is a good candidate for a factory.

Typically, a factory is a static class and/or a static method. Having the factory class static allows access to it without having to create an instance of the factory class.

Basic Factories

Factories using Strings

The factory method will generally return the common base class or common interface of the objects that could be created by the method…normally the structure is simple, either in a if-else or in a switch statement. So, for the animal factory, we’d have something like the following code:

AnimalFactory.cs
 public static class AnimalFactory  
    {  
        public static AbstractAnimalBase CreateAnimal(string type)  
        {  
            type = type.ToLower().Trim();  
            switch (type)  
            {  
                case "dog":  
                    return new Dog();  
                case "cat":  
                    return new Cat();  
                case "pig":  
                    return new Pig();  
                default:  
                    throw new Exception(String.Format("Unknown animal type {0}", type));  
            }  
        }  
    } 

Factories using Enumerations

A complaint with the above code is that it’s using strings to do the matching, which some claim is inefficient (due partly to the to lower and trim calls) and error prone (if you misspell, it’ll fail). This can easily be changed to use an enumeration, which will gain some speed (no need for string manipulation) and is less error prone but adds a little bit more maintenance to the code – the programmer has to update the enum as well as the factory code. Here’s the same code but using an enumeration instead:

AnimalFactory.cs
 public static class AnimalFactory  
    {  
        public enum AnimalEnum  
        {  
            Dog,  
            Cat,  
            Pig  
        };  
  
        public static AbstractAnimalBase CreateAnimal(AnimalEnum type)  
        {  
            switch (type)  
            {  
                case AnimalEnum.Dog :  
                    return new Dog();  
                case AnimalEnum.Cat:  
                    return new Cat();  
                case AnimalEnum.Pig:  
                    return new Pig();  
                default:  
                    throw new Exception(String.Format("Unknown animal type {0}", type));  
            }  
        }  
    } 

Well, that’s it for the factory, right? Well, in the general case, yes…but, there are a couple specific instances that I’ve found a use for lately that someone else may be interested in.

Cached Factories

There are times when creating a class is a long running process and you want to cache this data so you don’t kill your performance, but, the classes that do this all inherit from a base class so they are candidates for a factory pattern. The sample factories above would create a new animal each time that type is requested – which could run a long-running process. The cached factory helps with this situation…one thing to note with the cached factory it will return back the same object instance for a specific given type (not that this isn’t necessarily a singleton instance of a class). So, for example, using the animal example above, the program requests a dog for the first time, a dog (#1) is created and returned back to the caller…on the second call to get a dog, dog (#1) is still returned to the caller…let’s say the code is slightly different than above and we return back a dog for an input of “mut”…with this situation, the program passes in “mut” and we get back a different instance of a dog (#2). So, don’t get cached returns confused with singletons.

Now, for the code for a cached factory. Pretty similar to the others but it uses a dictionary to keep hold the type and the returned value. The code could easily be expanded to allow removal of cached values, etc, if needed.

AnimalFactory.cs
 using System.Collections.Generic;  
    public static class AnimalFactory  
    {  
        private static Dictionary<string, AbstractAnimalBase> AnimalCache { get; set; }  
  
        public static AbstractAnimalBase CreateAnimalCached(string type)  
        {  
            if (AnimalCache == null)  
            {  
                AnimalCache = new Dictionary<string, AbstractAnimalBase>();  
            }  
  
            type = type.ToLower().Trim();  
  
            if (!AnimalCache.ContainsKey(type))  
            {  
                AbstractAnimalBase animal;  
                switch (type)  
                {  
                    case "dog":  
                        animal = new Dog();  
                        break;  
                    case "cat":  
                        animal = new Cat();  
                        break;  
                    case "pig":  
                        animal = new Pig();  
                        break;  
                    default:  
                        throw new Exception(String.Format("Unknown animal type {0}", type));  
                }  
                AnimalCache.Add(type,animal);  
            }  
            return AnimalCache[type];  
        }  
    } 

Alternate “Factory” (Cache)

An alternate version of the above factory eliminates the switch statement – so, each animal object will be created and cached…but, each object must manually be created outside the factory (hmm, kinda longer a factory if the object is created elsewhere, is it?) – but that add could be technically done from anywhere, according to the permission of the function/class. So, the main method could add to the factory and other classes within the application use the factory with what was loaded from main.

AnimalFactory.cs
 using System.Collections.Generic;  
    public static class AnimalFactory  
    {  
        private static Dictionary<string, AbstractAnimalBase> AnimalCache { get; set; }  
  
        internal void AddAnimalToCache(string type, AbstractAnimalBase animal)  
        {  
            if (AnimalCache == null)  
            {  
                AnimalCache = new Dictionary<string, AbstractAnimalBase>();  
            }  
  
            type = type.ToLower().Trim();  
  
            if (!AnimalCache.ContainsKey(type))  
            {  
                AnimalCache.Add(type, animal);  
            }  
            else  
            {  
                throw new Exception(String.Format("Animal type {0} already exists", type));  
            }  
        }  
  
        public static AbstractAnimalBase GetAnimalFromCache(string type)  
        {  
            if (AnimalCache == null)  
            {  
                AnimalCache = new Dictionary<string, AbstractAnimalBase>();  
            }  
  
            type = type.ToLower().Trim();  
  
            if (!AnimalCache.ContainsKey(type))  
            {  
                throw new Exception(String.Format("Unknown animal type {0}", type));  
            }  
  
            return AnimalCache[type];  
        }  
    } 

Dynamic Factories

One thing that has always bothered me about the factory is having to add a class for what I want and then having to also modify the factory and maybe even an enum. There has to be a way for classes to “self register” themselves with a factory…well, there is with the above code – the constructor of each subclassed animal can add itself to the factory. Well, that’s great…but who is going to call the constructor for each of those sub-classes? Too bad the base class can’t determine it’s subclasses…or, wait, it can, but indirectly – through reflection.

Couple words on reflection and creating a factory in this way – reflection is “slow” in general, so you’ll probably want to cache the objects that are created and you probably only want to discover your classes once – on start up or on first use of the factory. Also, with this method, I’ve only used no-parameter constructors…and all the classes match that no-parameter constructor rule – probably ways around it but it will be a bit more coding to deal with that (i.e. it’s not as easy to do as with a normal factory). And, while this may be a way to dynamically discover classes for your factory, it raises some security concerns as well so code accordingly. So, use at your own risk basically.

Ok, enough with the legal warnings and notices. On to the code…

Brief Introduction to Reflection (as it pertains to Dynamic Factories)

So, the first question is how do we find out what classes are within a file? .Net actually makes this fairly simple…we have to load the assembly (i.e. dll or exe) into memory, then we can get all the types within that file. Essentially the code to do this is:

Code Snippet
 Assembly assembly = Assembly.LoadFrom(filename);  
Type[] types = assembly.GetTypes(); 

Where filename is the full path to an exe or dll that we want to inspect.

Discovering Interested Types

Next, we just iterate over all the types to see if they match what we’re looking for. We’ve got to be careful here as a type could be an interface, an abstract class, or not even a class that we’re interested in. For this, I’ve written a routine to verify a type is what I’m interested in.

Code Snippet
 protected static bool IsValidAnimal(Type type, ref AbstractAnimalBase animal)  
{  
    //is it a sub-class  
    if (type.BaseType != null)  
    {  
        //make sure it's not an interface  
        if (!type.IsInterface)  
        {  
            //is it a sub-class of what we're interested in  
            if (type.IsSubclassOf((typeof(AbstractAnimalBase))))  
            {  
                //make sure the type is a concrete type (i.e. not abstract)  
                if (!type.IsAbstract)  
                {  
                    try  
                    {  
                        animal = (AbstractAnimalBase)type.InvokeMember(null, BindingFlags.CreateInstance, null, null, new object[] { });  
                        return true;  
                    }  
                    catch (Exception ex)  
                    {  
                        throw new Exception(String.Format("Failed to load {0} as a add on command from {1}", type.Name, type.AssemblyQualifiedName), ex);  
                    }  
                }  
            }  
        }  
    }  
    return false;  
} 

So, to put the loading all together into a single class…

AnimalLoader.cs
 using System;  
using System.Collections.Generic;  
using System.Reflection;  
  
public class AnimalLoader  
{  
    public static List<AbstractAnimalBase> LoadAnimals(string filename)  
    {  
        List<AbstractAnimalBase> animals = new List<AbstractAnimalBase>();  
        Assembly assembly = Assembly.LoadFrom(filename);  
        Type[] types = assembly.GetTypes();  
  
        foreach (Type type in types)  
        {  
            AbstractAnimalBase animal = null;  
            if (IsValidAnimal(type,ref animal))  
            {  
                animals.Add(animal);  
            }  
        }  
        return animals;  
    }  
  
    protected static bool IsValidAnimal(Type type, ref AbstractAnimalBase animal)  
    {  
        //is it a sub-class  
        if (type.BaseType != null)  
        {  
            //make sure it's not an interface  
            if (!type.IsInterface)  
            {  
                //is it a sub-class of what we're interested in  
                if (type.IsSubclassOf((typeof(AbstractAnimalBase))))  
                {  
                    //make sure the type is a concrete type (i.e. not abstract)  
                    if (!type.IsAbstract)  
                    {  
                        try  
                        {  
                            animal = (AbstractAnimalBase)type.InvokeMember(null, BindingFlags.CreateInstance, null, null, new object[] { });  
                            return true;  
                        }  
                        catch (Exception ex)  
                        {  
                            throw new Exception(String.Format("Failed to load {0} as a add on command from {1}", type.Name, type.AssemblyQualifiedName), ex);  
                        }  
                    }  
                }  
            }  
        }  
        return false;  
    }  
} 

Ok, so we can now load the animals that’re in a dll or exe, but how do we load them into our factory? Need a key for each of the animals and also a way to load them before the factory is first used.

Making the Abstract Class “Keyable”

Well, we actually have a key in the AbstractAnimalBase class but it’s protected – let’s fix that and make it public so that the factory can access the keys (yes, it can be marked as internal instead as long as the factory and animal base class are in the same exe or dll). So the new AbstractAnimalBase class is changed to:

AbstractAnimalBase.cs
 public abstract class AbstractAnimalBase  
{  
    public string AnimalType { get; private set; }  
  
    public AbstractAnimalBase(string type)  
    {  
        AnimalType = type;  
    }  
  
    public void IntroduceSelf()  
    {  
        System.Console.WriteLine(IntroductionLine);  
        System.Console.WriteLine(Speak);  
        System.Console.WriteLine();  
    }  
  
    protected virtual string IntroductionLine  
    {  
        get  
        {  
            string introLine = "Hello, I am a " + AnimalType;  
            return introLine;  
        }  
    }  
  
    protected abstract string Speak  
    {  
        get;  
    }  
} 

Dynamic Factory Class

Now, to get that factory working. What would be nice would be for the factory to load the add ins when it’s first used…well, it can – by using a static constructor.

AnimalFactory.cs
 public static class AnimalFactory  
{  
    private static Dictionary<string, AbstractAnimalBase> Animals { get; set; }  
  
    static AnimalFactory()  
    {  
        Animals = new Dictionary<string, AbstractAnimalBase>();  
  
        List<AbstractAnimalBase> animals;  
         
        string filename="Animals.dll";  
        string path=Assembly.GetExecutingAssembly().Location;  
        path=System.IO.Path.GetDirectoryName(path);  
        string fileToLoad=System.IO.Path.Combine(path,filename);  
  
        try  
        {  
            animals = AnimalLoader.LoadAnimals(fileToLoad);  
  
            foreach (AbstractAnimalBase animal in animals)  
            {  
                string animalType = animal.AnimalType.ToLower().Trim();  
                if (!Animals.ContainsKey(animalType))  
                {  
                    Animals.Add(animalType, animal);  
                }  
                else  
                {  
                    throw new Exception(String.Format("Duplicate animal type {0} found", animalType));  
                }  
            }  
        }  
        catch (Exception ex)  
        {  
            throw new Exception(String.Format("There was a problem loading the assembly {0}", fileToLoad),ex);  
        }  
    } 

For this factory, for demo purposes, I’ve set the filename to be a static dll named Animals.dll, which the static constructor will use to pass to the AnimalLoader – you’ll more than likely want to use something different, but, remember, static constructors cannot accept parameters so you’ll have to find another way or just loop through all dlls. Also, this uses the current executing path – change as needed for your own purposes. Really, not a lot here – animals are discovered and loaded by the AnimalLoader method, then the animal types and the animal are added to the static list of animals for the factory. If you’ve been paying attention, yes, this is a cached factory at this point as reflection is slow.

Now, for getting the animals out of the factory.

AnimalFactory.cs
 public static AbstractAnimalBase GetCachedAnimal(string type)  
{  
    type=type.ToLower().Trim();  
    if (Animals.ContainsKey(type))  
    {  
        return Animals[type];  
    }  
    else  
    {  
        throw new Exception(String.Format("Unknown animal type {0}", type));  
    }  
}  
  
public static AbstractAnimalBase GetAnimal(string type)  
{  
    AbstractAnimalBase cachedAnimal = GetCachedAnimal(type);  
    Type animalAssemblyType = cachedAnimal.GetType();  
  
    AbstractAnimalBase animal = (AbstractAnimalBase)animalAssemblyType.Assembly.CreateInstance(animalAssemblyType.FullName);  
    return animal;  
} 

Two things to notice here, there’s a method to get a cached animal as well as creating a new one based on the cached version. I’ve supplied both just to show how to get a new animal from a cached version (this could also work for a normal cached factory as well as one using reflection to dynamically add classes).

Discovering what is available

And, that pretty much wraps up the factories and how to load classes dynamically. What, you want to know what types are available to show to your UI? Ok, here’s how you do that (requires “using System.Linq” namespace to be added thanks to the ToList extension method)…

AnimalFactory.cs
 public static List<string> GetAnimalTypes()  
{  
    return Animals.Keys.ToList<string>();  
} 

Dynamic Cached Factory Code

Now, for all the dynamic cached factory code.

AbstractAnimalBase
 using System;  
  
public abstract class AbstractAnimalBase  
{  
    public string AnimalType { get; private set; }  
  
    public AbstractAnimalBase(string type)  
    {  
        AnimalType = type;  
    }  
  
    public void IntroduceSelf()  
    {  
        System.Console.WriteLine(IntroductionLine);  
        System.Console.WriteLine(Speak);  
        System.Console.WriteLine();  
    }  
  
    protected virtual string IntroductionLine  
    {  
        get  
        {  
            string introLine = "Hello, I am a " + AnimalType;  
            return introLine;  
        }  
    }  
  
    protected abstract string Speak  
    {  
        get;  
    }  
} 

Dog.cs
 using System;  
  
public class Dog : AbstractAnimalBase  
{  
    public Dog()  
        : base("Dog")  
    {  
    }  
  
    protected override string Speak  
    {  
        get { return "Woof"; }  
    }  
} 

Cat.cs
 using System;  
  
public class Cat : AbstractAnimalBase  
{  
    public Cat()  
        : base("Cat")  
    {  
    }  
  
    protected override string Speak  
    {  
        get { return "Meow"; }  
    }  
} 

Pig.cs
 using System;  
  
public class Pig : AbstractAnimalBase  
{  
    public Pig()  
        : base("Pig")  
    {  
    }  
  
    protected override string Speak  
    {  
        get { return "Oink"; }  
    }  
} 

AnimalLoader.cs
 using System;  
using System.Collections.Generic;  
using System.Reflection;  
  
public class AnimalLoader  
{  
    public static List<AbstractAnimalBase> LoadAnimals(string filename)  
    {  
        List<AbstractAnimalBase> animals = new List<AbstractAnimalBase>();  
        Assembly assembly = Assembly.LoadFrom(filename);  
        Type[] types = assembly.GetTypes();  
  
        foreach (Type type in types)  
        {  
            AbstractAnimalBase animal = null;  
            if (IsValidAnimal(type, ref animal))  
            {  
                animals.Add(animal);  
            }  
        }  
        return animals;  
    }  
  
    protected static bool IsValidAnimal(Type type, ref AbstractAnimalBase animal)  
    {  
        //is it a sub-class  
        if (type.BaseType != null)  
        {  
            //make sure it's not an interface  
            if (!type.IsInterface)  
            {  
                //is it a sub-class of what we're interested in  
                if (type.IsSubclassOf((typeof(AbstractAnimalBase))))  
                {  
                    //make sure the type is a concrete type (i.e. not abstract)  
                    if (!type.IsAbstract)  
                    {  
                        try  
                        {  
                            animal = (AbstractAnimalBase)type.InvokeMember(null, BindingFlags.CreateInstance, null, null, new object[] { });  
                            return true;  
                        }  
                        catch (Exception ex)  
                        {  
                            throw new Exception(String.Format("Failed to load {0} as a add on command from {1}", type.Name, type.AssemblyQualifiedName), ex);  
                        }  
                    }  
                }  
            }  
        }  
        return false;  
    }  
} 

AnimalFactory.cs
 using System;  
using System.Collections.Generic;  
using System.Reflection;  
using System.Linq;  
  
public static class AnimalFactory  
{  
    private static Dictionary<string, AbstractAnimalBase> Animals { get; set; }  
  
    static AnimalFactory()  
    {  
        Animals = new Dictionary<string, AbstractAnimalBase>();  
  
        List<AbstractAnimalBase> animals;  
  
        string filename = "Animals.dll";  
        string path = Assembly.GetExecutingAssembly().Location;  
        path = System.IO.Path.GetDirectoryName(path);  
        string fileToLoad = System.IO.Path.Combine(path, filename);  
  
        try  
        {  
            animals = AnimalLoader.LoadAnimals(fileToLoad);  
  
            foreach (AbstractAnimalBase animal in animals)  
            {  
                string animalType = animal.AnimalType.ToLower().Trim();  
                if (!Animals.ContainsKey(animalType))  
                {  
                    Animals.Add(animalType, animal);  
                }  
                else  
                {  
                    throw new Exception(String.Format("Duplicate animal type {0} found", animalType));  
                }  
            }  
        }  
        catch (Exception ex)  
        {  
            throw new Exception(String.Format("There was a problem loading the assembly {0}", fileToLoad), ex);  
        }  
    }  
  
    public static AbstractAnimalBase GetCachedAnimal(string type)  
    {  
        type = type.ToLower().Trim();  
        if (Animals.ContainsKey(type))  
        {  
            return Animals[type];  
        }  
        else  
        {  
            throw new Exception(String.Format("Unknown animal type {0}", type));  
        }  
    }  
  
    public static AbstractAnimalBase GetAnimal(string type)  
    {  
        AbstractAnimalBase cachedAnimal = GetCachedAnimal(type);  
        Type animalAssemblyType = cachedAnimal.GetType();  
  
        AbstractAnimalBase animal = (AbstractAnimalBase)animalAssemblyType.Assembly.CreateInstance(animalAssemblyType.FullName);  
        return animal;  
    }  
  
    public static List<string> GetAnimalTypes()  
    {  
        return Animals.Keys.ToList<string>();  
    }  
} 

Trial and Error–WCF Services Part 1

2011-05-31T22:19:00.002-04:00

Decided a while ago that I would teach myself WCF (Windows Communication Framework) services. Saw the book, Programming WCF Services by Juval Lowy (ISBN 978-0-596-80548-7), at one of the local bookstores and decided to pick it up. While the book is a good read, after the first chapter I was like “going to need to take notes to figure this out.” Well, instead of doing that, I figured I’d start on a project I’ve been working on (ExpressRecipe) – the hard way – via trial and error. Hopefully my pain will help someone else out there…
I wanted to start out with something simple first – being able to get a host running and then get the description (also known as the WSDL) of the service through a web browser. To make things simple, I started out with a console app for the host in VS 2010. I created a separate project under the same solution to hold the WCF service itself.
First minor sticking point – the WCF reference is not automatically included so that must be included if you’re expecting to use either the host or any of the service attributes. So, be sure to add System.ServiceModel to all the projects that will be using WCF features. Be sure to include the using statement for that reference as well…
My first task was to create a simple interface that will be the contract for the service. I started out with a “user” contract that allows the client to create a new user with a first name, last name, username, and password as simple strings. So, the interface looks like:

Code Snippet

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
 
namespace ExpressRecipeWCFLibrary
{
    [ServiceContract]
    public interface IExpressRecipeUserContract
    {
        [OperationContract]
        void AddUser(string firstName, string lastName, string username, string password);
    }
}

First things you’ll notice that’s difference than a normal interface are the ServiceContract and OperationContract attributes. In their simple forms, the service contract is placed on the interface itself. The operation contract is placed on all the methods you want the host to expose to the client. Only one method here so the operation contract is specified only once. One thing of note – according to the book and the code they showed for the attributes, the attributes shown here are not inheritable – so they’ll need to be reapplied if this interface is subclassed [subinterfaced?]…they will be applied to a class that implements them though.
Ok, interface is pretty simple…next – the implementation of the interface.

Code Snippet

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace ExpressRecipeWCFLibrary
{
    public class UserService:IExpressRecipeUserContract
    {
        #region IExpressRecipeUserContract Members
 
        public void AddUser(string firstName, string lastName, string username, string password)
        {
            System.Console.WriteLine(String.Format("{0} {1} {2} {3}", firstName, lastName, username, password));
        }
 
        #endregion
    }
}

Well, actually, nothing surprising here at all – simple implementation of a normal interface…not even a mention of the System.ServiceModel reference in the usings. Well, that’s nice and fairly easy to do…just add the ServiceContract and OperationsContract to the interface and everything else is “business as usual.” [note that interfaces are used here – while it is recommended to use an interface and add the attributes to that, nothing prevents you from adding them to the class itself – but, the design principle applies – “program to an interface, not an implementation” so try to use an interface if at all possible].
The operations I wanted exposed as a service are done so now it’s time for the host.
In the console Program.cs file, I created a new ServiceHost and passed it the type of my UserService class (notice not the interface but the class itself). I also decided, for debugging purposes, to attach event handlers to each of the events raised by the host. So, the code looks something like this…

Code Snippet

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using ExpressRecipeWCFLibrary;
 
namespace ExpressRecipeWCFServices
{
    class Program
    {
        static void Main(string[] args)
        {
            ServiceHost host=new ServiceHost(typeof(UserService));
            host.Closed += new EventHandler(host_Closed);
            host.Closing += new EventHandler(host_Closing);
            host.Faulted += new EventHandler(host_Faulted);
            host.Opened += new EventHandler(host_Opened);
            host.Opening += new EventHandler(host_Opening);
            host.UnknownMessageReceived += new EventHandler<UnknownMessageReceivedEventArgs>(host_UnknownMessageReceived);
 
            host.Open();
            System.Console.WriteLine("User service started");
 
            System.Console.WriteLine("Press <enter> to close");
            System.Console.ReadLine();
            host.Close();
        }
 
        static void host_UnknownMessageReceived(object sender, UnknownMessageReceivedEventArgs e)
        {
            System.Console.WriteLine("Host unknown message");
        }
 
        static void host_Opening(object sender, EventArgs e)
        {
            System.Console.WriteLine("Host opening");
        }
 
        static void host_Opened(object sender, EventArgs e)
        {
            System.Console.WriteLine("Host opened");
        }
 
        static void host_Faulted(object sender, EventArgs e)
        {
            System.Console.WriteLine("Host faulted");
        }
 
        static void host_Closing(object sender, EventArgs e)
        {
            System.Console.WriteLine("Host closing");
        }
 
        static void host_Closed(object sender, EventArgs e)
        {
            System.Console.WriteLine("Host closed");
        }
    }
}

Don’t worry, really not much code – most of it is writing to the console, mainly for the event handlers. Ok, pretty normal code…guess we have the host so let’s run it.
Um…whoops – exception. It runs the “host opening” event, then complains with:

“An unhandled exception of type 'System.InvalidOperationException' occurred in System.ServiceModel.dll

Additional information: Service 'ExpressRecipeWCFLibrary.UserService' has zero application (non-infrastructure) endpoints. This might be because no configuration file was found for your application, or because no service element matching the service name could be found in the configuration file, or because no endpoints were defined in the service element.”

Man, you mean VS 2010 doesn’t create a default endpoint? And not even an App.Config file. Oh well. Yep, must add an App.Config file. [this can be found in add new item under the project menu – application configuration file]. For simplicity sake, I left the name as the default…
Ok, so, now to reference the book, what needs to be in this config file? Well, need an endpoint for the service, that part is obvious from the exception. Need to add the service to the confile file as well…so something like:

Code Snippet

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <services>
      <service name="ExpressRecipeWCFLibrary.UserService">
        <endpoint address="http://localhost:8000/UserService/" binding="wsHttpBinding" contract="ExpressRecipeWCFLibrary.IExpressRecipeUserContract"/>
      </service>
    </services>
  </system.serviceModel>
</configuration>

Ok, not obvious but it works…have to add the service class to the services list with full namespace (required to be full? – don’t know). Then to specify the endpoint - an endpoint is the combination of address, binding, and contract so all of that is specified. I wanted http and decided to use the web service binding (instead of basic binding, which would be the default for an HTTP address) so that I could access this service via non-WCF clients [i.e. Java]. The contract is the interface for the service with namespace specified (again – required – not sure).
So, does it work this time? Well, let’s see – Ctrl-F5.

Hmm, yep…ok, let’s try to get to the WSDL of the service. In the browser: http://localhost:8000/UserService/ – um, nope – “The webpage cannot be found.” Ok, well, let’s try http://localhost:8000/ – nope – still “The webpage cannot be found.”
Now what…well, according to the book, page 39, Metadata Exchange – “by default, the service will not publish its metadata.” Well, further reading (after the very discouraging “publishing your service’s metadata involves significant effort”) we find that we can do this in a couple ways. I chose one that seemed the easiest to me – enabling the metadata behavior (httpGetEnabled) on the endpoint.
So, going off the example in the book, my App.Config now looks like:

Code Snippet

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <services>
        <service name="ExpressRecipeWCFLibrary.UserService"behaviorConfiguration="MEXGET">
        <endpoint address="http://localhost:8000/UserService/" binding="wsHttpBinding" contract="ExpressRecipeWCFLibrary.IExpressRecipeUserContract"/>
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="MEXGET">
          <serviceMetadata httpGetEnabled="true"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

Does it run? Nope. It actually stopped after the host faulted event was called and gave this exception:

“The HttpGetEnabled property of ServiceMetadataBehavior is set to true and the HttpGetUrl property is a relative address, but there is no http base address. Either supply an http base address or set HttpGetUrl to an absolute address.”

Ok, so now what? Looking at the book’s example a bit more closely it shows the base address off of the host element of the service…and no endpoint element. Ok, so, I replaced it with:

Code Snippet

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <services>
      <service name="ExpressRecipeWCFLibrary.UserService" behaviorConfiguration="MEXGET">
        <host>
          <baseAddresses>
            <add baseAddress="http://localhost:8000/UserService/"/>
          </baseAddresses>
        </host>
        <!--<endpoint address="UserService/" binding="wsHttpBinding" contract="ExpressRecipeWCFLibrary.IExpressRecipeUserContract"/>-->
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="MEXGET">
          <serviceMetadata httpGetEnabled="true"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

I list my binding by doing this, something I’ll get back at a later time…and the contract is now gone as well. Well, will this even work?

How’d that happen? Ok, let’s see if we can access the WSDL in the browser by going to the base address specified (http://localhost:8000/UserService/).

Oh, cool…appears to be working…will try to get the binding back at a later time and create a client to call the AddUser method.

Dynamics in .Net 4.0

2011-05-24T12:57:00.001-04:00

One of the new features of .Net 4.0 is the concept of a dynamic type. In general terms, it allows the programmer to perform “late binding” at run time. So, what’s so special about that – the object type allows “late binding”. Well, does it? What if you don’t know what type the object is but you do know it will support a method or operation? Yes, you can always use “typeof”, “is”, or “instanceof” operators to test that it is a specific type or inherits from a specific type – but what if the method or operator doesn’t have a common inheritance tree – such as most of the operators (+, –, etc) or what if there are many possibilities/combinations. The dynamic type solves a lot of the type checking and casting that would be required in previous versions of .Net.

For example, let’s say you’re wanting to do addition on two objects. Let’s assume that both these objects support +. The general concept of late binding says that you “should” be able to do something like:

  1: object value1=1;
  2: object value2=2;
  3: object value3=value1+value2;

The above code will give you “Error 1 Operator '+' cannot be applied to operands of type 'object' and 'object'”. The solution is to cast these as ints such as:

  1: object value1 = 1;
  2: object value2 = 2;
  3: object value3 = (int)value1 + (int)value2;

Ok, so that works – no compile error…but, what if value1 was a double, not an int…or, what if value1 or value2 could be either int or double…then you’re stuck with some nasty code like:

  1: object value1 = 1;
  2: object value2 = 2;
  3: object value3;
  4: if (value1 is int)
  5: {
  6:     if (value2 is int)
  7:     {
  8:         value3 = (int)value1 + (int)value2;
  9:     }
 10:     else if (value2 is double)
 11:     {
 12:         value3 = (int)value1 + (double)value2;
 13:     }
 14: }
 15: else if (value1 is double)
 16: {
 17:     if (value2 is int)
 18:     {
 19:         value3 = (double)value1 + (int)value2;
 20:     }
 21:     else if (value2 is double)
 22:     {
 23:         value3 = (double)value1 + (int)value2;
 24:     }
 25: }
 26:

Add another type that both could be and it increases the code more…not nice at all.

Around .Net 3.5, Microsoft added the var type. The var type infers a type at design time. This is nice in our example case and actually works so:

  1: var value1 = 1;
  2: var value2 = 2;
  3: var value3 = value1 + value2;

Actually works – it compiles and we get 3. If we change a or b to be a double, value3 gets a double result (double + int=double) as expected if we had explicitly typed the variables. Great, problem solved – right? Wrong… Let’s add another monkey wrench into this…

Suppose we want a function that converts a string to the “best” type that that string represents. So, a string value of “2.4” would return a double 2.4, a “12/25/2011” would return a DateTime of 12/25/2011, etc. Then we’d like to take the result of that and add it to another result from that same function. This would work with object, but we’d be back in the exact same situation as before – testing with “is” and casting. What about var? (the GetBestType function is a prototype only – it works but it needs more error checking, validation, etc).

  1: var value1 = GetBestType("1.2");
  2: var value2 = GetBestType("2");
  3: var value3 = value1 + value2;
  4: 
  5: public var GetBestType(string value)
  6: {
  7:     double doubleResult;
  8:     if (double.TryParse(value, out doubleResult))
  9:     {
 10:         return doubleResult;
 11:     }
 12: 
 13:     int intResult;
 14:     if (int.TryParse(value, out intResult))
 15:     {
 16:         return intResult;
 17:     }
 18:     
 19:     DateTime dateResult;
 20:     if (DateTime.TryParse(value, out dateResult))
 21:     {
 22:         return dateResult;
 23:     }
 24: 
 25:     return value;
 26: }
 27:

Well, first thing with that code – won’t even compile. Seems the var keyword is only for local variables. Well, back to old reliable object, right? If we were using .Net 3.5 or before, yes…this is where dynamic comes in for .Net 4.0.

The dynamic type is determined at run time…so, fixing our code to use dynamic, we can do this:

  1: var value1 = GetBestType("1.2");
  2: var value2 = GetBestType("2");
  3: var value3 = value1 + value2;
  4: 
  5: public dynamic GetBestType(string value)
  6: {
  7:     double doubleResult;
  8:     if (double.TryParse(value, out doubleResult))
  9:     {
 10:         return doubleResult;
 11:     }
 12: 
 13:     int intResult;
 14:     if (int.TryParse(value, out intResult))
 15:     {
 16:         return intResult;
 17:     }
 18:     
 19:     DateTime dateResult;
 20:     if (DateTime.TryParse(value, out dateResult))
 21:     {
 22:         return dateResult;
 23:     }
 24: 
 25:     return value;
 26: }

Yes, we’re returning either a double, an int, a DateTime, or a string from one function and the code works as expected.

While the above code works, and minimizes code vs late binding type checking, both the dynamic and var keywords should be used sparingly in favor of code readability. Technically, while you could create every variable as var or dynamic, it would greatly reduce readability…so, use sparingly when needed (i.e. when you’d be tempted to use object and type checking). It is much better than using object, but it should never replace a explicitly typed variable, if you have the choice.

Static Constructors in .Net

2011-05-24T10:59:00.001-04:00

Suppose you’re creating a class in .Net and you want certain operations only done once, at the very first time your class is used. First thoughts? A flag to test to see if it’s the first time into the class – suppose your class has 100 static and non-static functions – that code to do the check must be in each of those. What a pain… Next idea? (And, no, you’re not allowed to cheat and use a Singleton) What? No more ideas…

The solution – use a static constructor. Static constructors are called only once, when the class is first used, either through static members or object members (i.e. non-statics).

Static constructors are really not much different from regular constructors in definition except they can’t have access modifiers (i.e. public, private, protected, etc). They are called before the normal constructor. But, being static, they can only access static members of that class. Here’re the other rules about static constructors from Microsoft (http://msdn.microsoft.com/en-us/library/k9x6w0hc(v=VS.100).aspx):

A static constructor does not take access modifiers or have parameters.
A static constructor is called automatically to initialize the class before the first instance is created or any static members are referenced.
A static constructor cannot be called directly.
The user has no control on when the static constructor is executed in the program.
A typical use of static constructors is when the class is using a log file and the constructor is used to write entries to this file.
Static constructors are also useful when creating wrapper classes for unmanaged code, when the constructor can call the LoadLibrary method.
If a static constructor throws an exception, the runtime will not invoke it a second time, and the type will remain uninitialized for the lifetime of the application domain in which your program is running.

Here’s a quick example class that creates a Singleton using the static constructor.

  1: public class StaticSingleton
  2:     {
  3:         static StaticSingleton staticSingleton;
  4: 
  5:         private StaticSingleton ()
  6:         {
  7:         }
  8: 
  9:         static StaticSingleton()
 10:         {
 11:             staticSingleton = new StaticSingleton();
 12:         }
 13: 
 14:         public static StaticSingleton GetInstance()
 15:         {
 16:             return staticSingleton;
 17:         }
 18:     }

Here’s the non-static constructor version for comparison:

  1:     public class Singleton
  2:     {
  3:         static Singleton singleton;
  4: 
  5:         private Singleton()
  6:         {
  7:         }
  8: 
  9:         public static Singleton GetInstance()
 10:         {
 11:             if (singleton == null)
 12:             {
 13:                 singleton = new Singleton();
 14:             }
 15:             return singleton;
 16:         }
 17:     }

True Random Numbers in SQL

2011-05-20T15:54:00.001-04:00

Co-worker stumbled across this one and thought it was a good way to generate random numbers in SQL Server.

Often, random numbers are driven off of the uniqueness of the ticks/millisecond part of the current date/time but that code may run so quickly that you’re not guaranteed a different value between each random request.

The solution – use GUIDs as the source for the random function as GUIDs are “guaranteed” to be unique. Of course, some casting is involved as the random function does not take a string. So, the solution is to cast the GUID as a var binary, then convert that to an int, then pass the absolute value of that that into rand (since it only allows positive ints). Here’s the general code:

  1: RAND(ABS(CAST(CAST(NEWID() AS VARBINARY) AS INT)))

As normal, rand returns a float/double between 0 and 1.

String Equality and Performance in C#

2011-05-16T15:39:00.001-04:00

Strings in .Net are one of the more used primitives but are also the most problematic performance wise. In college and while learning through books, etc. , we’re told that to concatenate two strings, use the + operator. The + operator seems to become habit fairly quickly and sticks with us, and we wonder why our programs are taking seconds between operations and eating megs of memory. It’s only after running a performance analyzer we realize the culprit – the old standby + operator which is taking seconds to concat two strings. We learn through that that we can increase performance and reduce memory usage by using StringBuilder and its Append method instead and bring seconds down to milliseconds and drop megs off the memory footprint. While this may not be the fastest method out there, it sure beats the + operator that we get into the habit of using.
We’re also told to use the == operator (or .equals in Java) for string equality. Is == the best operator to use when doing string equality operations? And, is there a fast case-insensitive way to do string equality?
As usual, there’s more than one way to do a task in .Net and string equality is no exception. I counted at least 24 different ways using the .Net built-in methods. A lot of the different ways come from doing string comparisons and doing the comparisons based on culture (Windows-installed, current, etc) or on doing a binary comparison…speed is also determined based on whether you’re doing a culture-specific comparison or doing a simple binary comparison (i.e. via ASCII/Unicode-table). Sting equality is not exactly the same as string comparisons so I’m ignoring culture in this post, with the exception of which performs the best given the circumstances.
Grouping the equality operations together without their culture options, there are 6. The == operator, .equals, .CompareTo, the static methods string.equals, string.Compare, and string.CompareOrdinal.
Since, in general, string equality operations are very fast when done as a single operation, I’ve ran tests based on 6,250,000 (2,500²) string equality tests. For these tests, I have a routine to create 2,500 randomly-generated strings. I tested with string lengths between 1 and 1k (1024).
Ok, so the answer to which is faster – well, guess what, it depends. [nothing is ever as easy as it seems, is it?]. The answer is different depending on if you’re dealing with same-length strings vs different length strings, and on whether you’re wanting to ignore case or not. There are sure to be other reasons for the speed difference as well but here’re my results. I’ll do the comparison based on different vs same length strings – just use the best function listed for whether to ignore the case or not.

DIFFERENT Length Strings

.equals and string.equals seem to be pretty much tied for 1st and 2nd place with time around .09 seconds (the .Net timer object I was using for the time calculation has an accuracy to .001 seconds). Both of these are using ordinal ignore case comparison.
Here’s the other results for comparison:

.equals (ordinal ignore case)	.097
string.equals (ordinal ignore case)	.098
.equals (ordinal)	.120
.equals	.121
string.equals (ordinal)	.127
==	.135
string.CompareOrdinal	.239
.equals (invariant culture)	.627
.equals (invariant ignore case)	.635
string.compare (ignore case)	.658
.equals (current culture ignore case)	.659
string.compare	.660
string.equals (current culture ignore case)	.673
string.equals (invariant ignore case)	.676
string.equals (current culture)	.682
.CompareTo	.684
.equals (current culture)	.689
== (w/ ToLowerInvariant inline)	24.153 (yes, seconds)
== (w/ ToUpper inline)	25.071
== (w/ ToUpper external)	25.029
== (w/ ToLower inline)	25.504
== (w/ ToLower external)	25.730

SAME Length Strings

For same length strings, things are slightly different – string.equals (ordinal) and .equals (ordinal) are at the top, not the ordinal ignore case. Here’s the rundown for same length strings. I’ve omitted the ToLower/ToUpper results as they were just horrible in performance.

string.Equals (ordinal)	.124
.equals (ordinal)	.128
string.compareOrdinal	.132
.equals	.133
==	.146
.equals (ordinal ignore case)	.213
string.Equals (ordinal ignore case)	.230
string.Equals (invariant culture ignore case)	.577
string.Equals (invariant culture)	.578
.equals (invariant culture ignore case)	.611
string.Equals (current culture ignore case)	.620
.equals (current culture)	.622
string.Equals (current culture)	.630
.CompareTo	.634
.equals (invariant culture)	.636
string.compare (ignore case)	.638
string.compare	.686

Code

Ok, so you don’t want to look up how to do an ordinal ignore case equality against two strings…well, here’s the code snipets. Variables str1 and str2 are strings.

==

This one is easy – not much explanation needed.

1: if (str1 == str2)

.Equals

String object method – similar to Java’s equals method.

1: if (str1.Equals(str2))

string.Compare

One of the static string compare functions. Returns 0 if strings are equal. Several options available.

1: if (string.Compare(str1, str2) == 0)

string.CompareOrdinal

Another static string compare function – compares using binary comparison instead of text so it uses the ASCII/Unicode table for its comparison.

1: if (string.CompareOrdinal(str1, str2) == 0)

string.Compare (ignore case)

An overload to string.Compare that ignores case of the characters.

1: if (string.Compare(str1, str2,true) == 0)

string.Equals, .Equals (current culture)

Compares strings using the current machine/user’s culture). Overload of the equals method.

1: if (string.Equals(str1, str2,StringComparison.CurrentCulture))

1: if (str1.Equals(str2,StringComparison.CurrentCulture))

string.Equals, .Equals (current culture ignore case)
Same as equals current culture – just ignores case

1: if (string.Equals(str1, str2, StringComparison.CurrentCultureIgnoreCase))

1: if (str1.Equals(str2, StringComparison.CurrentCultureIgnoreCase))

string.Equals, .Equals (invariant culture)

Compares based on the installed Windows culture.

1: if (string.Equals(str1, str2, StringComparison.InvariantCulture))

1: if (str1.Equals(str2, StringComparison.InvariantCulture))

string.Equals, .Equals (invariant culture ignore case)

Ignores case but compares on the currently installed Windows culture.

1: if (string.Equals(str1, str2, StringComparison.InvariantCultureIgnoreCase))

1: if (str1.Equals(str2, StringComparison.InvariantCultureIgnoreCase))

string.Equals, .Equals (ordinal)

Performs binary (ASCII/Unicode) comparison.

1: if (string.Equals(str1, str2, StringComparison.Ordinal))

1: if (str1.Equals(str2, StringComparison.Ordinal))

string.Equals, .Equals (ordinal ignore case)

Binary comparison but ignores case.

1: if (string.Equals(str1, str2, StringComparison.OrdinalIgnoreCase))

1: if (str1.Equals(str2, StringComparison.OrdinalIgnoreCase))

.CompareTo

String object compare to method – similar to string compare method except no overloads other than comparing strings to objects.

1: if (str1.CompareTo(str2) == 0)

== (w/ ToLower), == (w/ ToUpper), == (ToLowerInvariant)

Sadly, this is how I’ve done case insensitive searches for years (even in .Net) thanks for my many years programming in BASIC and QuickBasic – neither of which had the many ways to do string equality that .Net has. This is also, sadly, one of the slowest ways to do string case insensitive equality. The true cost here is the ToLower case conversion, which is just slow. This, just like the + operator for strings, is one of those “don’t do these” features of strings. If you’re needing to do case insensitive equality, use something else…

1: if (str1.ToLower()==str2.ToLower())

1: if (str1.ToUpper() == str2.ToUpper())

1: if (str1.ToLowerInvariant() == str2.ToLowerInvariant())

== (w/ ToLower external), == (w/ ToUpper external)

Essentially the only difference here is ToLower is pulled outside of the equality – so essentially the case conversion is done elsewhere…still takes a LOT of time to do the conversion on top of the equality.

1: string a = str1.ToUpper();
2: string b = str2.ToUpper();
3: if (a == b)

Conclusion

Well, since most strings in .Net (and Java) are different length strings, it’s best to use .equals over the == operator. If the program does not care about case nor culture comparisons, adding in the case insensitive ordinal comparison also helps as well. Of course, the performance is minor in comparison to the + operator, but, if you’re dealing with millions (or billions) of string equalities, every millisecond gained helps. Definitely avoid use of ToLower or ToUpper to do comparisons/equality.

Easy Separated Lists in .Net

2011-05-09T15:12:00.038-04:00

Found a simple way of doing a separated list, similar to PHP's implode function. The code expects the variable "Values" to be of an IEnumerable type, which includes arrays, lists, etc. Very useful for doing comma delimited lists.

Instead of doing:

string commaList = "";

foreach (string value in Values)

{

    commaList = commaList + value;

    commaList = commaList + ", ";

}

commaList = commaList.Substring(0, commaList .Length - 2);

It's easier (and faster) to do (.Net 4.0):

string commaList=string.Join(", ", Values);

.Net 3/3.5:

string commaList=string.Join(", ", Values.ToArray());

.Net 2.0:

string commaList=string.Join(", ",new List<string>(Values).ToArray());

Of course the join function allows any separator to be used, not just ", ".

And, according to this post, string.Join is faster than StringBuilder in this particular case.

Intro to Computer Programming - Chapter 7: Making Decisions

2010-02-26T17:54:00.000-05:00

Introduction

    The human life is filled with decisions. Every day, we as humans make millions of decisions, everything from when to get up to what to eat and each of those decisions brings on even more decisions. If we decide that we want something to eat, we must decide what we want to eat, where we're going to get it from, whether we are going to cook it ourselves or go get it from somewhere, how we want it cooked, if we have enough money to buy it, if we have enough time to eat it, and so forth. We make decisions based on our past experiences and our personal preferences.

    Computers are very good at making decisions. Computers make decisions, but their decisions are usually based on the content of a variable or the value of an expression instead of the computer's past experiences [unless of course you're dealing with artificial intelligence and then it's still based on variables].

    Computers have several different decision making statements. These statements can be classified into two categories, a branch and a loop.

Branch Statements

Humans use branch statements daily on common decision making tasks. For instance, the decision whether a person has enough money to buy a particular item is considered to be a branch statement. The reason this is considered to be a branch statement is because if the person does not have enough money to buy the item then the person could buy a cheaper item or do something else. Basically a branch statement will branch off into two or more courses of action, depending upon the decision. Branch statements in English usually use the words if, then, and else.

Branch statements in computers are very similar to those in English. Almost all computer languages have some form of a branch statement, most using the same word if to mark that a statement is a branch statement. For example, if the user pressed the "a" key, then do this else do something else. Both the Qbasic and the C/C++ language have a form of the branch statement.

Branch Statements in Qbasic

In Qbasic, the form of the branch statement is similar to the form in the English language in that it uses if-then-else. The if statement is followed by an expression that could have the value of true or false, if the expression is false then the computer does what comes after the then part of the statement and ignores the else part of the statement, otherwise it will ignore the then part of the statement and does the else part of the statement instead. The else part of the statement can be left alone if there is nothing to be done.

A good example of this is how the absolute function works. The absolute value function checks to see if a number is less than 0, if it is then it takes the negative of that number [which makes it positive since the number is already negative], otherwise it leaves the number alone. So, the statement would be IF number<0 THEN number=-number. Since there is nothing to do if the number is 0 or greater, the else part of the statement is left off. The type of if statement shown here is considered to be a simple if statement since it only includes at most one command on the then branch and at most one command on the else branch. The following program illustrates the if statement.

IF a=1 THEN PRINT "Hello"

IF a=1 THEN PRINT "Hello" ELSE PRINT "Bye"

IF a=1 THEN ELSE PRINT "Bye"

Program 19 - Qbasic IF Example

The other type of if statement is called a block if statement. The block if statement can have multiple commands on either the then branch or the else branch or both. The way to do a block if statement is to do the if statement as normal up to and including the then, then doing the program as normal with each statement on a line by itself, then when the block is done either do the else statement or tell the computer that this is the end of the if by including the statement end if. The following example demonstrates a block if with the block on the then, the block on the else, and the block on both.

IF number<0 THEN

PRINT "Number is negative."

number=-number

ELSE

PRINT "Number is positive."

END IF

IF number<0 THEN

PRINT "Number is negative."

ELSE

PRINT "Number is positive."

number=2*number

END IF

IF number<0 THEN

PRINT "Number is negative."

number=-number

ELSE

PRINT "Number is positive."

number=2*number

END IF

Program 20 - Qbasic Block IF Example

If statements can also be compound or nested and contain other if statements within them. The only caution here is that the programmer must make sure to close each block if statement by using the end if statement.

Block if statements are also allowed to change the expression for each else statement included in the if. For example, if the programmer wanted to see if a>1 and if that was false then to check if c<0, that could be accomplished by using a compound if or by using the elseif command. Program 21 demonstrates the use of the compound if and also the use of the eleseif command.

IF x>0 AND x<50 THEN

IF y>0 AND y<50 THEN

PRINT z

ELSE

PRINT x*y

END IF

ELSE

IF z>0 AND z<10 THEN

PRINT y

ELSE

IF a=1 THEN

PRINT x,y,z

END IF

IF x>0 AND x<50 THEN

IF y>0 AND y<50 THEN

PRINT z

ELSE

PRINT x*y

END IF

ELSE

IF z>0 AND z<10 THEN

PRINT y

ELSEIF a=1 THEN

PRINT x,y,z

END IF

Program 21-Qbasic Compund If example

Branch Statements in C/C++

    Simple if statements in C/C++ are very similar to simple if statements in Qbasic. The only differences between C/C++'s simple if statements and Qbasics are that in C/C++, the expression must be enclosed in a set of parenthesis ( () ), and also that the word then is omitted. Also, as usual in C/C++, a semicolon is added to the end of the line. Also, there is no difference between the C version of an if statement and the C++ version.

    Unlike most statements and functions covered so far in the C/C++ language, the if statement does not require an include file as the if statement is part of the language.

    The following table illustrates the differences between the Qbasic simple if statement and the C/C++ version of the simple if statement. Note that the output commands are C++ output commands for simplicity and endl is not included.

Qbasic	C/C++
IF a=1 THEN PRINT a	if (a==1) cout<<a;
IF a=5 THEN PRINT a ELSE PRINT b	if (a==5) cout<<a else cout<<b;

Table 26 – Comparison of Qbasic and C/C++ Simple if statement

Block if statements in C/C++ are also similar to the Qbasic block if statements except that the form of a block in C/C++ is different. In C/C++, a block is defined as a sequence of programming statements that are between a set of braces ( { } ). What this means is that C/C++ does not require a end if statement, but instead requires that a program block be created. The following C++ code segments illustrate the block if in C/C++. Notice how the line that contains the if does not require a semicolon [if the line is broken between the parenthised expression and the next command], even though it is on a line by itself, also the else is the same way and does not require a semicolon. Also, notice how if only one command follows the if or the else, it does not require the braces, but if it has more than one command following it it does require the braces.

if (number<0)

{

cout<<"Number is negative.";

number=-number;

}

else

cout<<"Number is positive.";

if (number<0)

cout<<"Number is negative.";

else

{

cout<<"Number is positive.";

number=2*number;

}

if (number<0)

{

cout<<"Number is negative.";

number=-number;

}

else

{

cout<<"Number is positive.";

number=2*number;

}

Program 22 - C/C++ Block if example

C/C++ also allows compound or nested if statements and these are done the same way as they are in Qbasic. It is advisable to put nested if statements into their own program block to keep from getting yourself confused as to which else goes with which if.

As was done in Qbasic, the else if command allows the expression to be changed within the if statement. The only difference between the else if command in Qbasic and in C/C++ is that else if is two words in C/C++, else if, whereas it is only a single word, elseif, in Qbasic. The following program illustrates the compound if as well as the else if command.

if (x>0&&x<50)

if (y>0&&y<50)

cout<<z;

else

cout<<x*y;

else

if (z>0&&z<10)

cout<<y;

else

if (a==1)

cout<<x<<y<<z;

if (x>0&&x<50)

if (y>0&&y<50)

cout<<z;

else

cout<<x*y;

else

if (z>0&&z<10)

cout<<y;

else if (a==1)

cout<<x<<y<<z;

Program 23 - C/C++ Compound If Example

Loops

    Loops are useful in many different type of programs. A loop gets the computer to repeat a series of steps while something is true, until something is true, a certain number of times, or even infinitely.

    Humans use loops on nearly every task we do in our lives. Walking is performing a loop of taking a series of steps until we reach a certain destination. Reading is performing a loop within a loop. With reading, we read the a series of letters until we hit something that tells us that that series of letters is a word, and then we continue to the next word until the end of the sentence or book. Even speaking is a loop, we speak until we have nothing more to say. Loops are probably just as common as decisions are as far as humans go.

    Computers are no different with the respect to loops. Some of the most common tasks can only be accomplished by using some form of a loop. For example, almost all games require some sort of loop that continues until the player wins or loses. Typing a character on the keyboard requires a loop because the computer has to wait until the user presses a key.

    In Qbasic and in C/C++, there are several types of loops. There are loops that are used to count (for loops), loops that perform a task while a certain condition is true (do-while and while loops), and loops that perform a task until a condition is true (do-until loops).

For Loops in Qbasic

One of the easiest ways to get a Qbasic program to count is to use a for loop. The for loop repeats a series of steps and counts from a given starting value until a given ending value and increases by a given value each time. For example, the programmer may wish a variable J to count from 1 to 100 and increase by .5 each time through the loop, therefore it would repeat a certain series of steps 200 times.

The format for the for statement is the word FOR, the variable to be used as a counter along with its initiation, the word TO, then the maximum count (can be a variable or expression), and optionally the word STEP and a step value (can be a variable or expression). For example, to make a for loop that counts from 1 to 5 and counts by 1 [the default], the for loop should look like: FOR j=1 TO 5. After the for statement there should be a program segment that needs to be repeated the number of times specified by the for loop. After the program segment should be the command next and the variable name which tells Qbasic where the for loop should end. This is best explained by the following program which counts from 1 to 10.

FOR J=1 TO 10

PRINT J

NEXT J

Program 24 - Simple Qbasic For Loop

If the programmer wanted to print the numbers from 10 to 1 and count down by -0.5, the program would look like the following:

FOR count=10 TO 1 STEP -.5

PRINT count

NEXT count

Program 25 - Qbasic For loop showing Step Option

Just like if statements, for loops can be nested to perform fairly complex operations. For example the following program will print a multiplication table from 1 to 5. Notice how the latest for loop (K) is the one to have the soonest appearing next. The variable names on the nexts are optional.

FOR J=1 to 5

FOR K=1 to 5

PRINT J*K;

NEXT K

NEXT J

1 2 3 4 5

2 4 6 8 10

3 6 9 12 15

4 8 12 16 20

5 10 15 20 25

Program 26 - Nested QBasic For Loop

For loops can also be used as timing loops by not including a program segment between the for statement and its corresponding next statement. This technique is sometimes used in games or wherever a program needs to be slower. As a word of note, this technique is not very stable as the same for loop will run at different speeds on different machines. For instance, a loop that counts from 1 to 1,000,000 could take several hours on a machine built 5 years ago, but could only take a minute on a modern machine.

For loops in Qbasic are useful when the maximum count is known, but are not very useful when the maximum count is an unknown value. Other loops are useful in this case.

Do Loops in Qbasic

In Qbasic, there are several forms of do loops. There is a do while a condition is true, and also a do until a condition is true. Each of these loops can be either a test at top or test at bottom loop. Each of these loops can be used in place of each other, but some are better suited for a particular task. The do while and do until loops are opposite of each other logically speaking so there is no need to specifically cover them individually but the test at top and test at bottom will next some explanation.

Test at Bottom Do Loops

The do loop will continue to execute until a condition is true, or while a condition is true. The until or while clause must be specified as well as the condition. The format of the test at bottom do loop is the word do, followed by the sequence of commands to be executed in the loop, then the word loop followed by the clause and then the condition.

In the case of the test at bottom do loops, the loop is allowed to be executed at least once before any testing of the condition is done. This type of loop could be useful in the case of input from a user and making sure they enter a specific value as is shown in the next program. As you can see, the two programs are identical except for the changing of until to while and also the "negative" logic where equals changes to not equals other than that, there is no difference in the programs and there is also no difference at all in what the programs do.

PRINT "Enter the number 1";

LINE INPUT A$

LOOP UNTIL A$="1"

PRINT "Enter the number 1";

LINE INPUT A$

LOOP WHILE A$<>"1"

Program 27 - Test at Bottom Do Loop In Qbasic

Test at Top Do Loops

Sometimes it is useful to perform a test at the top to prevent a loop from executing. An example of this would be in a math-related program that must rely on a variable being a certain value before the equation will work [division for instance]. The format of the loop is exactly the opposite of the test at bottom loops, as expected. The do is followed by the clause and also by the expression and the loop is left by itself. The following program shows a test at top loop that assumes that an illegal input has been entered beforehand.

DO WHILE a$<>"B"

PRINT "Incorrect Value"

PRINT "Please Press B"

LINE INPUT A$

LOOP

DO UNTIL a$="B"

PRINT "Incorrect Value"

PRINT "Please Press B"

LINE INPUT A$

LOOP

Program 28 - Test at Top Do Loop in Qbasic

While Loops

Qbasic also supplies a while loop, but it is essentially the same as the test at top do while loop. It is included in the do loops for completeness.

The format of this loop is similar to the do loops except that the do while is replaced by while and the word loop is replaced by wend [i.e. while end]. This loop is shown below.

WHILE a$<>"B"

PRINT "Incorrect Value"

PRINT "Please Press B"

LINE INPUT A$

WEND

DO WHILE a$<>"B"

PRINT "Incorrect Value"

PRINT "Please Press B"

LINE INPUT A$

LOOP

Program 29 – While Loop in Qbasic

Infinite Loops in Qbasic

Infinite loops are useful in many cases and are sometimes done accidentally. An infinite loop is a loop that never ends and they can be created using any of the Qbasic loops.

By using a for loop and setting the step equal to zero, an infinite loop can be created. By using the do-while [top or bottom test], or while-wend loops, a infinite loop can be created by making sure the expression is always true. By setting the expression to false, the do-until loop also becomes an infinite loop. The following programs show infinite loops.

FOR j=1 to 100 STEP 0

NEXT j

a=0

LOOP WHILE a=0

DO UNTIL a<>a

LOOP

WHILE 1

WEND

Program 30 - Infinite Loops in Qbasic

Ending Loops Prematurely in Qbasic

It is sometimes useful to exit a loop before it ends. For example, if an unexpected error occurred and there was no way to recover, it would be best to exit the loop, let the user know an error occurred and exit the program. With the exclusion of the while loop, the command exit can be used followed by the type of loop. The following program illustrates both exiting a for loop as well as a do loop.

FOR J=-5 TO 5

IF J=0 THEN EXIT FOR

PRINT 20/J;

NEXT J

X=0

DO WHILE X<50

X=X+1

IF X=20 THEN EXIT DO

PRINT X

LOOP

Program 31 - Exiting Loops in Qbasic

For Loops in C/C++

    The for loop in C/C++ is similar to the for loop in Qbasic, except the for loop in C/C++ is more versatile than it is in Qbasic. In C/C++, the for loop is a counting loop but it can also be used in more advanced topics such as moving between objects [near the end of the book you'll learn this].

    The for loop in C/C++ has three parameters, the same three that are used in Qbasic, the initiation, count, and incrementer. All of the parameters in the C/C++ for loop are enclosed in a set of parenthesis ( () ), similar to how an expression is enclosed in parenthesis in the C/C++ if statement. Besides all the parameters being enclosed in parenthesis, each parameter must be separated by a semicolon (;).

    The first parameter of the for loop is the variable initiation. This is similar to the variable initiation in the Qbasic for loop. It is also common to declare the for loop variable within the loop initiation itself, but the variable's scope is only within that for loop.

    The second parameter is a logical condition or expression, similar to what would be seen in a while statement. The for loop will exit when the while statement is false. In Qbasic, the C/C++ for statement expression would be considered to be a test at top do-while loop.

    The third parameter is the incrementer or decrementor. This tells the loop how much to increase or decrease the variable by on each time through the loop. The loop variable should be specified along with how much it should be incremented or decremented by. For instance, if the loop's variable is J and to increase it by 1 each time through the loop, use J+1 [a common alternative to using J+1 is to use J++ and use J—for J-1].

    Most for statements in C/C++ are usually block for statement, so just as with the if statement, enclose the sequence of statements within braces ( { } ) after the for loop.

The following C++ program shows a for loop that counts from 1 to 5. As with the if statement, the for loop does not require an include directive.

#include <iostream.h>

int main()

{

for(int j=1;j<=5;j++)

{

cout<<j<<endl;

}

return 0;

}

Program 32 - Simple C/C++ For Loop

As with most languages, for loops in C/C++ can also be nested. For loops can be nested just like if statements. The following program shows a nested for loop that produces a multiplication table from 1 to 5.

#include <iostream.h>

int main()

{

for(int j=1;j<=5;j++)

{

for(int k=1;k<=5;k++)

{

cout<<j*k<<" ";

}

cout<<endl;

}

return 0;

}

1 2 3 4 5

2 4 6 8 10

3 6 9 12 15

4 8 12 16 20

5 10 15 20 25

Program 33 - Nested For lops in C/C++

C/C++ for loops can also be used as timer loops, just like in Qbasic. In C/C++, the for loop just needs to be followed by a semicolon. The following example shows a timing delay loop in C/C++.

for(int j=0;j<100000;j++);

Program 34 - C/C++ Time delay for loop

Do Loops in C/C++

Unlike Qbasic, C/C++ only has a single version of the do loop and it is similar to Qbasic's test at bottom do-while loop. The format of the loop is the word do, followed by a sequence of statements, then the word while followed by the expression enclosed in parenthesis and then finally a semicolon. The following example illustrates the C/C++ do-while loop.

#include <iostream.h>

int main()

{

int a=0;

{

cout<<"Enter the number 1";

cin>>a;

}

while (a!=1);

return 0;

}

Program 35 - C/C++ Do-while Loop

While loops in C/C++

C/C++ offers a loop similar to the while-wend loop in Qbasic. This loop is simply called the while loop. This is a test at top loop. The loop is created by using the while statement followed by an expression within parenthesis, like the do-while loops in C/C++ and then followed by a sequence of statements. The following program illustrates the while loop.

#include <iostream.h>

int main()

{

int a=0;

cout<<"Enter the number 1";

cin>>a;

while (a!=1);

{

cout<<"Please Enter the number 1";

cin>>a;

}

return 0;

}

Program 36 - C/C++ While loop

Infinite Loops in C/C++

Infinite loops are useful in many cases and are sometimes done accidentally. An infinite loop is a loop that never ends and they can be created using any of the C/C++ loops.

By using a for loop and setting each of the parameters to nothing [just putting 2 semicolons within the parenthesis], an infinite loop can be created and also an infinite loop can be created by incrementing the variable by nothing. By using the do-while, or while loops, a infinite loop can be created by making sure the expression is always true. The following program segments show infinite loops.

for(;;)

{

cout<<"1";

}

{

cout<<"Here";

}

while(1);

while(1)

{

cout<<"Goodbye";

}

for(int j=0;1;)

{

cout<<"Hello";

}

Program 37 - Infinite Loops in C/C++

Ending Loops Prematurely in C/C++

It is sometimes useful to exit a loop before it ends. For example, if the programmer designed an infinite loop to retrieve data from the user but the user does not wish to enter any more data, the loop would have to end prematurely. To end any type of loop in C/C++, the break command should be used. Program 38 illustrates the use of the break command to prematurely end loops.

#include <iostream.h>

int main()

{

for(int j=-5;j<=5;j++)

{

if(j==0) break;

cout<<20/j<<endl;

}

int x=0;

while(x<50)

{

x=x+1;

if (x==20) break;

cout<<x<<endl;

}

return 0;

}

Program 38 - Exiting Loops in C/C++

Conclusion

Decision statements come in two major categories, the branch statement and the loop statement.

In Qbasic and in C/C++, the branch statement is similar to the English if statement. The branch statement has an if part that tests whether a condition is true or false, if the condition is true, it does the then part of the statement, if it is false, it does the else part of the statement. If statements can also be blocked or in other words have multiple commands on the then or the else part of the statement or on both. If statements can also be compound or nested within each other. Table 27 shows a comparison of the Qbasic and C/C++ if statements.

Type	Qbasic	C/C++
Simple	IF a=1 THEN PRINT a	if (a==1) cout<<a;
Simple	IF a=2 THEN PRINT a+2 ELSE PRINT b	if (a==2) cout<<a+2; else cout<<b;
Block	IF b=5 THEN PRINT c b=c ELSE PRINT b END IF	if (b==5) { cout<<c; b=c; } else cout<<b;
Block	IF b=5 THEN PRINT c ELSE PRINT b c=b END IF	if (b==5) cout<<c; else { cout<<b; c=b; }
Block	IF b=5 THEN PRINT c b=c ELSE PRINT b c=b END IF	if (b==5) { cout<<c; b=c; } else { cout<<b; c=b; }
Nested	IF b=5 THEN IF c=1 THEN PRINT B PRINT c ELSE b=c END IF ELSE PRINT b c=b END IF	if (b==5) { if (c==1) { cout<<c; cout<<b; } else b=c; } else { cout<<b; c=b; }
Simple w/ else if	IF b=2 THEN PRINT c ELSEIF c=2 THEN PRINT B	if (b==2) cout<<c; else if (c==2) cout<<b;

Table 27 - Qbasic and C/C++ If Statements

Loops are useful for doing repetitive tasks such as counting or doing a series of steps until something happens. There are three main types of loops in Qbasic and in C/C++, the for loop, the do loop, and the while loop. In Qbasic, the do loop has the option of being a test at top or test at bottom loop, whereas in C/C++, the do loop is only a test at bottom loop. The while loop in both languages is a test at top loop. The three loops are shown in Table 28 in both of the languages.

Both languages allow for breaking out of a loop before the loop condition becomes false. In Qbasic, the exit command will exit out of a loop and in C/C++, the break command will exit out of a loop. These are also illustrated in Table 28.

Loop can also be designed to never end or be infinite. Infinite loops are useful in games or in cases where an unknown amount of information will be retrieved. Table 28 also describes infinite loops.

Type	Qbasic	C/C++
For loop	FOR J=1 TO 10 PRINT J NEXT J	for(int j=1;j<=10;j++) { cout<<j<<endl; }
For loop with non-default increment and premature exit	FOR J=-5 TO 5 STEP .5 IF J=0 THEN EXIT FOR PRINT 20/J NEXT J	for(float j=-5;j<=5;j+.5) { if(j==0) break; cout<<20/j<<endl; }
For loop with decrement	FOR J=10 TO 1 STEP -1 PRINT J NEXT J	for(int j=10;j>=1;j--) { cout<<j<<endl; }
Infinite For loop	FOR J=1 TO 10 STEP 0 PRINT J NEXT J	for(int j=1;j<=10;j+0) { cout<<j<<endl; }
Infinite For loop	n/a	for(;;) { cout<<"Hello"<<endl; }
Infinite For loop	n/a	for (int j=1;;) { cout<<"Hello"<<endl; }
Infinite For loop	n/a	for (;1;) { cout<<"Hello"<<endl; }
Test at Top While	DO WHILE a<>1 PRINT "Incorrect Value" PRINT "Please Press 1" INPUT A LOOP	int a=0; while (a!=1) { cout<<"Incorrect Value"<<endl; cout<<"Please press 1"; cin>>a; }
Test at Bottom While	DO PRINT "Enter number 1"; INPUT A LOOP WHILE A<>1	int a=0; do { cout<<"Enter number 1"; cin>>a; }while(a!=1);
Test at Top Until	DO UNTIL a=2 PRINT "Incorrect Value" PRINT "Please Press 2" INPUT A LOOP	int a=0; while (a!=2) { cout<<"Incorrect Value"<<endl; cout<<"Please Press 2"; cin>>a; }
Test at Bottom Until	DO PRINT "Enter 1"; INPUT A LOOP UNTIL A=1	int a=0; do { cout<<"Enter 1"; cin>>a; }while(a!=2);
While Loop	WHILE a<>2 PRINT "Incorrect Value" PRINT "Please Press 2" INPUT A WEND	while (a!=2) { cout<<"Incorrect Value"<<endl; cout<<"Please Press 2"; cin>>a; }
Infinite While Loop	DO LOOP WHILE 1	do { }while(1);
Infinite Until Loop	DO LOOP UNTIL A<>A	do { }while(a==a);
While Premature exit	n/a	int a=0; while(1) { a++; if(a>=50) break; cout<<a; }
Do Premature exit	DO X=X+1 IF X=20 THEN EXIT DO PRINT X LOOP WHILE x<50	int x=0; do { x=x+1; if(x==20) break; cout<<x; }while(x<50);

Table 28 - Qbasic and C/C++ Loop Statements

Problems

Write a program to calculate the sum, difference, product, quotient, and remainder of two numbers from the user. Be sure the user knows exactly what to input (i.e. use a prompt). Continue doing this program until the user enters -1 and -1 for the input.

Modify Problem 1 to calculate the logical and and logical or of two numbers given by the user. Be sure to use a prompt. Force the user to enter only binary values of 0 or 1. If the user wishes to exit, allow -1, -1 to exit the program.

Write a program that counts from 1 to 50 and then from 50 to 1. Print out each line of output on a line by itself.

Intro to Computer Programming - Chapter 6: Communicating with the Computer

2010-02-26T17:53:00.001-05:00

Introduction

As stated in Chapter 4, one of the most common things a computer can do is print information to the screen. The next most common thing a computer does is ask the user for input.

Input has many places it could come from. It could come from the keyboard, the mouse, the sound card, a touch screen, modem, a file, among many others. The most common of these is the keyboard. This chapter will deal with keyboard based input from the user.

Keyboard input with Qbasic

Qbasic has several keyboard input statements. The two most common for most programs is the input statement and the line input statement. Both of these commands wait for the user to press the enter key before it accepts any information from the user. After the user presses enter, the information is then transferred into a variable for later processing.

Input Statement

    The input statement is one of Qbasic's most versatile of keyboard input commands. It allows the programmer to request multiple pieces of information from a user and automatically checks to see that the entered data was valid. The input statement also allows the programmer to include a prompt along with the request for information.

    The input statement allows the programmer to use multiple variables by using the same input statement. For example, if the programmer wanted an integer, a string, and a float entered, one input statement could be used. The way the statement is formed is by putting the statement input followed by a list of variables, each separated by a comma (,), that will hold what the user typed in. After the enter key is pressed, Qbasic automatically verifies the information to make sure the user actually typed a number when a number was requested instead of a string. If the user accidentally put the wrong type of information for an input, Qbasic will ask the user to redo the input by printing the words "Redo from Start" on the screen and it will ask again for the input from the user. It will continue to do this until the user inputs the correct information.

    The input statement has several options that can be included. These include a prompt, keeping on the same line, and inserting a question mark after the prompt.

The first option that can be used is the use of a prompt. A prompt can be included in the input statement so that the user will know what information is requested by the program. The prompt is simply enclosed in quotes after the input statement, just as is done with the print statement. Notice that the prompt can not be any type of expression but must be a string. The prompt must also come before the input variable list. You may ask why isn't the prompt just printed using a print statement, the answer is because if the user enters the incorrect information, the prompt will not be displayed again unless it is part of the input statement.

The second option is the ability to continue on the same line. This is similar to the way the print statement can stay on the same line after it displays its output. The option is also similar to the print statement in that a semicolon (;) is used. With the print statement, the semicolon is used after the output, but in the case of the input statement, the semicolon must be directly after the input command and before the prompt, if there is one.

The third option is the ability to automatically include a question mark (?) after the prompt. This option is automatically performed if a prompt is not included in the statement. The way to prevent a question mark from appearing as part of the prompt is to place a comma between the prompt and the input variable list. If a question mark is requested, the programmer should place a semicolon between the prompt and the input variable list.

The user of a program that uses the input statement should know that numbers should not contain commas because the comma is considered to be a delimiter. A delimiter is any character or set of characters that marks the end of a word, number, or phrase (for example, the delimiters for words are spaces, and most punctuation symbols excluding the apostrophe (')). With the input statement, commas are always considered to be a delimiter for both numbers and for strings (with the input statement, a string can not contain a comma unless the string is enclosed in quotes). So, for example, if the user enters the numbers 45,167 the computer would accept the 45 as the first input and the 167 as the second. If the computer was expecting only one number, it would request the user to enter the information again which could possibly frustrate the user.

Also, when the program is expecting a number, symbols other than numbers, negative or positive signs, or the decimal point are illegal. For instance if the program is asking for how much the user makes per hour and the user enters $4.75, the program would reject the input because the dollar sign is an illegal symbol for a number.

The following program and dialog between the computer and user demonstrate the uses of the input statement.

INPUT "What is your name";A$

PRINT "Hello, ";A$;"."

INPUT "Enter 2 numbers separated by commas:",A,B

PRINT A$;", ";"the sum of";A;" and";B;" is";A+B

PRINT "I would like to calculate about how much your"

PRINT "next paycheck will be."

PRINT "How many hours did you work the past 2 weeks?";

INPUT ;"",hours

PRINT " at how much per hour";

INPUT wage

PRINT A$; ",";"you will be getting paid approximately";

PRINT "$";hours*wage

What is your name?
Joe

Hello, Joe.

Enter 2 numbers separated by commas: 4, 8

Joe, the sum of 4 and 8 is 12

I would like to calculate about how much your

next paycheck will be.

How many hours did you work the past 2 weeks? 40 at how much per hour? 5.75

Joe, you will be getting paid approximately $ 230

What is your name?
Doe, John

Redo from start

What is your name?
John Doe

Hello, John Doe.

Enter 2 numbers separated by commas: 4, 8, 7

Redo from start

Enter 2 numbers separated by commas: 7, 5

John Doe, the sum of 7 and 5 is 13

I would like to calculate about how much your

next paycheck will be.

How many hours did you work the past 2 weeks? 4 at how much per hour? $6.00

Redo from start

at how much per hour? 6.00

John Doe, you will be getting paid approximately $ 24

Program 16 – Qbasic Input Demonstration

Line Input Statement

In comparison to the input statement, the line input statement is very limited in its uses. This limitation has its advantages though. The line input statement has no options and also is only able to input strings. The advantage to this is that line input does not respond to any delimiters with the exception of the enter key so any character is allowed to be entered and the program will not come back and say "Redo from Start".

Program 17 demonstrates the use of the line input statement.

LINE INPUT A$

PRINT A$

"Hello, how are you doing?"

"Hello, how are you doing?"

Program 17 - Qbasic Line Input Program

Keyboard input with C

    Once again, the complexity of C raises its ugly head with keyboard input as it did with the printf command, which hasn't yet been completely covered. The keyboard input command for C is just as complex as its output function printf.

    The scanf function is C's version of keyboard input. It is very similar in style to the printf function. With the scanf function, the type of the variables to be inputted must be specified by using a type specifier.

    Because the scanf function is only input, it cannot display any information on the screen, but the command format is similar to the printf function in that the type specifiers are enclosed in quotes, and after the quotes are a list of the input variables. One difference between the printf function and scanf functions is that the input variables of the scanf function must be preceded by an ampersand (&) [at least at this point in the book]. The reason for the ampersand will be explained in a later chapter.

The type specifiers of the scanf (and printf) functions are preceeded by a percent sign (%) and then the specifier itself. The following table lists the type specifiers for the scanf and printf functions (notice that the percent sign is already included). One difference between the printf and scanf type specifiers is that the scanf type specifiers should be preceeded by a space.

Type Specifier	Description
%d	Integer
%f	Floating point number
%e	Floating point in scientific notation (for printf)
%g	Shortest of either floating point or scientific notation (for printf)
%c	Character
%s	String [don't use yet!]

Table 24 – Scanf and printf type specifiers

As with most of C/C++'s functions, an include file must be specified in order to allow the program to use scanf. The include file for scanf is the same as it is for the printf function, stdio.h.

The scanf function is unlike the Qbasic input command in that it does not do any checking of what the user typed in as input nor does it automatically create a prompt for the user. Both of these tasks must be accomplished by the programmer. The scanf function [with the information you know so far] can also only input a single character, unlike the input or line input commands of Qbasic which can input words or entire lines of characters. The scanf function is similat to input in that the user must press enter or return before the computer will accept the input.

The following program demonstrates the use of the scanf and printf statements.

#include <stdio.h>

int main()

{

int j;

char t;

float y;

int a1,b1;

printf("Please enter an integer:");

scanf(" %d",&j);

printf("Please enter a non-integer number:");

scanf(" %f",&y);

printf("Please enter a character:");

scanf(" %c",&t);

printf("You entered the integer number %d\n",j);

printf(" the non-integer number %g\n",y);

printf(" the character %c\n",t);

printf("\n");

printf("Please enter 2 integer numbers separated by a space:");

scanf(" %d %d",&a1,&b1);

printf("The sum of %d and %d is %d\n",a1,b1,a1+b1);

return 0;

}

Please enter an integer:4

Please enter a non-integer number:1.5

Please enter a character:x

You entered the integer number 4

the non-integer number 1.5

the character x

Please enter 2 integer numbers separated by a space:1 4

The sum of 1 and 4 is 5

Program 18 - Scanf and printf example program

    Notice how the type specifiers can be "chained" together in both the printf and scanf statements. In the printf function, the type specifiers do not require a space between them but the scanf function requires a space [technically the space is not required but is recommended to prevent input problems].

    Just as wish Qbasic, the scanf statement includes automatic delimiters of space, comma, and enter.

    It is the programmer's responsibility to check the input that the user typed to make sure that it is valid. For example, the user could type in a decimal point (.) instead of a number and scanf will continue without warning, or the user could've entered a floating point number instead of an integer. The programmer needs to be aware that scanf does not check the data that has been entered. The next chapter will explain some ways of how to check for valid data.

Keyboard input with C++

    Once again, C++ is a mixture of the advantages of C and Qbasic combined. The cin statement in C++ is similar to the printf statement in C in that a prompt is not outputted automatically and that the data is not checked for the correct type. The cin statement has the advantage of being simplier than the C printf function in that the type specifiers are not used and the cin statement's structure is similar to that of the print statement in Qbasic.

    In an earlier chapter, you learned that the cout statement uses the double-less-than operator (<<) between the cout statement and the requested output. The cin statement is similar in that it uses the opposite operator, the double-greater-than (>>) between the cin statement and the variables used for input. As with the cout statement, the operators can be chained together.

    The cin statement falls under the same category as the cout statement and therefore requires the same include file, iostream.h, to be included in the program.

    Just as with the input statement and scanf function, the cin statement includes delimeters of space, comma, and enter. Also, just as the scanf statement, the input is not checked for correctness nor correct type therefore the programmer must ensure the user entered the correct data.

    The following program illustrates the general use of the cin statement. At this time, as with scanf, strings are not able to be used by cin.

#include <iostream.h>

int main()

{

int j;

char t;

float y;

int a1,b1;

cout<<"Please enter an integer:";

cin>>j;

cout<<"Please enter a non-integer number:";

cin>>y;

cout<<"Please enter a character:";

cin>>t;

cout<<"You entered the integer number "<<j<<endl;

cout<<" the non-integer number "<<y<<endl;

cout<<" the character "<<t<<endl;

cout<<endl;

cout<<"Please enter 2 integer numbers separated by a space:";

cin>>a1>>b1;

cout<<"The sum of "<<a1<<" and "<<b1<<" is "<<a1+b1<<endl;

return 0;

}

Please enter an integer:4

Please enter a non-integer number:1.5

Please enter a character:x

You entered the integer number 4

the non-integer number 1.5

the character x

Please enter 2 integer numbers separated by a space:1 4

The sum of 1 and 4 is 5

Conclusion

    Each language has some sort of command to get input from the user, the most common type of input being input from the keyboard. The commands seen so far have required the user pressing the enter key in order to tell the computer the user was finished entering data.

    The input command in Qbasic is very versatile in that it allows for automatic prompting of the user as well as inputting various types of data such as integers and strings. It also does a check to verify that all data is at least the correct type.

    The line input statement in Qbasic is useful for inputting strings that could contain commas or other types of punctuation that could be considered a delimiter when used with the input command. It does not allow automatic prompting.

    The scanf function in C is similar to the printf function in its command structure. A quoted string of type specifiers (shown in table 24) describes the input and a list of variables follows the string. The scanf function does not check the user inputted data against the type specifiers nor does it allow for automatic prompting. The scanf statement also requires an ampersand before the names of the variables and a space should separate the type specifiers within the input string.

Type Specifier	Description
%d	Integer
%f	Floating point number
%e	Floating point in scientific notation (for printf)
%g	Shortest of either floating point or scientific notation (for printf)
%c	Character
%s	String [don't use yet!]

Table 25 – Scanf and printf type specifiers

The cin statement is similar to the cout statement except it uses the double-greater-than operator (>>) between the cin and the variables. The cin statement also does not check the input to verify that it is the correct type requested by the program nor does it allow for automatic prompting.

Problems

Write a program to calculate the sum, difference, product, quotient, and remainder of two numbers from the user. Be sure the user knows exactly what to input (i.e. use a prompt).

Modify Problem 1 to calculate the logical and, logical or, bitwise and, bitwise or, and bitwise xor of two numbers given by the user. Be sure to use a prompt.

Write a program to set x equal to the remainder of a1 and a2, set y equal to the quotient of b1 and b2 and set z equal to the sum of x and y (the sum should not equal 0!). Print out each variable as well as a prompt on a line by themselves. The values of a1, a2, b1, and b2 should be given by the user.

Intro to Computer Programming - Chapter 5: Working with numbers

2010-02-26T17:52:00.000-05:00

Introduction

A computer's strength is in computing solutions to expressions. An expression can be something as simple as 1+1 to as complex as. [Don't expect me to explain that one to you! {it's not complete anyway!}]. Expressions are made up of numbers, operators, variables, and possibly functions. Numbers have already been covered in an earlier chapter. Operators, variables, and also some common math related functions will be covered in this chapter.

Operators

Introduction

Anyone who has used addition, multiplication, subtraction, or division has used an operator. An operator is a device used to convert one thing into another thing. In modern math, operators normally come between one thing and another. For example, the addition operator (+) comes between two numbers such as in 2 + 2. In modern math, we use the symbols + for addition, - for subtraction, × for multiplication (or · in algebra), and ÷ for division. In addition to the common four operators, we use parenthesis ( ( ) ) to indicate one thing has precedence over something else and we also use superscript numbers (ex: ²) to indicate a number to a power (2³=8) and the root sign () is used to show the root of a number. The operators that deal with numbers are called numerical operators.

In addition to general math, computers also deal with logic. Logic deals with whether something is true or false. Most languages have a set of logical operators that deal with the evaluation of logical expressions. For instance, say that A is true and B is true, then A AND B is true. The most common logical operators are and, or, not, and exclusive or. The logical operators return a value of true or false to indicate the solution to the logical expression.

Computers also can tell if one value is less than (<), equal (=), or greater than (>) another value. These operators are called relational operators. Relational operators tell the relationship from one value to another. These operators also return true or false depending upon the value of the expression.

In addition to numerical operators, logical operators, and relational operators, a computer can also deal with the logical operators on a bit level. Sometimes it is useful to find out of a certain bit is set or cleared and these bit-wise operators are useful for this task. Qbasic does not directly support the bit-wise operators.

Numerical Operators

Most programming languages have each of these common math operators but the symbols may be different. For instance, multiplication in most programming languages is the star (* {shift-8}). Addition and subtraction are usually the normal symbols of + and – respectively. Division is usually the forward slash (/). Parenthesis are usually the same as in modern math.

The power operator and the square root operator are usually different from one language family to another. For example, in Qbasic, the power operator is the caret (^) and the root operator is also the caret. In C and C++, neither the power operator nor the root operator exist as operators but they exist as functions. Table 9 lists the common numerical operators in Qbasic and C/C++.

Math operator	Qbasic	C/C++
+ (addition)	+	+
- (negation)	-	-
- (subtraction)	-	-
× (multiplication)	*	*
÷ (division)	/	/
modulus (remainder)	mod	%
power	^	n/a
(root)	^	n/a

Table 9 - Math operators and Qbasic/C/C++ equivalents

Most of the operators in the above table should be familiar as most are common math operators. The one operator that needs a little explanation is the modulus operator. The modulus operator is a way of finding the remainder of two numbers as if they had been divided. For instance, a normal division of 5 and 2 (5/2) is equal to 2.2 or 2 with a remainder of 1. The modulus operator gives us 1 as the answer to 5 mod 2 since the remainder of 5/2 is 1. There is actually a formula that can be used to find the modulus of two numbers and the steps for this formula are in Figure 2 (a is the first number, b is the second number).

1. Divide a by b (ex: 5/2=2.2)

2. Subtract the answer by the answer after dropping the decimal

(ex: 2.2-2)

3. Multiply the answer from step 2 by b and drop the decimal (.2*2=1)

Figure 2 - Modulus Calculation Steps

Logical Operators

    Every modern day computer is based on electronic circuits called gates. These gates deal with pure logic of zeros and ones. The gates do a math similar to modern day math except with different rules. There are roughly sixteen of these gates and most of them have names. The most common of these gates are and, or, not, and exclusive or (xor).

    Most of these gates are familiar to us as English speaking humans. For instance, if a person has a car and has a house then we know that that person has both a car and a house and does not just have one (such as only a car). The only two that are different than our English are or and xor.

The or in English means that a person can do one thing or something else but does not mean that a person can do both. For instance if a person says you could have an apple or an orange you must choose between the two but you can not have both. This is not the case in the gate version of or. Or in terms of gates means the same thing and and/or does in English in that a person can have an apple and/or an orange.

Our English interpretation of or is the same as the gate version of exclusive or or xor. Xor means one or the other but not both.

The not gate basically reverses the logic. For example, if a person has not a house and not a car [excuse the poor English, just go with it as it is] then we say that person does not have a house nor a car.

Instead of sentences, these gates use electronic voltages to indicate the value of a statement. Most of the time these values are either 1 or 0 or in other words they are binary. Each of these gates and their values can be placed into a table that indicate what a value will be upon a certain input. For instance, the value of 1 and 1 (or true and true) would equal 1 (true) but 1 and 0 would equal false. The following tables illustrate each of the common gates as well as their output values given a set of input values.

bAND01a000101Table 10 - AND gate

bOR01a001111Table 11 - OR gate

bXOR01a001110Table 12 - XOR gate

NOTa0110Table 13 - NOT gate
    It should be noted that all of the logical operators require two inputs, just as the general math operators do, with the exception of the not operator.
    In C/C++, any number other than zero is true and zero is always false. In Qbasic, only 1 and -1 are allowed for true and any other number is false. On output, C/C++ will give 1 for true and 0 for false but Qbasic will give -1 or 1 for true and 0 for false.
    In Qbasic and C/C++, these gates or logical operators can be used on a set of inputs. In Qbasic, the logical operators are exactly the same name as the gates they represent, but in C/C++ they are completely different. Table 14 lists the logical operators and their equivalent in the C/C++ language (notice that xor is not included because it does not directly exist as a logical operator).
Gate/logical operatorC/C++ EquivalentAND&&OR|| (double bar)
[same key as backslash]NOT!Table 14 - Logical operators and C/C++ equivalents
Relational Operators
    Relational operators are used to tell if one thing is less than, equal to, or greater than something else. These operators are useful to tell how one number compares to another or even how strings or characters relate to each other. Table 15 shows the relational operators in Qbasic and C/C++.
OperatorQbasicC/C++less-than<<less-than or equal<=<=greater-than>>greater-than or equal>=>=equal===
(two equal signs)not equal<>!=Table 15 - Relational Operators in Qbasic and C/C++
    Notice how Qbasic uses the equals operator for equals but C/C++ use a double equals. This is very important to remember as you'll see shortly. Also notice how Qbasic uses <> for not equals but C/C++ use !=. For C/C++ this actually makes sense as ! is the symbol for the not operator.
Bitwise Operators
    The bitwise operators are used in C/C++ and many other languages to tell if a certain bit is set (1) or cleared (0) or to produce a different number by setting or clearing specific bits. The bitwise operators can also be used to create encryption and decryption routines.
    The bitwise operators are not available in Qbasic but are available in C/C++ and are listed in the following table. Notice how the bitwise operators are similar to the logical operators.
Bitwise OperatorC/C++ EquivalentAND&OR| [same key as backslash (\)]XOR^Table 16 - Bitwise operators and C/C++ Equivalents
Order of Operations
    In math, the order that the operators are completed in makes a big difference in the answer. For example, 2+4*3 can be done two way, the first way gives 18 [addition first], the second way gives 14 [multiplication first], but which way is correct? According to modern day algebra, the second way is correct and the correct answer to 2+4*3 is 14 not 18. The reason for this is because multiplication and division are done first and addition and subtraction are done last. If there are two of the same level of operations then the left most operation should be done first (ex: 2*3*4 should be 2*3 first and then 6*4 second), this is called left associative. This ordering of the operands is called the order of operations. This ordering can be modified by using parenthesis such as (2+4)*3=18 and the 18 is correct in this instance.
    Programming languages also have an order of operations but this ordering is much more complex because any operator, numerical, logical, relational, or bitwise, can be used in an expression and in any combination. This ordering is also made a little more complex due to the fact that some operators are left associative and some are right associative (rightmost first). Of course, parenthesis can change the order of operations. Table 17 shows the order of operations for Qbasic and for C/C++.

OperatorQbasicC/C++LevelAssociativityNOTNOT!1RightNegative--1RightPower^n/a2LeftMultiply**3LeftDivide//3LeftRemainderMOD%3LeftAdd++4LeftSubtract--4LeftLess than<<5LeftLess than or Equal <=<=5LeftGreater than>>5LeftGreater than or Equal >=>=5LeftEqual===6LeftNot Equal<>!=6LeftBitwise ANDn/a&7LeftBitwise XORn/a^8LeftBitwise ORn/a|9LeftLogical ANDAND&&10LeftLogical OROR||11LeftLogical XORXORn/a12LeftAssignment==13RightTable 17 - Order of Operations for Qbasic and C/C++
Examples
    The following table demonstrates the operators covered in this section and the output from Qbasic and C/C++. In this table, 1 will equal true and 0 will equal false. Notice the order of operations for complex expressions. [line breaks in this table are not intentional but are the result of the equation being too long to fit in the box on a single line].
General
ExpressionQbasic
ExpressionC/C++
ExpressionAnswer2+4*822+4*8^22+4*(8*8)
[power n/a]2581 or not 0 and 11 OR NOT 0 AND 11||!0&&111 xor 11 XOR 1n/a0134 bitwise and 128n/a134&1281280+1 and 1-1 or 128
-(150 bitwise and 127)n/a0+1&&1-1||
128-(150&127)15 bitwise xor 3n/a5^366 bitwise xor 5n/a6^535÷05/05/0Illegal.
Division by zero
error!5<=10 and 5=>15 or 10<7
and 3>0
and not (15*3<18*2)
and 5=5
or 5 modulus 3=15<=10 AND 5>=15
OR 10<7 AND
3>0 AND NOT
(15*3<18*2) AND
5=5 OR 5 MOD 3=15<=10 && 5>=15
|| 10<7 &&
3>0 && !
(15*3<18*2) &&
5==5 || 5 % 3==105 and 25 AND 25 && 20 (Qbasic)
1 (C/C++)Table 18 - Example Expressions in Qbasic and C/C++
Variables
Introduction
    Just as operators are used in general math, variables are used in modern algebra. A variable is a letter, symbol, or word used to take the place of a number or expression. For example, in the expression x+4=8, the letter x is used to take the place of the number 4 (or possibly the expression 2+2 or even 22). In computers, variables are used to hold information for later retrieval or to perform more calculations.
    Most programming languages restrict a variables name. The variable must start with a letter and must not contain any punctuation or spaces. The length of a variable must also be between 1 and 127 characters. A variable name also must not be equal to the same name as a statement of that language. For example, in Qbasic, a variable can not be the named print because one of Qbasic's statements is named print.
    In math, variables usually hold a number or something that could eventually become a number. In computers, a variable can be a number, a string, a picture, among many other things. Since the computer does not know which type of information a variable will contain, the computer must be told what type of variable to create. Telling the computer what type a variable is is called declaring a variables type. The different types a variable can have is determined by the programming language being used, but the most common types are integers, characters, and floats.
    In addition to declaring a variables type, the programmer must also declare a variables scope. The scope tells where the variable will be known within the program. As a comparison, the English language's scope is only within the countries that speak English whereas a laugh is within the global scope (anyone in the world can understand what a laugh is, even little babies).
    It is sometimes useful to say that a certain variable must stay the same throughout a program to keep from accidentally changing its value. Forcing a variable to remain the same is called making the variable constant. Numbers are usually considered to be constants since a number can never change its value (the number 5 cannot change to the number 7 for instance, but the letter x could stand for 5 or for 7 and could change at any time). Some uses for constants are the values of pi (π), the gravitational constant, number of ounces in a pound, and so on.
    In most programming languages, variables, once changed, can not be changed back to what they previously were. For example, if the variable x contains 5 and later is changed to 10, the 5 is permanently erased and x will equal to 10 and not 5. There are a few ways around this limitation as will be seen in another chapter. One easy way is to copy the variable into another variable before it is changed.
Declaring Variables in Qbasic
    Qbasic, as stated in the last chapter, is a beginners language and therefore is fairly easy on the programmer in declaring variables. Qbasic does not require all variables to be declared and it automatically sets a value to each variable when it is first used [many languages do not do this for the programmer].
    In Qbasic, the programmer only has to give a variable a name and the language will automatically declare the variable as a single precision type [unless overridden] when the variables is first used and will set the variable equal to 0.0. What if the programmer did not want a single precision variable but wanted an integer instead? This is where the variable type specifiers come into play.
    A variable type specifier tells a language what type the variable will be. In Qbasic, a variable can be an integer, single precision, double precision, long integer, string, or fixed-length string. The variable type specifier in Qbasic is a symbol added to the end of the variable that tells Qbasic what type the variable is. The symbols are the percent sign (%) for integers, dollar sign ($) for strings, number sign (#) for double precision, exclamation point (!) for single precision, and ampersand (&) for long integers.
    Variables are usually assigned a value when they are first created even though in Qbasic this is not necessary unless the programmer wants a variable to have a specific value. Assigning a variable to a value can be done by using the equals operator (x=5 for instance sets x equal to 5). A word of caution, the variable being assigned a value must be on the left of the equals sign by itself. This is different from math where a variable could have an equation on the left side of the equals (example, x+4=8).
    Qbasic offers six different variable data types, four of which are numerical and two of which deal with strings. The four numerical data types are integers, longs, single, and double and the two non-numerical data types are variable length strings and fixed length strings.
Integers in Qbasic are signed 16-bit numbers and are the fastest of the data types that Qbasic can handle. The variable type specifier for the integer is the percent sign (%). These variables are automatically initialized to 0 when they are created.
    Long integers in Qbasic are signed 32-bit numbers and are slower than integers but faster than the other numerical data types that Qbasic offers. They are also initialized to 0 and the variable type specifier for long integers is the ampersand (&).
    Single precision numbers are the default type for variables created in Qbasic. They are also one of the slowest in calculations. They are 32-bits long and are floating point numbers. Upon creation, they are initialized to 0.0. The exclamation point (!) is the variable type specifier for single precision numbers.
    Double precision numbers are the slowest of the Qbasic data types. They are 64-bit floating point numbers and they are initialized to 0.0 upon creation. Their variable type specifier is the number sign (#).
    Qbasic offers two non-numerical data types and both of them deal with strings of characters.
The first type of string is the variable length string (string for short) and its variable type specifier is the dollar sign ($). Variable length strings can contain anywhere from 0 up to 32,767 characters and are usually used for processing text. They are automatically initialized to null [meaning nothing or blank]. When giving a string a value, the information must be enclosed in quotes (a$="Hello", not a$=Hello) otherwise Qbasic will think the value is a variable and not a string. [note that if the programmer intends to assign one string variable to another, do not include the quotes].
The second type of strings that Qbasic offers is the fixed-length string. Fixed length strings are fixed to a maximum specified size and they are not able to go above this size. The fixed length string is more complex and will be covered later as it does not have a variable type specifier. They are automatically initialized to null as well. Fixed length strings are normally used for database applications or for advanced file access.
    Qbasic also allows the creation of constant variables. In order for a variable to be constant, the command CONST must be before the name of the variable and the variable must be initialized to a specific value. Once the variable is declared constant it can not be changed.
    The scope of Qbasic variables is harder to explain and will be covered when the scope comes into play. It can be assumed that all variables up to and including this chapter are global.
The following table demonstrates declaring variables in Qbasic. Note that each box represents a completely different program and does not depend upon a previous box's contents.
StatementCommentPRINT xx will be declared by Qbasic as
a single precision variable and will
contain 0.0 but will be printed as 0.x$="A"x will be declared as a string and
will contain the capital letter A.x=5x will be declared as a single
precision variable and will contain
the number 5.x=y

y=3x and y will be declared as single
precision variables (y will be
declared first and be set to a
value of 0.0). x will be set to the
value of y and both will contain 0.0.
y will equal 3. Note that x does
not change just because y did.x%=0.9x will be declared as an integer an
will contain the value 0. Note that
the decimal is dropped and not rounded.x="A"x will be declared as a single precision
variable and Qbasic will attempt to
assign the capital letter A to it but will
fail and will give a type mismatch error.x$=yx will be declared as a string variable
and Qbasic will attempt to assign
the newly created single precision y
variable to it but will fail and will
give a type mismatch error.x&=x%+1x% will be declared and initialized
to 0, 1 will be added to x% and
that value will be assigned to x&.
Notice how two variables have the
exact same name but different types,
this is allowed in Qbasic but is NOT
recommended.x=x+1The x variable on the right will be
declared as a single precision
variable and will be initialized
to 0. 1 will be added to it and
the sum will be assigned to the
x variable on the left of the
equals. Notice that this statement
is not allowed in normal math but
is perfectly legal in programming.
This in a sense increases x by 1.CONST pi=3.14

pi=3Creates a single precision variable
called pi that is declared constant
and is initialized to 3.14.
Generates a duplicate definition
error since pi is declared constant.Table 19 - Qbasic Variable Declaration Examples
Declaring Variables in C/C++
    Unlike Qbasic, C and C++ both requires all variables to be declared and it also requires all variables to be initialized. One of the common mistakes most programmers make is the use of uninitialized variables. The C/C++ language does not set a newly created variable to any specific value but leaves the value so it is the sole job of the programmer to do this. Again, C/C++ requires all variables to be declared and it does not have a default type for undeclared variables as all variables must be specifically declared.
C/C++ has several numerical variable data types but only one non-numerical type. The numerical variable types that C/C++ support are bytes, short integers, integers, floats, longs integers, doubles, and Booleans. The non-numerical type that C/C++ supports is the character. All of these data types in C/C++ can be signed or unsigned but defaults to signed values.
Unlike Qbasic, the C/C++ variable type specifiers come before the name of the variable and must include a space between the variable type specifier and the variable name. Table 20 shows the variable type, their normal sizes, and the variable type specifiers.

TypeSize
in bitsVariable Type
Specifierbyte8byteshort integer16shortinteger32
(depends
on processor)intlong integer64
(depends
on processor)longfloat32floatdouble64doubleBoolean1
(depends
on compiler)boolcharacter8charTable 20 - C/C++ Variable Type Specifiers
    The main difference between Qbasic and C/C++ variable initialization is the initiation of the char type. In Qbasic, strings are initialized by putting the information in quotes ("). In C/C++, the char type is initialized by inserting the information in single quotes (') [same key as double quotes (")] instead of double quotes. Another interesting thing to note about the char type is that it can be assigned a number instead of a character. In this case, the number would represent the ASCII code for a specific character. When printed, the character would be displayed but in mathematical formulas the character would be treated as if it were a number.
    In C/C++, a variable can be declared signed or unsigned. To do this, the word signed or unsigned must come before the variable type specifier. The default for all of C/C++'s types is signed.
    Variables in C/C++ can also be declared constant and are declared constant the same way Qbasic variables are declared constant. The word const must come before the sign specifier and before the variable type specifier. As in Qbasic, the variable must be initialized upon creation and is not allowed to be changed.
    The scope of a variable within C/C++ is more easily defined than it is in Qbasic. In C/C++, a variable's scope is only between the opening brace ({) that comes before it and the matching closing brace (}). If the programmer wishes to create a global variable, the variable must be declared outside of any brace pairs [preferably at the beginning of the program after the include directives]. Global variables are the exception to the initialization rule in that they are automatically initialized to a default value, similar to the way Qbasics variables are initialized. Global variable are frowned upon in programming.
The following table demonstrates declaring variables in C/C++. Note that each box represents a completely different program and does not depend upon a previous box's contents. Also note that most of these are not complete programs but only segments of code.
ProgramCommentsint x;Creates a signed integer
variable named x. Note
that the variable contents
are unknown and could
change each time the program
is executed!unsigned short y=0;Creates an unsigned short
variable named y and it is
initialized to 0.double y=1.4;
int x=0;
x=y;Creates a signed double
variable named y and
initializes it to 1.4
Creates a signed integer
variable named x and
initializes it to 0.
Compiler will give a
warning saying that y is
not an integer [possibly
an error]. A type cast should
be used (see function section){
int x=1;
{
cout<<x;
}
}Since the cout is after the
declaration of x and since x
is within the same scope as the
cout, a 1 will be printed.{
int x=1;
}
{
cout<<x;
}Compiler will give an undeclared
variable error since x is outside
the scope on the cout statement.const unsigned double pi=3.14;Creates a constant unsigned
double variable named pi
and is equal to 3.14. Note that
pi can not be changed otherwise
the compiler will give an error.int x=1;
double x=5;Compiler will give an error
saying that x is already declared.char v='A';
char x=66;
cout<<v<<endl;
v=v+2;
cout<<x<<endl;
cout<<v;Creates two character variables,
one named v and one named x
and initializes both of them,
v to the capital letter A and
x to the ASCII code 66 [letter
B]. Prints out the contents of
v, adds two to v and then prints
out the contents of x, then prints
the contents of v. Program
prints A B and C [each letter
on a separate line].int a;
a=1;Creates an signed integer
variable named a. The variable
a is not initialized until the
second line.int x, y;Creates two signed uninitialized
integers x and y.int x=0, y=1;Creates two signed integers,
x and y and initializes x to 0
and y to 1.int x,y;
x=15;
y=(x==15);Creates two signed uninitialized
integers x and y. Assigns 15 to x.
Checks for equality between x and 15
(i.e. does x equal 15). Sets y equal
to 1 (true) since x equals 15.int x,y,z;
z=5;
x=y=z;Creates three signed uninitialized
integers x, y, and z. Sets z=5.
Sets y equal to z then sets x equal to y.int x=1;

int main()
{
cout<<x<<endl;
}Creates a global signed integer variable
and initializes it to 1. Since it is global,
the cout is able to print out its value.Table 21 - C/C++ Variable Declaration Examples
    One important thing to remember in C/C++ is the difference between equals (=) and double equals (==). In C/C++, the equals sign assigns a value to a variable such as in x=5. The double equals, on the other hand, tests for equality such as to see if x does equal 5. The equality operator is a relational operator and therefore gives a 1 or 0 back. The equals operator is an assignment and it gives the value on the right of the equal sign back. Common programming mistakes happen because the programmer put an assignment operator equals in place of the relational operator double equals.
Functions
    Functions are formulas or equations that take one or more values and gives one value back. High school Algebra has functions such as the absolute value of a number. The absolute value function take one number, such as -5, and gives back its positive form, in this case 5. Trigonometry is another section of mathematics that contains many functions such as the sine, cosine, and tangent of an angle.
    Most programming languages also contain functions, most of which work on numbers such as the absolute value, sine, and logarithm. Most languages also contain functions that work on strings such as the length of a string or the left or right of a string.
    Both Qbasic and C/C++ have a subsection of math functions that can be used in expressions to perform a calculation. Most math related functions only require one number, or parameter, and all will give back, or return, a single number. Table 22 shows a list of common math related functions in Qbasic and in C/C++ and also what the functions return. Variables x and y are used as inputs to the function. Note that if these functions are used in C/C++, the math.h file must be included in the program using the #include directive.

Function nameQbasicC/C++DescriptionAbsolute value(x)ABS(x)abs(x)Returns the absolute value of x.
If x<0 then it returns the positive
version of x.Sign(x)SGN(x)n/aReturns -1 if x<0, 0 if x=0 and 1 if x>0.Sine(x)SIN(x)sin(x)Returns the sine of x. x must
be in radians not degrees.Cosine(x)COS(x)cos(x)Returns the cosine of x. x
must be in radians not degrees.Tangent(x)TAN(x)tan(x)Returns the tangent of x. x
must be in radians not degrees.Logarithm(x)LOG(x)log(x)Returns the log10 of x.Power(x,y)n/apow(x,y)Returns xySquare Root(x)SQR(x)sqrt(x)Returns the Random(x)RND(x)rand(x)Returns a pseudo random number.
Qbasic and C/C++ differ on the
meanings of x.Convert to integer(x)CINT(x)int(x)Convert x into an integer.Convert to double(x)CDBL(x)double(x)Convert x into a doubleConvert to single(x)CSNG(x)float(x)Convert x into a floatTable 22 - Common Math Functions in Qbasic and C/C++
Conclusion
    Expressions when used in a program are similar to equations in math in that they both have numbers, operators and possibly functions. As in math, each operator also has a specific precedence level that it must obey in order to get the correct answer to an expression and these precedence levels can be overridden by the use of parenthesis.
    Variables are used in expressions just as variables are used in formulas. Variables in programs are slightly different in that the variable on the left of the equals sign is not used as part of the expression and therefore statements such as x=x+1 are legal and can be solved or evaluated.
    There are many different functions in most languages, several of which perform math related functions such as absolute value and sine. Functions take in parameters and give back, or return, a value related to the parameter.
    Some examples that summarize this chapter are included in the following table. Note that many of the C/C++ solutions are not complete programs but are code segments.
EquationQbasicC/C++Value(1+1)*(5+3)PRINT (1+1)*(5+3)cout<<(1+1)*(5+3);1628+3PRINT 2^8+3#include <math.h>

int main()
{
cout<<pow(2,8)+3;
return 0;
}259Abs(-20)-20PRINT ABS(-20)-20#include <math.h>

int main()
{
cout<<abs(-20)-20;
return 0;
}0x=true
y=false
z=not(x)
x and y and zx=1
y=0
z=NOT(x)
PRINT x AND y AND zbool x=1;
bool y=0;
bool z=!(x);
cout<<(x&&y&&z);0x=5
y=4
(x/y-int(x/y))*yx=5
y=4
PRINT (x/y-cint(x/y))*yint x=5;
int x=4;
cout<<((x/y-int(x/y))*y);1x=1
y=5
Does x+4=y?x=1
y=5
PRINT x+4=yint x=1;
int y=5;
cout<<(x+4==y);1Table 23 - Sample Expressions in Qbasic and C/C++
Problems
What are the solutions to the following expressions:
2+1*8x+9=1 (Qbasic)-1*5-(5+2)1 and 4 (Qbasic)2&10int(.25)*42|5abs(-25)*42^7 (xor)pow(2,3)sgn(-19)*sgn(12)+sgn(0)x=y=z=w=2 (C/C++)What are the values of x, y, and z in the following code segments? [each box represents a different program]
int x;int x, y, z;
x=y=z=-1;x%=0x+1+yPRINT Y$int x;
x=x+1;x+y!y=1 and not 0short x=0;
int y=x;
x=5;int x=1;
int y=5;
int z=x*y+z;Write a program to calculate the sum, difference, product, quotient, and remainder of 5 and 2.
Modify Problem 3 to calculate the logical and, logical or, bitwise and, bitwise or, and bitwise xor of 5 and 7.

Write a program to set x equal to the remainder of 5 and 3, set y equal to the quotient of 4 and 7 and set z equal to the sum of x and y (the sum should not equal 0!). Print out each variable as well as a prompt on a line by themselves.

Besides the and, or, and xor gates in electronics there are nand gates, nor gates, and nxor gates. These gates are the exact opposite of the and, or, and xor gates. Write a program to produce the nand, nor, and nxor gates and verify that they work correctly. Produce a complete table for each gate. [the input a must equal 0 and 1, and b must equal 0 and 1]. {warning, this program will be large}

The table below lists several variable names. Which of these variables is illegal and in which languages?

hi	1.1	Name1
maximum	and	city and state
print	cout	address
port20	'name	Color_blue
file.extension	program21	1st

Intro to Computer Programming - Chapter 4: Communicating with the User

2010-02-26T17:51:00.000-05:00

Chapter 4: Communicating with the User

Introduction

One of the most common and basic of things a computer program can do is print information to the screen. With the exclusion of sound output, output to the printer, or graphics, information printed to the screen is the only way to communicate with the user. Every language (with the exclusion of assembly) has at least one specific command to print information to the screen, most have several.

Nearly all of the commands of the HTML language are for displaying information in one form or another, whether it be in the form of text, audio, or in the form of graphics. This is an advantage when displaying pre-processed information is the only thing the computer needs to deal with, but this is not usually the case. For instance, in HTML alone, the programmer cannot ask the user for two numbers and add them together. In other words, HTML cannot do any type of information processing. This is where the other computer languages such as BASIC, C++, and Java come in.

The next most common task that a computer does is ask the user for information and then process that information. For instance, the older computers when turned on would ask the user for the current date and time and then they would act upon that information accordingly. Even with modern computers running the Windows Operating System, the computer is constantly displaying information, asking the user for input, and doing background processing of the input.

In an attempt to keep the programs simple at first, I'll only explain how to do text output and input. The more advanced topics such as sound and graphics will be covered at a later time.

Displaying Text in Qbasic

Introduction

    Qbasic is one of the easier languages to write programs in. Qbasic is based on the BASIC family of languages. The BASIC language itself was created in the late 1960's for beginners so they could learn how to program (BASIC stands for Beginners All-Purpose Symbolic Instruction Code).

Unlike other languages, including HTML, Qbasic does not require any special requirements such as the requirements at the beginning or end of the program (like HTML requires the <html> and </html> tags at the beginning and end of the program). With Qbasic, the programmer can just start solving the problem. Qbasic also is not an extremely strict language in that commands do not have to be capitalized and the language is not case-sensitive (for example, Name is the same thing as NAME and name).

    Qbasic programs do require the Qbasic interpreter, which is included on the enclosed CD under the Qbasic directory. Microsoft created Qbasic as a free version of their compiler called QB. The only difference is that any program created in Qbasic must be run within Qbasic because Qbasic must interpret each of the commands into something the computer can understand (similar to how a Spanish interpreter interprets English into Spanish). QB, on the other hand, converts the program straight into a language the computer can understand so the program can be ran from Dos or from within Windows without the need for QB. Any programs written in Qbasic will also work correctly in QB without problems, but not necessarily the other way around.

    There are at least two main reasons why Qbasic is not used to do much programming. The first reason is because Qbasic is extremely slow in processing information. The main reason for this is because it is an interpreted language and the process of interpreting one language into another is always slow, even when talking about human spoken languages. The other reason why Qbasic is not used much is that it has limits as to how large the programs can be and how much data the program can handle. Qbasic can only handle programs up to 64 kilobytes (one kilobyte is equal to 1,024 bytes) or roughly 64 typed pages. Many programs are in order of several thousand typed pages long and Qbasic would not be able to even load the program, must less run it.

The Print Statement

In Qbasic, the Print statement is used to display text to the screen. It can be used to print strings, numbers, and even the answers to formulas. The format of the command is the command itself [i.e. PRINT] followed by what the programmer wishes to print. If the programmer wants a certain piece of information printed "as is", the information must be enclosed in quotes (" "). To print a blank line, use a print statement by itself with nothing after it. See Program 7 for examples of the print statement.

PRINT "Hello"

PRINT 2.14

PRINT 2+2

PRINT "2+2"

PRINT –2

PRINT 2/.5

PRINT 2.0

Hello

2.14

2+2

-2

Program 7 - Qbasic Program Showing Print Statement and Output

    Qbasic is one of the few languages that actually helps its programmers out by giving them shortcuts. One of the most famous shortcuts in the Qbasic is instead of always typing PRINT for each print statement, the programmer can just type a question mark and Qbasic will replace the question mark automatically with the print command. Also helpful is the way Qbasic automatically capitalizes its commands as the programmer types them.

    Notice that each print statement prints its output on a single line and then automatically goes to the next line. If the programmer wishes to keep the output of the next print statement on the same line, just add a semicolon (;) to the end of the statement and Qbasic will keep any more output on the same line. Another use of the semicolon option is to string several print statements into a single statement. This could be useful if the type of data is different or if variables are involved (will explain variables in the next chapter).

    Another useful option with the print statement is the comma (,). The comma is used just like the semicolon except that the comma adds a 16-space tab along with keeping everything on the same line. The comma option is useful for doing tables.

It is also useful to notice that positive numbers have a space inserted in front of them, but negative numbers to not have this additional space. There is a way to get rid of this additional space, but you'll have to wait a couple chapters for the solution to that problem J.

The next program shows the use of the semicolon option as well as the question mark shortcut. Notice how the words "is" and "Raleigh" do not have a space between them. This is because the information enclosed within quotes is printed exactly as it is within the quotes. To correct this apparent error, just add a space between the word is and the end quotation mark or before the quotation mark and the word Raleigh.

? "The sum of 2+2=";2+2

? "The capital of North Carolina is";

? "Raleigh";" with a population of";

? 200000

The sum of 2+2= 4

The capital of North Carolina isRaleigh with a population of 200000

Program 8 - Qbasic Program Showing the use of ; and ?

The print statement will come in handy in other forms of output in the Qbasic language. You'll see the print statement again at a later time.

Displaying Text in C

Introduction

    The C language is what some consider to be a professional language. Most of todays programs are written in C or C++ (C++ is an advanced version of C). C is not a beginners language like BASIC is but it doesn't suffer from the same restrictions as BASIC suffers from such as program size limits or data size limits. For instance, the Windows Operating System is written mainly in C and C++ and contains several million lines of code.

    In order to write and compile C programs, the programmer must have a C compiler such as Microsoft Visual C++, Bloodshead's DevC++, or the GNU C compiler (the latter two are free). The Bloodshead DevC++ compiler is located on the CD under the DevC directory.

Unlike Qbasic, C is not an interpreted language but it is a compiled language. This means that the compiler itself is not required after the first compile. In other words, once the translation to the computer's native language is finished, it does not have to be translated again unless the program is changed. This allows C compiled programs to be extremely fast when they are executed.

    C, like HTML and most other programming languages, has a minimum requirement for all of its programs. This requirement does have a few parts that can be changed, but the beginning C programmer will not usually need these advanced features. The requirements for C are exactly the same as those for its advanced version, C++. Program 9 shows the minimum C/C++ program. It is best to ignore what each line in Program 9 does at this time as each line will be explained later.

int main( )

{

return 0;

}

Program 9 - Minimum C/C++ Program

Unlike Qbasic, C is case sensitive in both its commands as well as variables. This means that main is not the same thing as Main or MAIN. This is a common error for many beginning programmers.

Formatting is also fairly specific in C. Nearly every line in C will require a semicolon at the end of the line. There are a few exceptions and these will be covered in a later chapter. Think of the requirement of the semicolon in C to be like the requirement of a period at the end of a sentence in the English language. For now, just follow the examples on the uses of the semicolon placement. They'll be explained soon.

The printf Function

The C command to print information to the screen is somewhat similar to the print statement in Qbasic. The printf function, with a few exceptions, will print text that is enclosed in quotes exactly as is, just like Qbasic. The prinf function will also print numbers, but it requires some special formatting commands in order to work correctly. Unlike print in Qbasic, printf automatically keeps all information on the same line unless told otherwise (this is the exact opposite of Qbasic).

There is one requirement to add to the program before the printf statement can be used, #include <stdio.h>. This additional line of code only needs to be added once and should be added at the beginning of the program. The reason this additional line of code must be added is because C is a very small language and only has about 30 statements in the language [In comparison, Qbasic has over 200 statements]. In C, statements are automatically included in the language, but functions are not included unless you specifically tell C to add the function by using the #include directive. As an example, let's say someone is trying to cook a specific kind of cake and they have ten different recipe books, all of which have different cakes in them and the recipe they want is in only one of these recipe books. They would either have to search through all the books manually, be told by someone else which book its in, or look at an index. The easiest way is for someone else who already knows the recipe books to tell them which book the specific cake recipe is located in (maybe the cook is in a hurry and needs the recipe quickly). This is the case with the C language, the language (more specifically the compiler itself) must be told where the function is located. In our case, the printf function is located in the file stdio.h. The #include directive will be covered in depth later. Program 10 demonstrates the printf statement and the #include directive.

#include <stdio.h>

int main ( )

{

printf("This is C.");

return 0;

}

This is C.

Program 10 - Simple printf Statement

The printf function allows special formatting characters within quoted information. As a contrast, Qbasic prints the quoted information exactly as is. These special formatting characters force the printf statement to force a new line, insert a tab, among several others. The most common of these are forcing a new line (\n) and the tab (\t) character. Table 4 lists some of the special formatting characters that are available within the quoted text of the printf function and Program 11 demonstrates how they can be used in printf statements.

Format Character	Meaning in C
\n	Insert a new line
\t	Insert a tab
\\	Print out a \
\"	Print a "

Table 4 - Printf format characters

#include <stdio.h>

int main( )

{

printf("The capital of North Carolina is");

printf("Raleigh\n");

printf("\tThis sentence has a tab in front\n\n");

printf("\n");

printf("The file is located in C:\\My Files\n\n");

printf("C is \"fun\"\n");

return 0;

}

The capital of North Carolina isRaleigh

This sentence has a tab in front

The file is located at C:\My Files

C is "fun"

Program 11 - printf statement with format characters

The printf function can print numbers but it requires more formatting characters in order to do it. [What, did you actually expect C to be as easy as Qbasic? L Just wait, C++ is easier than C, I promise!] In order to print numbers, a format specifier must be used. This feature of the printf function will be covered later in this chapter.

Displaying Text in C++

Introduction

    As stated earlier, the C++ language is just an advanced version of C. This does not necessarily mean that C++ I harder to learn than C, but it mainly means that C++ has advanced features, some of which make the language easier to understand and some that make it harder to understand.

    Just like C, C++ is also not a beginners language and also just like C, C++ does not have the program size limits like BASIC does. A C++ compiler must also be used to compile the C++ programs such as Visual C++, Blodshead's DevC++, or the GNU C++ compiler (Bloodshead DevC++ is included on the CD).

    C++, like C and most other programming languages, has a minimum requirement for all of its programs. The requirements for C++ are exactly the same as those for C. Program 12 shows the minimum C/C++ program. It is best to ignore what each line in Program 12 does at this time as each line will be explained later.

int main( )

{

return 0;

}

Program 12 - Minimum C/C++ Program

Like C, C++ is case sensitive in both its commands as well as variables. This means that main is not the same thing as Main or MAIN. This is a common error for many beginning programmers.

Formatting is also fairly specific in C++. Nearly every line in C++ will require a semicolon at the end of the line. There are a few exceptions and these will be covered in a later chapter. Think of the requirement of the semicolon in C++ to be like the requirement of a period at the end of a sentence in the English language. Not all sentences in English have a period after them, some have a question mark or an exclamation mark. For now, just follow the examples of semicolon placement. They'll be explained soon.

The cout Statement

The cout statement in C++ is similar to the Qbasic print statement and it is also similar to the C printf function. The cout statement prints quoted text similar to the way the C printf function does in that the cout statement uses the C formatting characters for new line, tab, and so forth (see Table 5). This is different from the Qbasic print statement as quoted text is printed exactly as is. The cout statement does differ from the C printf function in that numbers are easily printed, just as they are in Qbasic (i.e. no special formatting characters are required) [see, told you C++ is easier than C, at least cout will let you print numbers easily J]. Basically, the cout statement combines the best of C's printf function and Qbasic's print statement into one statement [kind of].

Format Character	Meaning in C++
\n	Insert a new line
\t	Insert a tab
\\	Print out a \
\"	Print a "

Table 5 - Cout format characters

Just like the printf function in C required the #include directive, so also does the cout statement in C++. The cout statement is located in the iosteam.h file so the #include statement should look like #include <iostream.h>. It should be noted that just because cout is a statement, C++ must still be told where to find cout. This is because the cout statement is not part of the C++ language.

Because the cout statement is a statement and not a function, it does not require a set of parenthesis like the printf function requires, but it does require another form of punctuation known as the double less-than operator (<<). The double less-than operator is required for each piece of data to be outputted to the screen. For example, if the programmer wanted to print a word, then a number, and then another word using only one cout statement, then the cout would require three double less-than operators. An example of this is shown in Program 13. This same program can also be written by using three separate cout statements but this still requires three double less-than operators as shown in Program 14.

#include <iostream.h>

int main( )

{

cout<<"2+2="<<4<<".";

return 0;

}

2+2=4.

Program 13 - C++ Program showing use of cout double less-than

#include <iostream.h>

int main( )

{

cout<<"2+2=";

cout<<4;

cout<<".";

return 0;

}

2+2=4.

Program 14 - C++ Program showing use of cout Statements

There are two main things to notice about the cout statement. First, if you remember the output from the Qbasic print statement, you'll remember that any non-negative numbers had a space before them. This space is removed in C++ by using the cout statement (there is still a way to get rid of the space in Qbasic). The second thing to notice is how everything is automatically printed on the same line as is done in C with the printf statement. To change this, the formatting characters must be used in the printed output. The following program demonstrates the use of the cout statement with these formatting characters. Also, notice in the program how the letters "endl" (which stands for end line) can be used to simulate using "\n" outside of quoted text.

#include <iostream.h>

int main()

{

cout<<"2+2="<<2+2;

cout<<endl<<endl;

cout<<"The capital of North Carolina is";

cout<<"Raleigh\n"<<"with a population of";

cout<<200000<<endl;

return 0;

}

2+2=4

The capital of North Carolina isRaleigh

with a population of200000

Program 15 - C++ program showing cout statements

Conclusion

Each language in this chapter (Qbasic, C, and C++) has a specific statement or function to display information to the screen. In Qbasic, the print statement is used. In C the printf function can be used and in C++ the cout statement can be used to display information. A comparison of the languages so far and also a comparison of the display statements is shown in Table 6. A comparison of programs is shown in Table 7.

QBasic	C	C++	Output
PRINT "Hello"	printf("Hello\n");	cout<<"Hello\n";	Hello
PRINT "Hello";	printf("Hello");	cout<<"Hello";	Hello
PRINT 2+2;	n/a	cout<<2+2;	4 (in Qbasic) 4 (in C++)
PRINT -4;	n/a	cout<<-4;	-4
PRINT "A";"B"	printf("A"); printf("B"); printf("\n");	cout<<"A"; cout<<"B"; cout<<endl;	AB

Table 6 - Language Comparison

Purpose	Qbasic	C	C++
minimum program		int main() { return 0; }	int main() { return 0; }
program with command used in this chapter	PRINT "Hello"	#include <stdio.h> int main() { printf("Hello\n"); return 0; }	#include <iostream.h> int main() { cout<<"Hello"<<endl; return 0; }

Table 7 - Program Comparison

The print statement in Qbasic prints quoted text as is without any special formatting and can also display numbers. It automatically prints all information on a line by itself unless told otherwise by use of the semicolon or the comma options. The semicolon option forces the print statement to print the next piece of information on the same line while the comma option inserts a 16-space tab. The shortcut for typing the print statement is the question mark (?).

In C, the printf function can print quoted information. Special formatting codes can be inserted within the quoted text and printf will act on these formatting characters. Printf can also display numbers but is more complicated than Qbasic's print statement. Printf will print all information on the same line unless told otherwise by the carriage return special characters (\n). A list of special formatting characters is shown in Table 8. In order for printf to be used within a C program, the stdio.h file must be included.

Format Character	Meaning in C++
\n	Insert a new line
\t	Insert a tab
\\	Print out a \
\"	Print a "

Table 8 - C/C++ Special Formatting Characters

The cout statement in C++ is similar to the printf function as well as the print statement. Cout will print quoted text as printf and uses the same formatting codes (see Table 8). Cout also has the capability of printing numbers easily, as the print statement in Qbasic can do. Similar to printf, the cout statement prints all information on the same line unless specified otherwise by the carriage return code (\n) or the end line code (endl). In order for the cout statement to be used within a C++ program, the iostream.h file must be included.

Problems

[What, you thought I was going to let you get out of doing some problems? Yeah, right! J They'll be fairly easy, I promise…at least for now J]

Since there were three languages covered in this chapter, each of these problems should have three answers, one for each language unless otherwise specified. Also, assume that the problem requires a complete program unless the problem states otherwise. Also, the quotes in the problem dictate the desired output therefore do not include the quotes in the program output.

Write a program to print "Hello" on the screen on a line by itself.

Write a program to display the sum of 4+8 on the screen in the languages that allow displaying numbers on the screen.

Modify problem 2 to display a prompt as well as the output. Keep the prompt and output on the same line. [Hint: A prompt is a description of the output, in this case the prompt is "4+8="]

Write a program to display the numbers from 1 to 5 on the same line. For languages that require it, insert a space between each number.

Do problem 4 using only a single print statement or the equivalent.

Write a program to display the numbers from 5 to 10 on the same line. In addition, display the numbers 1 to 5 on a line by themselves and then finish the program by displaying the numbers 5 to 10 on the same line. [Hint: This should look similar to a box except the right side will be missing]

Write a program to display the numbers from 1 to 25 using a tab between each number. Use between five and eight rows to display the numbers.

Intro to Computer Programming - Chapter 3: Beginning HTML

2010-02-26T17:50:00.000-05:00

Introduction

    One of the easier programming languages at this time is the Hypertext Markup Language (HTML). HTML is usually only used for creating web pages for the Internet and it is very limited in what it can do. Most do not really consider HTML a programming language, but rather a text formatting language. This is partially why I'm covering it first, along with it being fairly easy to learn.

    Anyone can create web pages from scratch using a simple text editor such as Microsoft Windows' Notepad program. No special software is needed to create web pages. In order to view the web page, though, a web browser such as Netscape Communicator or Microsoft Internet Explorer is needed.

    HTML has a minor problem in that each computer could display the web page slightly different. With HTML alone there is no easy way of forcing the program to display the same on every computer.

Also another problem with HTML is that it cannot solve problems such as adding two and two together! HTML is used to display text, tables, and pictures and also allows for "links" between other HTML pages but does not allow much more than that.

HTML Programming

Program Requirements

HTML has a few requirements for its programs. First, the program extension must be either htm or html so the web browser can process the program correctly. Second, the program must contain at least the start and end tags of <html> and </html> at the beginning and end of the file. Other than those two requirements, the programmer can use any commands or text however is required to solve the problem.

As stated above, the minimum HTML program must contain at least the <html> and </html> tags. This is illustrated in Program 1. Notice how each tag is on a separate line. This is not a requirement for the language, but helps programmers read the program a little easier.

Program 1 - Minimum HTML Program

Program Heading and Titles

The heading of a HTML program contains general information about the program. This information is usually not displayed as part of the document except in the case of the title. The heading tags are <head> and </head>. The heading is usually at the very beginning of the document and does not contain many commands between the tags.

The most common tag that is used within the head tags are the title tags <title> and </title>. The title of a HTML program is usually displayed at the top of the web browser as part of the browser's own title bar. For instance, viewing the following page in Internet Explorer would make the title of Internet Explorer to become "Hello – Microsoft Internet Explorer".

<html>

<head>

<title>

Hello

</title>

</head>

</html>

Program 2 - HTML Program Showing the Title Tag

The heading of a HTML program is not very useful as it can not display much except for a title. The body of a HTML program is where most of the information is contained.

Program Body

Just as the body of a written letter contains the content of a letter, the body of a HTML program contains all the content of the program. To specify the body of a HTML program, use the tags <body> and </body>. The body of a HTML program can contain as much text or any other tags (excluding <html>, <head>, and <title>) as the programmer needs.

Any text that is within the body of the program will be displayed within the web browser as is with no formatting unless it has been modified with a tag. Program 3 shows how the body tags are used within a program to display text within the web browser.

<html>

<head>

<title>

Hello

</title>

</head>

<body>

This text will be displayed in the browser window.

</body>

</html>

Program 3 - HTML Program Showing the Body Tag

Headings

The HTML language has six levels of headings that are indicated by the tags <h1>, <h2>, <h3>, <h4>, <h5>, and <h6> and each one has an associated end tag. HTML does not force the programmer to use the headings in any particular order. Some browsers, such as Netscape and Internet Explorer, make the text smaller as the number of the heading tag gets larger. Program 4 demonstrates the use of the heading tags and the web browser output of the program.

<html>

<head>

<title>

Hello

</title>

</head>

<body>

<h1>A level one heading</h1>

<h2>A level two heading</h2>

<h3>A level three heading</h3>

<h4>A level four heading</h4>

<h5>A level five heading</h5>

<h6>A level six heading</h6>

</body>

</html>

A level one heading

A level two heading

A level three heading

A level four heading

A level five heading

A level six heading

Program 4 - HTML Program Showing Heading Tags and Associated Output

Paragraphs, Line Breaks, and Preformatted Text

    Text within HTML programs is automatically flowed together until something forces it to being a new paragraph. Two of the ways to force text to break are the paragraph (<p>) and line break (<br>) tags. Another way to force text to be exactly the way the programmer intended is to use the preformatted tag (<pre> and </pre>). Program 5 demonstrates the use of all three of these tags.

    The paragraph tag is used to indicate the start of a new paragraph. Most browsers add a blank line when encountering the paragraph tag.

    The line break tag causes the current line to break, similar to the paragraph tag, but does not insert a blank line between the test before the tag and the text after the tag.

    The preformatted tag forces the browser to display the text exactly as it was entered in the program. In this format, spaces and line breaks are preserved and the text is not automatically flowed together as normally. Notice that this tag also has an associated end tag.

<html>

<head>

<title>

Beginning HTML

</title>

</head>

<body>

The paragraph tag is used to indicate the

start of a new paragraph. Most browsers

add a blank line when encountering the paragraph

tag.<p>The line break tag causes the current

line to break,<br> similar to the paragraph tag,

<pre>

but does not insert a blank line between the

test before the tag and the text after the

tag. The preformatted tag forces...

</pre>

</body>

</html>

The paragraph tag is used to indicate the start of a new paragraph. Most browsers add a blank line when encountering the paragraph tag.

The line break tag causes the current line to break,
similar to the paragraph tag,

    but does not insert a blank line between the

    test before the tag and the text after the

    tag.  The preformatted tag forces...

Program 5 - HTML Program Showing Paragraph and line breaks and Preformatted output

Text Formatting

The HTML language has several tags that allow the programmer to format specific sections of text. The type of formatting that is allowed by HTML is similar to the formatting options supported by modern day word processors. This includes bold (<b>), italic (<i>), and underline (<u>). Each of these tags also have an associated end tag. These tags can also be combined to produce formats such as bold italic (<b><i>).

HTML also allows the programmer to center text or images by using the center tag (<center> and </center>).

Images

It is common for programmers to include images and pictures in their HTML programs to display a concept to a viewer of their web pages. The image (<img src>) tag is used for this purpose. The image can be either of GIF or JPG format and are displayed along with the text.

The image tag is slightly different from the other tags in that it requires more information along within the tag. This tag requires at least the filename and web address of the image to be included. For example, to include an image called "bird.jpg" into the web page, the image tag would be <img src="bird.jpg">.

Horizontal Lines

Sometimes the programmer wishes to separate one section of a page from another. One of the more common ways of doing this is to use a horizontal line to separate the sections. The tag to draw a horizontal line is <hr>.

Hypertext Links

One of the most common tags in the HTML language is the hypertext link tag (<a href> and </a>). This tag allows the viewer of the web page to link to another document. This "other document" can be another web page, an image or movie, or even a sound.

The hyperlink tag is similar to the image tag in that it requires other information in order to work correctly. The information this tag requires is the web address (URL) and/or filename of the document to be linked to. The tag also allows a text description of what the link goes to. The next program will demonstrate the hypertext link as well as the other features of the HTML language covered so far.

<html>

<head>

<title>

My Web Page

</title>

</head>

<body>

<center><h1>Favorite Web Sites</h1></center>

<a href="http://www.microsoft.com">Microsoft Corp</a><p>

<a href="http://www.intellicast.com">Intellicast Weather</a>

<hr>

<center><h2>ECU's Todd Dining Hall</h2></center>

<center>

<img src="http://www.ecu.edu/images/horiz_l/todd_day.jpg">

</center>

<hr>

<b>Microsoft</b>, <b>Intellicast</b>, and <b>ECU</b> are

<b><i><u>not</u></i></b> responsible for the contents of this web page

and are <b>only</b> used as examples of how HTML tags can be used.

</body>

</html>

Favorite Web Sites

Microsoft Corp

Intellicast Weather

ECU's Todd Dining Hall

Microsoft, Intellicast, and ECU are not responsible for the contents of this web page and are only used as examples of how HTML tags can be used.

Program 6 - Final HTML Program

Other Tags

The HTML language is not a complex language but it is fairly large and it is still evolving. If you wish to learn more about HTML, the web is the best place to learn about the language. There are also some good books available that cover the language more in depth.

Intro to Computer Programming – Chapter 2: Basic Computer Terminology

2010-02-26T17:49:00.000-05:00

Chapter 2: Basic Computer Terminology

Introduction

As stated earlier, computers have added many new terms to the English language. More specifically, programming languages have also added many terms to the language or have added new definitions to their meanings. Before going into different programming languages, there are a few terms that must be understood that are common to most all computer languages. The programmer should realize that most of these terms are related to math in some form as computers are based solely on math, more specifically binary math.

The Binary Number System

    Computers are based solely on math. Due to how computers are produced, they can only really deal with two numbers, 0 and 1. This style of numbering is called the binary number system (in math terms it is considered base-two). An individual digit of a binary number is called a bit (a bit is the smallest number a computer can deal with). Before explaining binary, I'll explain how humans deal with numbers.

    Humans normally deal with the decimal number system (in math the decimal system is considered to be base-ten). The decimal number system has ten numbers in it, 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9. The way we use this numbering system is we look at the rightmost digit and count to the left. For instance, if there are 4 digits (1000 for example), then the number must be in the thousands and that number must be somewhere between 1,000 and 9,999. We were taught in elementary school that the rightmost digit is the ones position, the one to the left is the tens position, and so forth. What is actually happening is we are calculating higher powers of 10 (the base according to mathematicians) as we go to the left. If you're confused, just bare with me and let me explain and show you how this works.

    The rightmost digit corresponds to 10⁰ which is equal to 1 (any number to a zero power is equal to one [don't ask me why, just trust me and remember it J]). The digit to the left of that one is equal to 10¹ which equals 10. The next one is equal to 10² (10x10) which is equal to 100. The forth digit from the right is equal to 10³ (10x10x10) which is 1,000. See Table 2 to see how the decimal system calculates one million.

1,000,000	100,000	10,000	1,000	100	10	1
10⁶	10⁵	10⁴	10³	10²	10¹	10⁰
1	, 0	0	0	, 0	0	0

Table 2 - Powers of 10

    Notice that so far we have only calculated a number that has a one as the leftmost digit and all other digits are zero. This is basic to understanding how humans figure out what a number is. The next step is to show how we calculate any number.

    A simple formula is needed in order to calculate the value of any number of the decimal system. Since there are ten numbers in the decimal system and since the number modifies the value at its position (a 40 is not a 10, but is 4 times 10), we must find a way to find out what the actual value is at a specific position. All we have to do is multiply the digit at a certain position with its power and add all of these numbers together. For example, the number 423 is equal to 3*10⁰+ 2*10¹ + 4*10² which is equal to 3*1 + 2*10 + 4*100 which is equal to 423 [of course]. Have I thoroughly confused you? Hope not. This process of breaking apart a number is actually considered to be converting a decimal number to a decimal number, which is useful as an example but nothing more. What we would like to do is see how the binary number system works in comparison to the decimal number system.

    The binary number system is very similar to the decimal number system except that we use two to a certain power instead of ten. The formula is the same. It is useful to note that the formula will convert a binary number into a decimal number. Table 3 shows how a binary number is converted into a decimal number. Note how the binary number only has the digits 0 or 1, that's because that is all the binary number system contains.

128	64	32	16	8	4	2	1
2⁷	2⁶	2⁵	2⁴	2³	2²	2¹	2⁰
1	1	0	1	0	0	1	0
11010010 in binary = 02⁰ + 12¹ + 02² + 02³ + 12⁴ + 02⁵ + 12⁶ + 12⁷ = 0 + 2 + 0 + 0 + 16 + 64 + 128 = 210 in decimal

Table 3 - Binary to Decimal

Computers themselves use binary but programmers use decimal, octal (base-eight [contains only the numbers 0-7]), and hexadecimal (base-sixteen [contains the numbers 0-9 as well as the letters A-F]). It is not necessary that the programmer learn these other bases at this time but just be aware that they exist in the computer field (you'll see hexadecimal [short form is hex] soon).

Types of Numbers

Humans have various terms to refer to certain types of numbers. For instance, we call ½ a fraction, and .4 a decimal, and –4 a negative number. For more complex math, we call 5i+3 a complex number. Computers have similar names for numbers. All of the following number types can be signed (allowing positive, zero, and negative numbers) or unsigned (allowing only zero or positive numbers). A special note is that on numbers above 999, a comma should not be included within the number.

Integers

Integers are numbers without any decimal points. The number can be negative, zero, or positive. It must be a whole number and not contain a fraction. For example, 1000, 0, 25, 1, -4 are all integers but .1, .333, 5.2, 1.000001, and –99.99 are not integers.

Integers are used in computers for speed as the computer does not have to deal with fractions. Some examples of how they are used in computers would be in the form of a date (1-1-2001) or time (12:00).

On most computers, integers are measured in how many bits (binary digits) they contain. On old computers, an integer contained only 8 bits. On modern computers, an integer contains anywhere between 32 and 128 bits [depends on the computer]. What this means is that a computer can only count but so high or low. An 8-bit number has a decimal range from 0 to 255 or –127 to 128 [if you're wondering how I'm getting the decimal ranges, 2⁸=256 numbers. Zero must be included so the range is 0 to 255.]. A 16-bit number has a maximum range up to 65,536 numbers. A 32-bit number has an upper limit of 4,294,967,296! You may ask what happens when you try to go over this range, well, it depends. If the computer is allowed to use negative numbers as well as positive then if you add 1 to a number that has reached the maximum limit, you'll get a negative number on the lower limit of the range. On the other hand, if the computer is not allowed to use negative numbers but only positive ones and you add a 1 to a number already at its maximum, you'll get zero as the answer. Yes, this can cause problems. (ah, another problem for you to solve in the future J).

Byte

A byte is a smaller version of an integer. It is usually only 8-bits long. As stated earlier, it contains 256 numbers. Bytes are used mainly for characters that the computer can produce. I'll explain this at a later time. For now, just think of a byte as a smaller version of an integer. Believe it or not, it is usually faster to use integers instead of bytes for storing information! Yes, bytes are much smaller than integers, but the computer's basic unit is an integer. [It is similar to how an American's basic unit of money is the dollar but we have smaller units of money such as quarters and pennies].

Single and Double Precision and Floats

Numbers that contain decimals are called, depending on the programming language, single/double precision or floats.

The reason for the single and double precision difference is just the bit size and the number of digits that could be in the number. For example, a single precision number may store the fraction 1/3 as 0.33333 where a double precision will store it as 0.3333333333. Double precision does not necessarily mean that there will be double the amount of digits available for a number, this will depend on the language being used. Another note, single precision numbers can be calculated faster than double precision numbers, but both are much slower than integers.

Floats (named floats for the term floating point) are single or double precision numbers with just a different name. They are called floats because the decimal point can "float" anywhere within the number. I will refer to this group of numbers as floats throughout this book except when talking about certain languages.

This group of numbers is useful for calculating formulas that contain fractions. For example, to calculate how much tax would be added to an item would require a float.

Longs

Longs are basically integers that have a larger range than a normal integer. Longs are useful when an integer is just too small.

Other Types

Computers can deal with other types of information as well as numbers. To be truthful, even these types are numbers but they are in a special classification because of the way humans perceive them. For instance, if a statement is true, a human probably wouldn't say that a statement was –1. In Qbasic this is what the computer would say to a true statement! For example, the formula 2+2=4. A human would say, yes, 2+2 does equal 4. In Qbasic, the computer would say 2+2=4 equals –1!

Boolean

Boolean types deal with a section of mathematics called Boolean logic. To put this in simple terms, it deals with whether a statement is true or false. The computer has no idea what true means or what false means but uses Boolean logic to figure out the truth of a statement. In most programming languages, 1 means true and 0 means false (Qbasic uses –1 to mean true and 0 to mean false).

Character

A character is almost always the same thing as a byte. A character can be any single letter, number, or symbol that is on the keyboard, among others symbols that the computer can produce. A character is actually the symbol itself (such as an 'A' or space). Internally the computer represents each symbol as a number. For instance, the character 'A' is internally represented as the number 65 and a space as number 32. Where does the computer get these numbers from for the characters?

Around 1968, a group of computer scientists came up with a table that contains all of the symbols the computer can normally produce and assigned a number to each of them. This table is called the ASCII table
[American Standard Code for Information Interchange]. This table contains 256 individual characters. The first half of the ASCII table is standard for all modern day personal computers. Figure 1 shows the entire IBM PC version of the ASCII table.

Figure 1 – Hex IBM PC ASCII Table

In the programming language Java, the ASCII table is being replaced with a table called Unicode. The Unicode table contains the ASCII table as well as many more symbols. It uses a 16-bit byte value and thus has a total capacity of 65,536 symbols.

Strings

Another useful type is the string. Strings are just a bunch of characters "strung" together. For instance, a single word or part of a word is a string or even an entire sentence or paragraph could be considered a string. Strings are almost always enclosed in quotes in programming languages. Since numbers are considered to also be characters (numbers are included in the ASCII table so they can be a character), a series of numbers could be considered a string. What makes the difference between a number and a string? The quotes. For instance, 123 is an integer, but "123" is a string that contains the characters "1", "2", and "3". Strings are useful in storing things such as names, words, addresses, and so forth.

Others

Each programming language has different types to represent certain types of information. Some types are difficult to explain until some information is known about the language itself. I'll explain these other types when they are useful to learning about a particular language.

Intro to Computer Programming – Chapter 1: Problem Solving

2010-02-26T17:48:00.000-05:00

Chapter 1: Problem Solving

Introduction

In order to write a program for a computer, the programmer must know what the program is going to do, how it will do it, and what it the input and output of the program will be. In order to do this, the programmer must have problem solving skills. For simple programs, the programmer will just need basic problem solving skills. These problem solving skills will improve as the programmer gains experience in programming.

A programmer could come against a problem as simple as how to display a letter on the screen to something as complex as making a robot walk across a room or flying the space shuttle. Displaying a letter on the screen is very easy in most languages and can be solved by all programmers, as long as the programmer knows the basic commands of the language. Flying the space shuttle is a slightly different story. It takes a team of NASA programmers many months to solve the complex problems that are encountered by flying the space shuttle.

The beginner programmer must also realize that there is usually more than one way to solve a particular problem. For instance, there are at least five ways to write a letter on the screen in the language Qbasic; which way the programmer chooses to display a letter on the screen would depend upon the specifics of the problem or even the personal preferences of the programmer.

How to Solve Problems

    There are many ways to solve problems. A problem can usually be solved if enough information is known about the problem. If a person is given a problem that requires a specific answer, the programmer must know how to get the required information from the problem in order to get an answer. It is similar to driving from one location to another. The person must know where to start and where to finish, and any places to visit on the trip.

    Let's take the problem of taking a trip from Florida to New York. A person who wishes to solve this problem must know first exactly where they are in Florida and where in New York they wish to visit. Next, they need to know what means of travel they will take (can they walk, drive, fly, take a boat, etc). They will also need to know where they wish to stop while traveling to New York. Some other things to consider are how long they wish to be traveling, how much money they have for the trip, and possibly how much luggage they wish to take. All or most of these questions must be answered before the trip should ever take place and then when certain questions are answered (such as means of travel), it could bring up more questions as which direction to travel or which roads to travel. As with most problems, there are many ways to travel from Florida to New York. The same is true with computer programming. Sometimes there are restrictions on the problem, such as taking the shortest route from Florida to New York, which could restrict the number of answers down to a few. This is also true with computer programming. As the traveler gains experience, they will know the best way to travel from Florida to New York and will also know the best places to stop on the way. Computer programmers also gain experience as they solve computer related problems.

    There is no set way to solve a given computer problem. Each problem is different and therefore requires a different way to find a solution. Here are a few guidelines that a programmer should go through for each problem.

Read. Most of the time important information is enclosed in the description of the problem. The problem should be read until the programmer understands what is requested.

Understand. The programmer must be able to understand the problem completely before telling the computer how to solve the problem. The programmer must be able to put the solution in a very specific series of steps so the computer can produce the desired answer.

Ask. If not enough information is given in the description of the problem, ask questions to someone who may know how to solve the problem or to the person who produced the problem. Two heads are almost always better than one! Books and the Internet are also useful resources if another person is not available.

Think. Think of how a simpler problem could be applied to help solve this problem. Most of the time a harder problem is just a collection of simpler problems. For example, multi-digit multiplication contains simpler problems such as single-digit multiplication as well as addition. It is not always possible to come up with an easy solution to a problem.

Solve. If the programmer can produce a solution by hand, then a program can be more easily produced. If the programmer has no idea how to solve the problem, how will the programmer be able to tell the computer how to solve it?

Choose. Choose the language that best helps solve the problem or use the language the programmer already knows. If the programmer only knows Fortran, but the best language to use is Cobol, then the programmer should attempt (not all problems can be solved in every language) to produce the solution in Fortran, unless the programmer wishes to learn Cobol.

Code. Produce the program in the chosen language and make sure it is free from errors.

Test. Make sure the program produces the correct answers, if not, the problem should be thought through more carefully and redone. The reason to solve the problem was to get the correct answer, not incorrect answers.

Intro to Computer Science – Preface

2010-02-26T17:47:00.001-05:00

Preface

What this book is about

    In today's information age, computers are all around us. Computers are in our vehicles, in our televisions, our microwaves, our telephones, and countless other devices we use daily. One question to think about is how do these computers know what to do? They are just made out of silicon [i.e. sand], metal, carbon, and a few other elements. The truth is, they don't know what to do. They have to be told what to do and how to do it and the only way to do that is to give them instructions on how to do something. The instructions to do a particular task for computers are collectively called a program.

    Each different type of computer can possibly have different sets of instructions that it understands. These sets of instructions are called a programming language. A programming language can be thought of like a human spoken or written language. English, for example, has different words in it than a language such as French. They possibly have the same words in both, and the words could mean the same or they could mean something completely different. A person can know only English, or only French, or a person could know both of them. The same is true with computers. A computer could understand languages such as Assembly, C, Java, Pascal, or Basic (think of these like they are human languages that you've never heard of).

    Just as human languages come from different families of languages, such as French and German are of the Romantic language family, the same is true with computer languages. For example, under the C family of computer languages are programming languages such as C, C++, C# [pronounced C sharp], and Java. Under the Basic family are languages such as BASIC, BASICA, Qbasic, QuickBasic, and Visual Basic.

    Some human languages are not used anymore, except for very special purposes. Examples of these languages are Egyptian, Ancient Greek, and Ancient Hebrew. The same is also true of computer languages. Programming languages such as Cobol, Fortran, and Pascal are rarely ever used anymore except for very specific purposes.

    Each computer language has its advantages and disadvantages, just as human languages. BASICA, for instance, is a very easy language to learn but it is limited and extremely slow. C++, on the other hand, is harder to learn but is extremely fast. For this reason and others, computer languages are picked by a programmer according to the problem they wish to solve. The computer language Fortran, for instance, is great at solving math problems.

    You're still probably asking yourself, "Why do we need to program a computer?" The simplest answer is because the computer cannot do anything without it being told what to do. It must be told by someone how to do everything, including what steps to go through when it is turned on! The only way to tell a computer how to do something is to write a program to tell it what to do. In order to do this, the programmer must know what the problem is that is needing to be solved and must also know the computer language in which to solve. If these two things are known, a program can be easily written to solve the problem. The problem could be as simple as how to write a word onto the screen or as complex as flying the space shuttle.

    This book is intended to teach anyone how to program a personal computer. A basic understanding of how to use a computer [preferably one that has been programmed so that it is usable J], and an understanding of basic middle school Algebra is also helpful. I plan to cover some of the more common languages used such as C, C++, Java, and HTML and also some of the lesser-used languages such as Qbasic and Assembly. Some of the more complex languages, such as Java and Assembly, will be handled near the end of the book to allow important topics to be covered and explained thoroughly. Other languages, specifically HTML, will be covered first and only within the first few chapters as they are not complex languages.

    This book is not meant to be an all-inclusive reference to each of these languages. If it were, this book would be several thousand pages long. It is meant to be an introduction only.

Conventions

There will be several places within this book where code, new terms, user input, and so forth will be used within the text. The table below shows how each of these conventions will look throughout the book.

Convention	Meaning
Bold	New term
Code	In-text code. Usually just a single command or line
Program	Multi-line code segment or program. Lines will be indented slightly from the book's text
computer output	Computer's output from a program
user input	User's input into a program
Error	Error or mistake within program or an error that the computer produced

Table 1 – Conventions used throughout the text

An Apology

The computer field has been around for over 50 years and it has added many words to the English language. In many instances there are multiple words to mean the exact same thing. I will try to stick to the same set of terms throughout the entire book, but if I slip, please forgive me.

Also, computer programming is not an easy topic to explain at times. I will do my best to explain it, but if I confuse you, forgive me. Sometimes it is best to just sit down and experiment with a new concept and to figure out how it works yourself. You will not make the computer blow up if you do something wrong. The worst that could happen (at the introductory level anyway) is that you may have to reset the computer. Experimentation is always the best way to learn, especially when dealing with computers.

Special Thanks

A special thanks to Heather Rawlins who got me to write this book in the first place and for always being there for me. To Mrs. Pam Leary for showing me how to add two plus two in BASIC on an old TRS-80 Model III many years ago. To Microsoft for creating the tools and languages to allow programmers to create their own software. To all my friends who have put up with me through the years. To Dr. Abrahamson, Dr. Wirth, and Dr. Prichard from East Carolina University for putting up with all my questions, allowing me to catch their mistakes without getting too mad, and for teaching me more about computer science.

If I've missed anyone, it's not that I haven't thought about putting you in here. I don't want to write a book of just "thank you"'s. If I've offended anyone by not including you in here, email me and complain about it.

Intro to Computer Programming - Legal

2010-02-26T17:46:00.001-05:00

The information contained within this document does not contain any warranty. The code has been tested on my machine to not cause damage and has been reviewed by university professors and other programmers but it is not guaranteed to do exactly what it should. The reader takes full responsibility for executing the code samples contained within. Any damage caused by the information or programs contained herein are the reader’s responsibility.

All terms, trademarks, and copyrights are property of their respective owners.

MS-DOS, Qbasic, QuickBasic, BASICA, C#, Internet Explorer, Microsoft Office Suite [including Word, Excel, Access, PowerPoint, FrontPage], and the Visual Studio Suite [including Visual Basic, C++, FoxPro, InterDev, and J++] are all registered trademarks and Windows is a trademark of Microsoft Corporation.

Java is a registered trademark of Sun Microsystems.

Turbo Pascal is a registered trademark of Borland Corporation.

Netscape Communicator is a registered trademark of Netscape Corporation.

Pentium is a registered trademark of Intel Corporation.

All rights reserved. No part of this document may be reproduced either in printed, written, nor digital form without the express written permission from the author.

Copyright 2001 by Randy Hale.

Intro to Computer Programming - Blog Intro

2010-02-26T17:45:00.001-05:00

I started writing this multi-language (QB, C, C++) approach to an into to computer programming while in college as a personal side project. I haven't touched it in over 8 years so I figured it was about time to release it to the public. Maybe someone out there could use it or learn something from it. It is in no means finished and has not been edited in any way.
I'll post this in a chapter format - it is kinda large as a whole so that'll probably be the easiest way.
Questions, comments, donations :), etc are all welcome.

First Blogged System Build

2010-02-18T17:32:00.001-05:00

After over 14 years (probably closer to 16) of building computers, I've never documented a build. So, with the chance to build a semi-high performance system, I figured I'd do at least one documented build - and with today's internet technology, I may as well blog it. :) Please forgive the formatting - first time doing any major blogging :)

The customer who wanted this system wanted a high performance system w/ monitor and printer for around $1400. We went through the traditional questions of "what are you using this computer for" and "any special requests"? Basically, he wanted a system that he could easily upgrade, one that was a good performer for the price, price was somewhat important, this was going to be the main system in the house (with several children), he would not be playing major games on the system (i.e. no AfterShock but maybe Flash-based internet games/card games), he preferred to not "have" to upgrade this system for 2-3 years, the system had to have enough space to store music and video (i.e. 1TB), had to have CD/DVD writing capability, etc. Well, I went out and with those requests found prices on several component choices and "pre-built" a couple systems on paper to get a rough cost.

Basically, the 3 systems, a entry-level (~$1100), a mid-level (~$1400), and a super performance (~$2400) included a 21" Samsung Monitor (Samsung 2233SW 21.5-Inch Full HD Widescreen LCD Monitor) and the Epson Workforce 610 which my wife and I have been extremely pleased with (Epson Workforce 610 Wireless Color Inkjet All-in-One Printer (C11CA50201)) as their non system base. The 3 systems had was an Asus motherboard base, an AMD CPU, and, if the motherboard didn't have on-board video, an ATI graphics card. The Asus, AMD, and ATI were my own preference choices for various reasons.

After talking with the customer on the various options, we choose the new Asus EVO/U3S6 (Asus M4A785TD-V Motherboard)* {note - Amazon does not have the U3S6, this is the base motherboard link} (the NewEgg link is M4A785TD-V EVO/U3S6). This specific motherboard features USB 3.0 as well as SATA III (i.e. 6Gbs) and has an onboard ATI 4200 video card...and, yes, the USB 3 and SATA III are off-board on a controller card - not a major problem for me. This board also has fairly substantial overclocking capabilities, supports up to 16gb ram, has 5 on-board SATA II ports, and 6 USB 2.0 ports. In addition to 2 SATA III ports, 2 USB 3.0 ports, HDMI, on-board sound (what motherboard doesn't nowadays), eSATA, COM1 and LPT1 ports (? yes, ports for legacy COM1 and legacy LPT1). The on-board video is also decent and can easily be combined with another 4200 off board card for even more performance - and, for what this will be used for, no need to go with a high-end video card. No, this is not the most feature rich board but I know the Asus brand and have been extremely impressed with their quality and their warranty on their hardware and computers. I'll stick with what I trust and use myself. [I've also used and really like Abit boards but NewEgg did not have *any* Abit boards and Amazon did not have any Abit SATA III boards].

For the processor, I gave the customer a choice of the AMD Phenom II X2 (Phenom II X2 545 AM3 3.0GHZ 7MB 45NM 80W 4000MHZ Pib) on up to the X4 (AMD HDZ965FBGIBOX Phenom II X4 965 3.4GHZ Central Processing Unit (Black)) and several Ghz choices within each of those. He choose the mid-range AMD Phenom II X4 945 HDX945FBGIBOX 3.0 GHz/6MB L3/125W Processor. For the price, it ended up being the best price point. I went ahead and kept the stock fan/heat sink as I knew we would get a case that had plenty of airflow and I don't foresee this customer overclocking the machine any. And, another good word for AMD, I've never had any problems with their stock fans/heatsinks - it's always been the stock Intel that I've had major problems with.

In terms of memory, I told him he would be running 64-bit (i.e. no, he had no choice :)). So, 4gb is the minimum I recommended. He would be running Windows 7 on this machine and the applications he mentioned he may use would not be anything that would tax the memory. So, we both decided to stay at 4gb with the option available to add another 4gb (2x2gb) at a later time. I choose the G.Skill NQ Series F3-12800CL9D-4GBNQ Dual Channel - Memory - 4 GB ( 2 x 2 GB ) - DIMM 240-pin - DDR3 - 1600 MHz / PC3-12800 - CL9 - 1.8 V - unbuffered - non-ECC. Even though the motherboard could support the higher speed memory, I stayed with a mid-range speed...I personally have not seen a significant speed improvement for using higher speed memory - there are many other slowdown areas that should be addressed before memory speed is increased (i.e. hard drive RPM speed is a much more significant speed problem than a 300-600Mhz difference in memory speed). And, yet another AMD advantage over Intel for DDR3 memory - AMD allows using dual channel memory (2 memory slots used)...Intel requires ternary channels (3 memory slots used)...again, lower cost for AMD vs Intel and also lower amount of heat dispersed into the case (lower wattage required, etc). Yes, there may be minor differences between dual and ternary channel memory but not enough to make me switch to Intel (and spend more).

Next came the hard drive. There were several options here. We ended up, after a long debate, with the Western Digital Caviar Black 1 TB Bulk/OEM Hard Drive 3.5 Inch, 32 MB Cache, 7200 RPM SATA II WD1001FALS. [We had picked a Samsung but NewEgg was sold out when I made the order]. We had talked about the 7200 RPM drives vs the 10000RPM (Western Digital 300 GB VelociRaptor SATA 10,000 RPM 16 MB Cache Bulk/OEM Desktop Hard Drive WD3000HLFS) drives but the price per gigabyte vs performance was a bit much. Yes, 10k RPM drives are FAST but for $200 for 300gb vs $100 for 1TB - not worth it for general use. We also went back and forth over the new SATA III 6Gbps drives but from what I read of the ratings, the speed and performance for those new drives just isn't up to the speed yet and with the standard so new I suggested he hold off and get those drives later after more manufactures get on board (there was only 1 when I did the research - I found none just now on Amazon and NewEgg, so maybe a very good choice to, for once, avoid the bleeding edge!). This drive is in Western Digital's line of similar drives - green being "green" which uses less power and are very quiet, blue which is general use, and black which is a performance drive. After installing this drive into the system, this drive seemed "noisy" compared to others I've used...but, this could be due to the acoustics of the case or the drive itself...doesn't sound bad and not overly loud but can be heard over the fans. The only caution with this drive is that it is not natively RAIDable...there's supposed to be a "trick" out there to force the RLE disabled/enabled but I didn't bother as this drive is currently not RAIDed. Of course you must pay WD more if you want the native RAIDable drive...i.e. not worth it... For the high performance system, I had included in the price 2 1.5tg 6gb drives and 3 of the 300gb 10k RPM drives...

The customer wanted to be able to write CDs and DVDs...after looking at the prices ($30 for a DVD writer), and seeing the price on the Blu-Ray Combo drive (LG Electronics LightScribe 8x SATA Blu-ray Combo Internal Drive UH08LS10 BLACK/RBOX (Black)), we choose to get the Blu Ray drive. This'll be my first Blu Ray drive installed [hey, I haven't been building systems much lately] and so far so good...haven't yet tested the Blu Ray capability but normal reading seems to be very quick and for ~$90, not a bad price at all for a Blu Ray Player.

After how many years of not using a floppy for storage, I decided to not use a floppy drive on this system. Flash drives are much more reliable and cheaper.

I got a generic keyboard and mouse - these are a lot personal preference so I got the cheapest available that worked and they can update as needed.

The power supply is the old reliable Antec Earthwatts 650 (650 Watt ATX12V V2.2 Psu). I've used these many times in several of my home systems and for repairs and they do a great job. They don't generate a lot of heat and have very reliable components. They're also 80%+ efficient which helps with the electric bill. The only thing I don't like is their cables are not modular, but, they do have pretty much all the cables you'd need. Probably not the best for the tight-fit case but in a large case, modularity is not a problem. For this system and for upgrade reasons, I didn't recommend anything below a 500w so this was the best available choice.

The case...ah, this is probably one of my favorite parts of the build. I've really been a fan of Antec cases (I personally have the P180 (Antec P180 Advanced Super Steel Mid Tower ATX Case) and the P182 (Antec P182 Advanced Super Mid Tower ATX Case (Black/Stainless Steel Trim))). For this build, with an unknown amount of heat generated from the CPU, I decided to go with something with a bit more air flow (the Antecs do a great job, don't get me wrong) and something not so heavy (the Antecs are 50lbs+) and something easy to upgrade. I looked at two, an XCLIO Windtunnel with its two huge external fans or the RaidMax Smilodon (RaidMax Elite Series Smilodon 612W - Mid tower - ATX - power supply 500 Watt - black - USB/Audio) with its foldout motherboard tray. I talked to the customer and we decided to go with the one with the most air flow - the XCLIO Windtunnel. All I'll say is this case is a pleasure to work with. The external fans are beasts and are adjustable and can be powered off at will. The case has plenty of room, great air flow (even with the external fans off), easy to get the motherboard installed, screwdriver-less installation of all drives. Pretty nice. The only gripes I have are the edges are sharp - but that's common with a lot of cases, the hard drive carriers are a bit of a pain to get onto the drives and don't appear as easy to remove once they're on the drives...but, being in a caddy, they're ok (if you're looking at swapping hard drives a lot - avoid!). The DVD drive was a cinch to install. I do wish the power cable for the external fans were a bit longer but other than that, not bad. This case only comes with the external fans, the drive fan and back external fan are optional - but I highly doubt are needed. The case is a bit taller than my Antec P182 and not as weighty (30lbs). Oh, another small thing, be careful of the front panel, lifting the case the panel is plastic and doesn't appear to be able to hold the weight well. The case also has adjustable feet, which is a nice change to the rubber "feet" I'm used to. The front panel is pretty thick and hides the drives and power/reset buttons. The USB/audio ports are on the side...interesting. Unlike the Antecs, this case does NOT have any air filters...and with all the incoming air, internal dust might be a problem. The hard drive did seem loud but not sure if this is the hard drive or the case's fault. Rubber grommets would be a nice addition (i.e. like Antec's P180 series). Overall, I did like the case (yes, against all my gripes - just documenting everything) and would definitely buy it again for another high performance system. The fans are adjustable and are surprisingly quiet! The side panel is a pain to get on at times (goes on but the thumbscrews don't always align) and it does not come off the way most normally do - it comes up (up being case on it's side) , not back (back as in drives towards power supply). Took some getting used to... With it all said and done and everything built, the case temp was <30C and CPU temp <30C (BIOS temps) and the exhaust air was very cool (unlike one of my Intel-based Antec's with air fairly warm). Even with the external fans off, the CPU/case temp did not go above 32C (BIOS temps). A few of the case pics are below...

I had the entire system built in less than 2 hours. Was a fairly easy build and I actually did take my time on it...the case made a huge difference.

Installing software...I installed Windows 7 (upgrade version) [with no prior OS], it installed and it was ready to use in ~15 minutes. Unfortunately, 7 did not like me trying to use an upgrade without an OS already installed (I know, I have not done any clean absolutely no OS installs of 7 before so I thought it would "ask" for an original XP/Vista CD - it didn't). So, Vista 64 install...also took ~20 minutes (yay, not SATA drivers needed! Pleasant surprise!)...then installed 7 on-top of a clean Vista install. Again, less than 15 minutes. Everything else was a cake walk - nothing took over 5 minutes to install...actually probably took longer to download most things than to install them. I installed Avast, Ad-aware, all the "useful" Asus utilities , Java, ATI display drivers, OpenOffice, Google utilities (minus Spyware Doctor as that's caused me problems on several other systems) along with all the LG utilities for reading/writing disks and watching Blu Rays. I also installed the DivX player, which has a decent selection of HD videos and can encode videos fairly well. Of course, Firefox was also installed. Overall, I had everything installed and fully updated in just a couple hours.

General testing went well and the machine performed great. We'll see how well the customer likes this machine :)

For the record, this time NewEgg instead of Amazon had the best prices for the parts where normally it's the opposite. Sorry, Amazon - some parts just weren't available at all at Amazon. And, yes, the total for this system was a little under $1400 including monitor, printer, computer, tax (stupid TN tax of ~$125!) and shipping/handling ($30! - yes, $30 and everything came in about a week).

Since I have no clue (yet) how to arrange these pics, the various pics from the build are below.

SQL 2008 Resetting auto increment indexes

2009-04-28T23:36:00.003-04:00

Found this useful for resetting the auto-increment indexes on a SQL 08 database.

DBCC CHECKIDENT ("database.dbo.tablename", RESEED, 0);

No column name needed.