Randomness

How to Keep Numerous Tabs Open in Google Chrome

2011-03-08T03:27:00.000-05:00

I try not to open too many tabs in Google Chrome, however, it still happens. When many tabs are open it slows down the system and take up a lot memory. An easy work around to this is to end all tabs that are not currently in use. To do this simply press Shift+Escape to bring up Chrome's task manager. End all tabs that are not being used or are taking a large share of the memory. The tab remembers its URL but doesn't load anything into memory. Refresh the page to load the contents again. Now one can have as many tabs open without slowing the system.

String Literals

2011-02-11T02:19:00.002-05:00

What is wrong with the following code?

#include <cstdio>
#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char** argv)
{
char *str = "hello world";

str[0] = 'H';

return 0;
}

Consider:

 char str[256];

strcpy(str, "hello world");

instead of:

char *str = "hello world";

Why?
The compiler puts the string literal ("hello world") into the read only address space of the program and thus is immutable during runtime. Which explains why there is a segmentation fault/exception thrown when one tries to write to str.

More Info: String Literals - Where do they go?

XOR Swap Algorithm

2011-02-05T15:06:00.000-05:00

XOR swap algorithm is a nifty little trick to swap two variables with each other without a temporary variable.

Here is a little snippet of code showing how it works:



#include <cstdio>

#include <cstdlib>

#include <iostream>



using namespace std;



int main(int argc, char **argv)

{

 int x, y;



 x = 123;

 y = 456;



 cout << "x = " << x << endl; // x = 123

 cout << "y = " << y << endl; // y = 456

 cout << endl;



 // Swap values

 x ^= y;

 y ^= x;

 x ^= y;



 cout << "x = " << x << endl; // x = 456

 cout << "y = " << y << endl; // y = 123



 return 0;

}

Reverse Words in a String

2011-02-05T12:47:00.003-05:00

Reverse the order of words in a string "jackdaws love my big sphinx of quartz" to "quartz of sphinx big my love jackdaws"

Solution 1: Using a Stack
Assumption: The string literal is given in a String



public String reverseString(String myStr)

{

 String [] myStrSplit = myStr.split("-");

 Stack<String> stack = new Stack<String>();

 StringBuilder myStrReverse = new StringBuilder(); 



 for ( String s : myStrSplit )

 {

  stack.push( s );

 }

 

 while ( !stack.empty() )

 {

  myStrReverse.append( stack.pop() );

 }



 return myStrReverse.toString();

}

Time Complexity
String#split + pushing on stack + popping off stack
N + N + N time
= O( 3N )

Space Complexity
myStr + myStrSplit + stack + myStrReverse
N + N + N + N
= O( 4N )

Solution 2: Using a Doubly LinkedList



public void reverseString(DLinkedList myStr)

{

 Node next, prev;



 for ( Node n : myStr )

 {

  next = n.next;

  prev = n.prev;



  n.next = prev;

  n.prev = next;

 }

}

Time Complexity
traverse myStr
= O( N )

Space Complexity
Space for next and prev
= O( 1 ) (constant space)

Solution 3: Using XOR

#include <cstdio>
#include <cstdlib>
#include <iostream>

using namespace std;

// Find next space position
inline int nextSpacePosition(char *str, int startPosition)
{
int nextSpacePosition = -1;

for ( int i = startPosition; str[i] != '\0'; ++i )
{
if ( str[i] == ' ' )
{
nextSpacePosition = i;
break;
}
}

return nextSpacePosition;
}

// XOR Swap
inline void swap(char *a, char *b)
{
*a ^= *b;
*b ^= *a;
*a ^= *b;
}

int main(int argc, char **argv)
{
char *originalStr = "jackdaws love my big sphinx of quartz";
char reverseStr[256];
int strLength;
int pos, spacePos;
bool lastIteration = false;

pos = 0;
spacePos = 0;
strcpy(reverseStr, originalStr);
strLength = strlen(reverseStr);

// Reverses string
for ( int i = 0; i < strLength/2; ++i )
{
swap(reverseStr[i], reverseStr[strLength-i-1]);
}

// Reverses words
while ( ! lastIteration )
{
// Find where word ends (space)
spacePos = nextSpacePosition( reverseStr, spacePos+1 );

if ( spacePos == -1 )
{
spacePos = strLength;
lastIteration = true;
}

// Reverse word
int end = pos + ((spacePos-pos) / 2);
for ( int i = pos; i < end; ++i )
{
swap( reverseStr[i], reverseStr[spacePos-1-(i-pos)] );
}

pos = spacePos + 1;
}

cout << "Original: " << originalStr << endl;
cout << "Reversed: " << reverseStr << endl;
}

Time Complexity

traverse half of reverseStr (reversing the string) + traverse reverseStr (reversing words) + string length

= O( 5/2 * N )

= O( N )

Space Complexity

Space for constant space variables

= O( 1 ) (constant space)

The appealing feature for this method is that it doesn't require any "new" data structures (i.e., linked list) and all the work is done in place.

Testing a Device

2010-10-19T21:54:00.004-04:00

An interesting question is how do you test a device (e.g., vending machine, toaster, pencil, magical food creator appliance). There is no correct answer to this question but a correct thought process. Like any problem that we face as an scientist/engineer is to start from the top. It is very important at this point to understand the big picture.

For a tester this means, what are the requirements of the device? A requirements document is what the product should be or perform. The requirements define the design of the product. There is also specifications which are derived from the requirements. The developer and tester shouldn't worry about writing the specifications, just that they are met, and that they have good requirements.

FURPS represent a good model for classifying software quality attributes. Use FURPS as a high level mental checklist. From there, you can branch into each category and drill down with specific tests.

Functionality - Feature set, Capabilities, Generality, Security

Usability - Human factors, Aesthetics, Consistency, Documentation

Reliability - Frequency/severity of failure, Recoverability, Predictability, Accuracy, Mean time to failure

Performance - Speed, Efficiency, Resource consumption, Throughput, Response time

Supportability - Testability, Extensibility, Adaptability, Maintainability, Compatibility, Configurability, Serviceability, Installability, Localizability, Portability

Other things to keep in mind: input/output, display, and data model.

Software Testing Overview

Apply your knowledge:

Windows 7 MS Paint Bug

MS Notepad Bug

Model Reconstruction from Images

2010-04-25T17:46:00.126-04:00

In the coming days I will talk about model reconstruction from images. I have developed a very simple framework for doing reconstruction. The framework consists of feature detection, correspondences, removing of incorrect data, distortion removal, computing the projection matrices, triangulation, and mesh creation. The discussion will involve a simplified problem space. Proofs for methods are left out of the explanation as the project’s scope is to perform the operations rather than the theory that goes behind it.

The rig consists of a free moving calibrated camera at a single focus.

Image Capture

Images taken with web cam

First step is to capture images. The camera must have the same focus for all images, including the images used for camera calibration. For simplicity, the Microsoft LifeCam NX-6000 web cam was used as it has a single focal length. A regular compact camera would give the best results. Compact cameras have a better image sensor (CCD) and lenses rather lower quality image sensor (CMOS) and lenses found in web cams.

Feature Detection

A good feature detector is to create a consistent feature point amongst different images. Characteristics of a good detector are invariant to changes to scale, noise, illumination, and affine (scale and translation) transform. Feature point detection is primarily done with the algorithm called Scale Invariant Feature Transform, or SIFT. Rather than re-implementing available solutions, the project used the VLFeat library. SIFT is invariant to scale, orientation, affine distortion, partially invariant to illumination changes [ref].

Correspondences

Correspondences between two images, 220 points

The VLFeat library also does image correspondences. An advantage of SIFT is that its feature points have an associated vector to them. To compare two features to each other one only has to look at the Euclidean distance between the two vectors. However, this is all taken care by the library.

Although SIFT is a fairly accurate algorithm, it isn’t perfect. Poor quality features can occur in parts of the image that the color data rapidly changes (i.e., a tree’s leaves), parts were color data doesn’t change (i.e., a flat solid area), highly saturated or under-saturated areas (i.e., lights, darkness), or highly specular or reflective surfaces (i.e. chrome, mirrors). Additionally, there can be bad correspondences from mismatching feature points.

Removing Incorrect Correspondences

Image correspondences after RANSAC, 84 points

Random Sample Consensus, or RANSAC, was used to remove bad data. RANSAC is an iterative method to estimate parameters of the mathematical model (p. 54). The model in this case is the fundamental matrix (see Fundamental Matrix). The basic concept of the algorithm is that there is a set of data consistent with a mathematical model called the inliers and a set of data not consistent with the model called the outliers. RANSAC is non-deterministic in nature because it randomly chooses a set of points to create the model. RANSAC runs a set number iterations or until it finds a good set of inliers. The set of inliers that minimizes the error is the chosen set of data to represent the model. Thus the inliers in this case would be good feature points and outliers would be noisy and incorrect data.

Dense point matching

Once an accurate model has been established, a guided matching can occur. Guided matching usually consists of rectifying the images and comparing them to each other. Image rectification and comparison creates a set of dense point correspondences thus a better end result. This process can be repeated to get the most out of the images. This has yet to be implemented however.

Alternate Method

Handpicked results, 37 correspondences

For simplicity, handpicked results will used. cpselect is the best way for getting manual sub-pixel accuracy point correspondences in MATLAB. Handpicked correspondences are used so possible errors that come from automatic feature detection are eliminated.

Camera Calibration

Camera calibration was done with the Camera Calibration Toolbox for MATLAB. The camera calibration process consists of taking images of a known calibration object. For the toolbox the calibration object is a checkerboard pattern. The user holds the calibration object in different positions while taking pictures of the object. These images are fed through the toolbox and it outputs the calibration information or better known as intrinsic parameters.

Intrinsic Parameters

The intrinsic parameters consist of focal length, principal point, and skew coefficient. Additionally, the toolbox can compute the distortions of the camera. With this information, the camera matrix K is built. The camera matrix allows a metric reconstruction of the scene up to a scale. Additionally, knowing the lens distortions of the camera will allow removal of distortion in the image correspondences. These variables are:

Name	Description	Variable	Dimensions
Focal length	Focal length in pixels	fc	2x1 vector
Principal point	Principal point coordinates	cc	2x1 vector
Skew coefficient	Skew coefficient defining the angle between the x and y pixel axes	alpha_c	1x1 scalar
Distortion coefficients	Image distortion coefficients (radial and tangential distortions)	kc	5x1 vector

The calibration matrix is computed (p157):

$K = \[\left(\begin{array}{ccc} a_x & s & x_0 \\ 0 & a_y & y_0 \\ 0 & 0 & 1 \end{array}\right)\] = \[\left(\begin{array}{ccc} fc(1) & alpha_c * fc(1) & cc(1) \\ 0 & fc(2) & cc(2) \\ 0 & 0 & 1 \end{array}\right)\]$

Fundamental Matrix

The basic concept of the fundamental matrix is that it takes one space and projects onto another space. In this application the fundamental matrix takes the first image point set and projects it to the second image point set. The fundamental matrix has the essential matrix, which has the rotation and translation matrices that is needed to make the project matrices. It is computed by taking the Kronecker tensor product for every image correspondences and finding the SVD of the resulting matrix (p. 393)

Essential Matrix

In this case, $K_2$ and $K_1$ are equal because the same camera with the same setting were used. Thus, to recover the essential matrix [4, p. 257]:

$E = K_2^TFK_1=K^TFK$

The essential matrix must be projected into the essential space by:

$[U_E,E_E,V_E ] = SVD(E)$

$E = U_E * \[ \left( \begin{array}{ccc} 0 & 1 & 0 \\ -1 & 0 & 0 \\ 0 & 0 & 0 \end{array}\right)\] * V_E^T$

Extrinsic Parameters

The extrinsic parameters, rotation $R$ and translation $t$, can be recovered from the essential matrix $E$.

$W = \[ \left( \begin{array}{ccc} 0 & 1 & 0 \\ -1 & 0 & 0 \\ 0 & 0 & 0 \end{array}\right)\]$

$Z = \[\left(\begin{array}{ccc} 0 & 1 & 0 \\ -1 & 0 & 0 \\ 0 & 0 & 0 \end{array}\right)\]$

$[U_E,E_E,V_E ] = SVD(E)$

$R = UWV^T or R = UW^T V^T$

$t = U_E*[0 0 1]^T or t = -U_E*[0 0 1]^T$

Thus now there are four sets of possible rotation and translation pairs. (p. 258 - 259)

The correct rotation and translation is the pair that creates (i.e. triangulates) points in front of both cameras. First, the project matrices have to be computed (see Projection Matrices), this will give $P_1$ and $P_2$. Next, one image pair has to be triangulated (see Triangulation), creating a 3D point $X$. The depth with a positive value for both project matrices and the 3D point will indicate the correct rotation and translation pair. This is done by (p162):

$X=(X,Y,Z,T)^T$

$P=[ M | p_4 ]$

$depth(X,P) = \frac{ sign(det(M)) * w }{T * ||m^3||}$

Projection Matrices

Computing the projection matrices is a simple task of putting all the information together. Note that the first projection matrix set to origin (0,0,0) with no rotation and translation.

$P_1 = \[\left(\begin{array}{ccc} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{array}\right)\]$

$P_2 = K * [R,t]$

Triangulation

In a perfect scenario, two rays extending from the points would intersect at a point in space. However, because of slight errors in the point correspondences the two points would never intersect or would intersect at the wrong point in space. The optimal triangulation algorithm brings the points closer to their respective epipolar lines (the plane that intersects the two cameras and the 3d point) so they intersect at a more accurate point in space [4, p318]. The final step of the algorithm is the actual triangulation. The algorithm is performed for every correspondence between the two images creating a point cloud.

The final step is the creation of the 3D model. This can be approached in various ways. For a simple mesh creation, MATLAB’s Delaunay function proved to yield good results. Texture for each triangle face can be taken from corresponding three points on either image. The issue with method is that it won’t work if any of the three points lay on a different plane. The better method is to create a dense point cloud that has the color information for every vertex. For output, a good model format is OBJ as it has an easy to follow textual representation for the model and is supported in many different model editors.

Model Creation

Textured OBJ model viewed in MeshLab

Additionally, external applications such as MeshLab and Blender have proven useful. MeshLab has many point cloud to mesh construction algorithms under Filters > Remeshing, Simplification, and Reconstruction. Noteworthy reconstruction algorithms include Ball Pivoting Surface Reconstruction algorithm and Poisson Reconstruction. Texturing can be accomplished in Blender by UV mapping using the images.

HTC Touch Pro Keyboard Fix

2010-02-21T19:24:00.006-05:00

Update

Two months later my keyboard stopped working again. I followed my own fix but it didn't work. I bought a new keyboard from eBay for $26 and installed it. No problems yet. Side note, I had to buy a Phillips size #000 screw driver to remove the four screws holding the keyboard to the sliding bracket. Again, this video on replacing the keyboard was useful.

Recently the keyboard on my Sprint HTC Touch Pro stopped working. I also didn't have the phone insurance plan (d'oh!) so I couldn't send it in to get it fixed without costing to much. So I did some research and found that when pushing down hard on the space key on the keyboard it makes the keyboard work again. This actually worked, however, it did not last. After a week of on and off keyboard functionality I decided it was time to dig deeper for a solution by opening the phone. Below the space key on keyboard is the keyboard's connector to the cellphone. It seems that the connector gets loose or the solder doesn't correctly make the connection. The solution is to push down on the solder so it makes the connection firm again.

Warning: Disassembling the phone WILL void your warranty and MAY damage your phone. Only do this if you feel comfortable dealing with electronics.

Tools
Torx screw driver with T-6 head
Flathead screw driver (Recommend 3.0mm)

(Top) Torx screw driver, with T-6 Head
(Bottom) 3.0mm flathead screw driver

Before we begin, this video on keyboard replacement might be helpful in see how the phone looks on the inside. However, we will not be replacing the keyboard.

Directions

Turn off the cellphone, remove the back cover and remove the battery.
Unscrew the 4 Torx screws from the back. The screw in the top left has a sticker over it, removing this will most likely void the warranty.
Using the flathead screw driver, push down on the edges to pop out the keyboard. The keyboard should slowly push out on the other side. Work your way around the keyboard a few times. Alternatively, you can run the flathead screw driver or your finger nail around between the keyboard and the chrome frame until it pops out.
Once the keyboard is free, lift the side up next to the volume keys. Note: the keyboard frame is connected on BOTH sides, therefore it will not become fully detach, careful not to yank out the connector on the other side.
Lift up the orange cable directly below the space key.
Take the flathead screw driver and gently push down on the connector area. This should make the keyboard connection more firm.
Push the orange cable back down and put everything back.

Now the keyboard should be working again, enjoy. :-)

Images

Keyboard cable (lift up)

Keyboard connector (push down)

Additional images

Microsoft Notepad Bug

2009-11-23T21:08:00.001-05:00

In my probing of Notepad I've found a bug in the Find dialog:

OS: Windows XP SP 3 (Version 5.1.2600)
In the Find dialog box it allows one to enter a number of characters (unlimited?). However it only looks at the first 128 characters entered in the Find box. This could be misleading when somebody pastes a long string into the find dialog box. Additionally, when you reach the end of the search, when it prints out the string it cannot find it mentions only the first 128 characters. Find only does search for the first 128 characters, but it doesn't explicitly make it clear.

Below is an example when I tried entering 128 characters of 'a' then typing in 'ignored'. The image show how 'ignored' is not part of the search: finds the first 128 characters and when at the end of the find it displays that it cannot find the only the first 128 characters of the find string.

Thoughts & Fixes:

Allow only 128 characters to be entered into the Find text box.
When more than 128 characters get pasted into the Find text box have a message bubble explaining that the text was truncated.
Notepad++ seems to suffer from a similar issue in not explicitly making the user aware that its only searching for only first number of characters. However, Notepad++ actually cuts the string off after you execute the search, which implicitly tells the user that only the first number of characters were searched. Notepad only does this after you perform the search, close the Find dialog and reopen it, does it cut off the find string.

Software Testing: Overview

2009-11-22T00:11:00.002-05:00

Here's my condensing of Wikipedia's Software Testing and a few sub pages.

Software testing can’t make your code 100% bug free, but give more confidence it has less bugs.

Software Testing Topics
Functional vs. non-functional testing
Functional testing

verify a specific action or function of the code
Can the user do this?
Does this particular feature work?

Non-functional testing

May not be related to a specific function or user action (i.e., scalability or security)
How many people can log in at once?
How easy is it to hack this software?

Defects and Failures
Software defected that is not caused by coding errors. A programmer makes an error (mistake) which results in a defect (fault, bug) in the software source code. If this defect is executed, in certain situations the system will produce wrong results, causing failure.

Requirement gaps (unrecognized requirements)

Non-functional requirements: testability, scalability, maintainability, usability, performance, and security

Important to find faults early: Requirements -> Architecture -> Construction
Test is the last step before release, important to find defects now or 10x more costly in post-release

Compatibility

Frequent cause of software failure is compatibility with another application, new operating systems, or web browser version

Input combinations and preconditions

Testing under all combinations of inputs and preconditions is not feasible

Non-functional quality (how it is supposed to be versus what is supposed to do)

Scalability, performance, compatibility, reliability

Static vs. dynamic testing
Static Testing

Reviews, walkthroughs, or inspections
Unfortunately often omitted

Dynamic testing

Executing programmed code with a given set of test cases
Can start before program is complete (testing modules or discrete functions)
Drivers or debugger

Software verification and validation
Verification

Have we built the software right? (I.e., does it match the specification)

Validation

Have we built the right software? (i.e., is this what the customer wants)

Software Testing Team

Manager, test lead, test designer, tester, automation developers, and test administrator

Software Quality Assurance (SQA)

* Examine the and change the software engineering process itself to reduce the amount of faults – defect rate
* Mission critical vs. Non-mission critical

Banking software vs. MS Calc

Testing Methods
The Box Approach
Black box testing vs. white box testing are different point of views that a test engineer takes when designing test cases.
Black Box Testing
Black Box Testing is done without any knowledge of internal implementation.

* Equivalence Partitioning

o Divides the input data into partition of data from the test cases can be derived
o Test cases are designed to cover each partition at least once
o Example (input: months expressed as integers, the input parameter 'month' might have the following partitions)

        ... -2 -1 0 1 .............. 12 13 14 15 .....
      --------------|-------------------|---------------------
invalid partition 1     valid partition    invalid partition 2

* Boundary Value Analysis

o Tests are designed to include representatives of boundary values. Values on the edge of an equivalence partition or at the smallest value on either side of an edge. Common locations for errors that result in software faults. Frequently exercised in test cases.
o Example (input: months expressed as integers, the input parameter 'month' might have the following partitions), pick values before, on, and after boundary:

        ... -2 -1 0 1 .............. 12 13 14 15 .....
      ---------------|-----------------|---------------------
invalid partition 1   valid partition     invalid partition 2

All-Pairs Testing

For each pair of input parameters to a system, tests all possible discrete combinations of those parameters. Tests can be parallelized.

Fuzz Testing

Provides invalid, unexpected, or random data to the inputs of a program. Looks for when program fails (i.e., crashing).
Areas of interest: file formats, networking protocols, environment variables, keyboard/mouse events, sequences of API calls, (even parts not considered “input): databases, shared memory, precise interleaving of threads.
Inputting random stream of bits to applications
Can find memory leaks (useful in languages like C/C++)
Negative testing
Security: Interesting areas cross trust boundaries
Bug finding tool rather than quality assurance
Pros

Increases security and safety
Creates tests with odd data
Can find exploitable bugs

Cons

Needs mature specifications, as fuzzing is based on this
Proprietary protocols make it difficult to generalize fuzzing methods
Code coverage can be poor
Simple faults

Model-Based Testing

Test cases are derived from a model that describes (usually functional) aspects of the system

Traceability Matrix

Table that correlates two relationships to determine completeness of the relationships

Exploratory Testing

Learning, test design and test execution
Pros

Less preparation
Important bugs found quickly
do not have to complete a series of scripted tests

Cons

Dependent on testing skills
Tests can’t be reviewed (unlike scripted testing)
Reproducing the test is difficult

Use when requirements and specifications are incomplete or if there is a lack of time.

Specification-Based Testing

Test the functionality of software according to requirements
Pros

No ‘bonds’ with the code, has the “tester” mentality

Cons

Walking in the dark (tester doesn’t understand how code works)
Tester could over or miss areas of the code

White Box Testing
Access to internal data structures and algorithms

Types of white box testing

API Testing – Testing of the application using Public and Private API calls
Code Coverage – creating tests to satisfy some criteria of code coverage (e.g., the test designer can create tests to cause all statements in the program to be executed at least once)
Fault Injection methods – improving the coverage of a test by introducing faults to test code paths
Mutation Testing methods – modifying program’s source code in small ways, and any tests which pass after code has been mutate are defective.
Static Testing – white box testing includes all static testing

Test Coverage
White box testing methods can also be used to evaluate the completeness of a test suite created with black box testing methods.

Grey Box Testing
Access to internal data structures and algorithms for purposes of designing the test cases but testing at the black-box level

May include reverse engineering

Testing Levels
Grouped by where they are added in the software development process or by the level of specificity of the test

Unit Testing
Tests that verify the functionality of a specific section of code, usually at the function level

May have multiple tests for one function

Integration Testing
Seeks to verify the interfaces between components against a software design

Individual software modules are combined and tested as a group
Purpose is to verify functional, performance, and reliability requirements placed on major design items
Occurs after unit testing and before system testing

System Testing
Tests a completely integrated system to verify that it meets requirements

System Integration Testing
Verifies that a system is integrated to any external or third party systems defined in the system requirements

Regression Testing
Focuses on finding defects after a major code change has occurred
Seeks to find old bugs that have come back

Acceptance Testing
Black-box testing performed on a system prior to its delivery

Alpha Testing
Simulated or actual operational testing by potential users/customers or an independent test team

Beta Testing
Released to a limited audience outside of the programming team

Non-Functional Software Testing
Software performance testing, including Load Testing
Checks to see if software can handle large quantities of data or users

Performance Testing
Load Testing

Stability Testing
Checks to see if the software can continuously function well in or above an acceptable period

Usability Testing
Check if the user interface is easy to use and understand

Security Testing
Essential for software that processes confidential data to prevent system intrusion by hackers

Internationalization and localization
Needed to test these aspects of software for which pseudo-localization is method can be used

Destructive Testing
Attempts to cause the software or a sub-system to fail, in order to test its robustness

The Testing Process
Traditional CMMI or waterfall development model

Performed by an independent group of testers after the functionality is developed before it is shipped to the customer
Could compromise the time devoted to testing

Agile or Extreme development model

Test-driven software development

A Sample Testing Cycle
Waterfall development model

Requirements analysis
Test planning
Test development
Test execution
Test reporting
Test result analysis
Defect retesting
Regression testing
Test closure

Automated Testing
Used in Test-driven development
Continuous Integration software will run tests automatically every time code is checked into a version control system

Testing Tools
Testing/debug tools include features such as:

Program monitors, permitting full or partial monitoring of program code:

Instruction Set Simulator – complete instruction level monitoring and trace
Program animation – step-by-step execution and conditional breakpoints
Code coverage reports

Formatted dump or Symbolic Debugging – inspection of program variables
Automated functional GUI testing tools are used to repeat system-level tests through GUI
Benchmarks – run-time performance
Performance analysis (or profiling tools) – highlighting hot spots and resource usage

Measuring Software Testing

ISO 9126: reliability, efficiency, portability, maintainability, compatibility, usability

Testing Artifacts

Test plan – test specification
Traceability matrix – correlates requirements or design documents to test documents. It is used to change tests when the source documents are changed, or to verify that the test results are correct
Test case – id, requirement references from a design specification, preconditions, events, a series of steps to follow, input, output, expected result, and actual result.
Test script – combination of a test case, test procedure, and test data
Test suite – collection of test cases
Test data – multiple sets of values or data are used to test the same functionality of a particular feature.
Test harness – software, tools, samples of data input and output, and configurations

Types of Test Cases

Positive Test
Does it work when it gets good data?

Negative Test
Does it work when it gets bad data?

Probe Test
How does it handle when somebody tries to break it (usually with bad data)?

Sources

Wikipedia - Software Testing and related pages.
Wikipedia - Software Testing Portal

Windows 7 Paint Bug

2009-11-21T23:24:00.002-05:00

As I was testing the line feature in Microsoft Paint in Windows 7 (Version 6.1, Build 7600) I noticed a (small) bug in the line drawing behavior.

When one draws a line (and before the line loses focus), I noticed that Rotate 180 degrees, Flip vertical, and Flip horizontal all don't work on the line. It seems as if a line gets treated differently as the other shapes (all other shapes have a dotted bounding box around them, whereas a line doesn't). However, its strange that Rotate left/right 90 degrees both work but Rotate 180 degrees doesn't -- maybe somebody just forgot?

The issue can be resolved in one of two ways: gray out the three Rotate drop down options, or (better) implement the logic necessary to get the three malfunctioning rotates to work.

Tether Windows Mobile 6.5 to a Computer

2009-11-17T18:35:00.005-05:00

This method will show how to tether a Windows Mobile phone to your computer (namely a laptop) without the use of addition software.

Service Provider: Sprint
Phone: HTC Touch Pro (Windows Mobile 6.5)
Computer: Windows XP (Active Sync installed but not running)

1. Download and install PHM Registry Editor on phone.

2. Add/Edit the following values using the registry editor:



[HKEY_LOCAL_MACHINE\Comm\InternetSharing]

Extension=""



[HKEY_LOCAL_MACHINE\Comm\InternetSharing\settings]

ForceCellConnection="Sprint"



[HKEY_LOCAL_MACHINE\Comm\InternetSharing]

MaxCMCon=0

3. Connect phone to the computer's USB

4. Open Internet Sharing, Click "Connect"

Side note: Only port 80 (HTTP) connections are allowed to communicate, meaning only browser related activity is allowed. Thus no external internet based applications will work, such as instant messaging. An easy work around is to use browser based applications such as Meebo for instant messaging.

Software Testing Overview

2009-11-05T17:31:00.000-05:00

Types of Test Cases
Ideally, you want to abstract your tests far back enough so you can apply it in different situations, but before you can do that you must have a clear picture of what could go wrong. Once you have a clear picture of the problem space, then you can create automated tests.

Happy/Positive Case
How the application or method behaves when given good input (errors or exceptions should not happen).
Example



int divide( 10, 2 ) // 10 / 2, return 5

Negative Case
How the application or method behaves when given bad input (errors or exceptions should happen).
Example



int divide( 1, 0 ) // 1 / 0 should return error or throw exception

Probe Case
How the application or method behaves when some one is tries to negatively manipulate the application. It is also important to note what the application is doing: is it a notepad program (relatively low damage) or is it the registry editor (relatively high damage). Accessing passwords (relatively high damage)? Character's money or level or stats in multilayer video game (relatively high damage) vs. offline single player game (relatively low damage). The list goes on.
Example



void foo( garbageData, garbageData2 ) // Could one pass bad data and exploit the application?

Usability Test
Not everyone thinks the same, especially when it comes to the programmer and the user. How does the application or method behave for other people? or Does the application behave like how the user would anticipate?

Example: Testing a window

Given

Test Notepad's Find window/dialog (yes this is purposely vague)

1. Read Documentation
Get the documentation for this window. This will will answer "How should the window behave?". This will create the initial questions.

2. Make Test Table

To organize our test cases, we'll create a table of all possible tests. We'll start with labeling the headings of our tests:

Name / Area / Component	ID	Description	Requirements	Test Category	Author	Automated	Pass/Fail	Remarks

Make a list of things we see:

Window
"Find" Window Title
Window close button
"Find what:" label
Find text box
"Find Next" button
"Cancel" button
"Match case" check box
"Direction" group
"Up" and "Down" radio buttons
Accelerators on "Find what:", "Find Next", "Match case", "Up", "Down"
Window theme
Layout & Layout behavior

Other items that we didn't see here but could have been tested: Drop Down List Boxes, Combo Boxes, List Boxes, menu bar, scroll bars, tabs.

Now, compile into the table:

Name	Description	Requirements	Category	Author	Automated	Pass/Fail	Remarks
Window
"Find" Window Title
Window Close Button
"Find what:" label
Find text box
"Find Next" button
"Cancel" button
"Match case" check box
"Direction" group
"Up", "Down" radio buttons
Accelerators on "Find what:", "Find Next", "Match case", "Up", "Down"
Theme, Layout, Layout behavior

3. Write Tests
Perform tests: Positive Test (PT), Negative Test (NT), Probe Test (PrT), Usability Test (UT)

Fill out table with the tests

4. Beta Test
Once you are confident of your work while maintaining the invariants specified in the documentation, ask others for input. What does your developer think (if you didn't develop the item of test) or fellow developer? What does your lead think? What does the customer think?

5. Ship
Ship. Rinse. Repeat. As Jeff Atawood (play off Glengarry Glen Ross) says, Always Be Shipping. Assuming your application is now a solid product, some times the best testing is done by the community. Their criticism, tinkering, tearing apart of your application may be the only way to get the experience/evolution your application needs (or at least the drive to figure it out!).

What's Wrong with this Code?

2009-10-05T18:40:00.006-04:00


doFoo()
{
  int x = 10;
  Foo *foo = new Foo();
  for ( int i = 0; i < 100; ++i )
  {
    x += i;
    foo->add(x);
  }
}

Easy right? We forgot to free the memory associated with the pointer foo. This is what we call a memory leak!

Fix:


doFoo()
{
  int x = 10;
  Foo *foo = new Foo();

  for ( int i = 0; i < 100; ++i )
  {
    x += i;
    foo->add(x);
  }
  
  delete foo; // this frees up the memory associated with the pointer foo.
}

What if we had an array of Foo's ?


 Foo *foos = new Foo[100];
 // ...
 delete [] foos;

Stack vs. Heap: Overview

2009-10-03T20:52:00.005-04:00

Both deal with how memory is managed

Stack	Heap
Inside program (Program space)	Outside program (Managed by OS)
Fast	Slow (because of system calls to allocate memory)
Run-time variables (function parameters, return address, return value, primitives)	Dynamically allocated variables (Objects) Global and static variables
Stack variables are destroyed automatically when out of scope	Heap variables are destroyed when manually de-allocated Note: If memory is never de-allocated then a memory leak occurs
needs initialization	needs allocation
small memory space Note: If to much memory is allocated on the stack then we have a stack overflow. This is dangerous because it can corrupt memory or cause exploitative code to be executed.	relatively large memory space

Examples

int i = 123;                   // on stack

int stackArray[256];                    // also on stack

int *heapArray = new int[256]; // on heap

Sources
Stack-based memory allocation
Dynamic memory allocation
What is stack & heap?
Heap vs. Stack

Merge Sort vs. Quick Sort: Overview

2009-10-03T18:19:00.007-04:00

Merge Sort	Quick Sort
Time complexity (Average): O(n log n)	Time complexity (Average): O(n log n)
Time complexity (Worst): O(n log n)	Time complexity (Worst): O(n^2) (Occurs when list is sorted)
Stable sort Not dependent on any factors Average case = Worst Case	Not a stable sort Dependent on randomness of list
Memory: O(n) Additional memory space required	Memory: O(log n) Memory Complexity (Best): O(1) Little additional memory space required

When to use Merge Sort? When additional memory usage is not a problem and list could be partial sorted

When to use Quick Sort? When additonal memory usage is a problem and the list is randomized.

[Source: Sorting Algorithm]

Jump Breaks Broke the Blog -- and solution

2009-09-26T11:34:00.001-04:00

Problem
The people at Blogger added a Jump Breaks for posts on the front page but for some reason it broke my front page layout. The right side menu is below all the posts.

Solution
The problem occurs when the  tag is used between another (div) tag. So the simple fix is to make sure to close any tags before using a jump break, then reopen them after it.

Windows Mobile Software Round-up

2009-08-22T00:29:00.008-04:00

I recently got the HTC Touch Pro with the Windows Mobile 6.1 Pro operating system installed. Shortly after getting over the hype of my new device, I set out on finding quality software for the Windows Mobile. These are some of the top programs I found that work best on my Windows Mobile device:

General/Interface

Slide2Unlock (S2U2)
G-Alarm (2nd place Klaxon)
TorchButton
Facebook: Dedicated Facebook application for Windows Mobile
TagReader: A special bar code reader that serves as basically Internet shortcuts.
PdaNet for Windows Mobile: Connect your PC/Laptop to the internet using the phone's cellular network (requires internet data plan). Useful when you can't find WIFI.
YouTube
Bing

Tweaking

Games

Media

Instant Messaging

AIM
Skype

Web Browsers

Misc. GPS/Internet Based

Note: You'll need .NET Compact Framework 3.5 Redistributable for the programs to work. Look for the CAB file that matches your device in C:\Program Files\Microsoft.NET\SDK\CompactFramework\v3.5\WindowsCE. For me it was NETCFv35.wm.armv4i.cab.

Update
Previously I mentioned Klaxon as my choice for the Windows Mobile alarm replacement, however (at its current state) it tends to run into problems with S2U2. Recently I found another WiMo alarm program called G-Alarm (which looks very similar to Klaxon) that has some cool features like having to do mazes or calculations before being able to disable/snooze the alarm, or having music play lists instead of alarms (recommend getting some soothing nature sounds). AGEye, the creators of G-Alarm, also some other neat little applications on their site including a stop-watch, couple games, and some tweaking programs.

Another program I highly recommend is the Windows Media Player replacement Nitrogen. Easy to use interface and responsiveness makes this a clear choice over the default software.

If the software is free to use please remember to donate to (starving) the developers! :-)
and
If you've found some application that you would like to share please comment below!

Blog Update

2009-08-19T16:26:00.002-04:00

Somebody at Reddit liked my article and mentioned in his comment in an Ask Proggit post: "Are you using dark themes on your editors/IDEs? Is that any more eye friendly?". Below you can see a sharp spike in visitors.

But now we return to your regularly scheduled program of little visitor traffic. ;-P

Eclipse Java Color Themes

2009-08-08T02:52:00.015-04:00

Eclipse isn't the best when it comes to customizations but with a few tricks we can alleviate some of the issues. One such issue is color themes. There is no easy way to export color settings (for creation of themes) but there are two files that hold the syntax and text editor coloring information.

Update
Eclipse Color Themes (how-to) by Roger Dudler and Felix Dahlke is a better method of importing themes into Eclipse. My method was just a temporary work around until a plug-in was written.

Note: Files from and tested with Eclipse 3.5 (Galileo) using Java

The two main areas that control the IDE's coloring:

Window | Preference | Java | Editor | Syntax Coloring

Window | Preference | General | Editors | Text Editors

These preferences are saved in:

[workspace]\.metadata\.plugins\org.eclipse.core.runtime\.settings\org.eclipse.jdt.ui.prefs

[workspace]\.metadata\.plugins\org.eclipse.core.runtime\.settings\org.eclipse.ui.editors.prefs

Linux/Mac [workspace]/.metadata/.plugins/org.eclipse.core.runtime/.settings/

Where,

org.eclipse.jdt.ui.prefs = Syntax Coloring

org.eclipse.ui.editors.prefs = Text Editors

So from that one can make, import, and export their preferences easily without editing the files manually.

Here are some themes I've found (and created!)

Default (Originally from Eclipse)

Inkpot (Originally from here)

Vibrant Ink (Originally from here)

Wombat (Originally from here)

Sula (My theme)

Zenburn (Jani Nurminen)

Download all files here

Finally, there are more theme ideas that can be found at the StackOverflow post on Color Schemes for Programming. If you've got a cool theme, post a link and I'll update the post.

Add Scroll and Media Keys to Microsoft Natural Ergonomic Keyboard 4000

2009-02-27T18:44:00.010-05:00

The Microsoft Natural Ergonomic Keyboard 4000 is a fantastic keyboard for programmers and typists. in general However, the keyboard has some minor shortcomings:

Zoom slider in the middle of the keyboard is a bit useless
There are no Previous Track and Next Track media keys

Fix 1: Change the Zoom slider to a Scroll slider

Open the file C:\Program Files\Microsoft IntelliType Pro\commands.xml.
Find the XML tag ALL then sub-tag labeled Application with the attribute UniqueName set to StandardSupport (in my case the correct Application tag was right below the All tag).
Change the ZoomIn to ScrollUp and the ZoomOut to ScrollDown. End result should look similar to below.
Save the file and restart your computer.

Now the Zoom slider now scrolls instead of zoom!

Note: The behavior is still a little strange in Firefox, and Internet Explorer still zooms.

Fix 2: Adding Special/Media Keys to the My Favorite keys

Note: The next fix will involve the registry, continiue only if you feel comfortable working with the registery and after you make a backup the registry.

To change the "My Favorites" keys (labeled 1-5) we need to look at the registry.
For this example we want to assign the Next Track (0x2BF) to My Favorite key 1.

Note: The folder icons in the Registry Editor are called keys. The icons that look like scraps of paper are called values.

Start | Run... | Command: regedit
Open the registry key: HKEY_CURRENT_USER\Software\Microsoft\IntelliType Pro\EventMapping\
In here you should see a couple folders numerically numbered.

My Favorite Key 1 - Registry Key 78 - Notepad Shortcut

My Favorite keys 1-5 correspond to the registry keys 78-82
If registry key 82 (keyboard key 5) doesn't exist, right click on EventMapping key New | Key and name it 82
Open registry key 82, if there is anything besides the (Default) value delete them.
Right click on registry key 82, New | DWORD Value
Name: Command
Value: 2BF
Base: Hexadecimal

End Results
Close the Registry Editor and you're done! (No need to restart the computer).

Below I provided additional special keys you can set to your Favorite keys (note I wasn't able to test all of them but most of them seem to work, comment below if you find any more!).



Browser

064(100) - Back

065(101) - Forward

066(102) - Refresh

067(103) - Stop

068(104) - Search

069(105) - Favorites

06A(106) - Web/Home



Windows

0C8(200) - Cut (Ctrl+x)

0C9(201) - Copy (Ctrl+c)

0CA(202) - Paste (Ctrl+v)

0CB(203) - Undo (Ctrl+z)

0CC(204) - Redo



Word

12D(301) - Exit

12E(302) - Help

12F(303) - Show/Hide Desktop

130(304) - Next window

131(305) - Previous Window

132(306) - Log off

133(307) - New

134(308) - Open

135(309) - Close

136(310) - Print

137(311) - Save

138(312) - ???

139(313) - ???

13A(314) - ???



Windows (cont.)

13B(315) - Find

13C(316) - Lock Workstation



13F(319) - Zoom in

140(320) - Zoom out



191(401) - Spell Check



Media

2BF(703) - Next track

2C0(704) - Previous Track

2C1(705) - Stop (media)

2C2(706) - Play/Pause



Windows (cont.)

321(801) - Mail

322(802) - Media

323(803) - Calculator

324(804) - My Computer

325(805) - My Documents

326(806) - My Pictures

327(807) - My Music

328(808) - Messenger

329(809) - Calendar



Outlook

384(900) - Reply

385(901) - Forward (email)

386(902) - Send



Office Programs

3E8(1000) - Word

3E9(1001) - Excel

Automatically set "Do Not Share" option in Delicious

2009-02-22T21:08:00.011-05:00

Delicious is a great social bookmarking service. It also doubles as a cross-application/platform bookmark syncing. For those who want to use it as a personal bookmark syncing service having all your bookmarks shared can be inconvenient. When adding new bookmarks there is the problem of the new bookmark being shared. Here is solution for having the "Do Not Share" check box ticked on default in the Firefox Delicious add-on:

Normal Mode (Default)

Browse to about:config
Right click: New | Integer
Preference name: extensions.ybookmarks@yahoo.sharemode
Value: 1
Restart the browser

Classic Mode

Download Greasemonkey
Right click on the Greasemonkey icon in the status bar and create a new script
Enter the following into the script

// ==UserScript==

// @name           delicious default do not share

// @namespace      http://delicious.com

// @description    Set the 'Do Not Share' checkbox in the Save a Bookmark window in Classic Delicious mode (Tested with version Delicious 2.1 Firefox 3 Add-on)

// @include        http://delicious.com/save?*

// ==/UserScript==



window.document.getElementById('share').checked = true;

Bookmarklet

Finally, bookmarklets can be used for making Delicious bookmarks. The bookmarklet is best if you don't want or can't install the Firefox add-on. Drag this Delicious Bookmarklet to your bookmark toolbar. (Thanks Björn)

Note: This was tested with Firefox 3 with the Delicious add-on 2.1

Keep in mind that Delicious is a social bookmarking service, so use this only when absolutely needed!

Moving to Blogger

2009-02-19T09:54:00.005-05:00

Hello World :)

I'm moving my current blog from Wordpress to Blogger. I'm in the transition of moving the posts over so hang tight!

Update: Finished moving entries over. Hello people from Wordpress :)

NetHack Online GUI

2009-02-09T09:40:00.004-05:00

One of the projects I'm currently working on is a graphical interface for the game NetHack for NetHack.Alt.Org (a.k.a NAO) telnet server. My aim was to create a telnet interpreter between the server and the client so player can play with graphical tiles over the classical ASCII mode :). Some of the diehard NetHack ASCII fans say its blasphemy but I think its cool ;).

In my venture I learned lots about telnet (which you can read more about here) and Windows C# programming, and flexed some threading knowledge.

Issues

Correctly interpreting terminal controls
Converting the ASCII codes to the NetHack tiles, and doing so efficiently.
Correctly interpreting in game menus

Downloads

Source code
Screen shots

If anyone knows how to solve some of the issues (mostly the 2nd issue) please leave a comment :)

NetHack Command line Trick

2009-02-07T10:48:00.000-05:00

For those who still play the old hack-and-slash game called NetHack one can use command line to get your game up quickly. The user can pass it the class/race/role/etc straight to the game. This can be used to setup your favorite settings into a shortcut so you can get straight to the fun!
Here's an example for Windows Shortcut (Target field):

"C:\NetHack\NetHackW.exe" -r human -p barbarian -g male -a neutral

Now if I can only figure a way not to die so quickly :-P

Telnet Programming with C#

2009-01-26T09:34:00.004-05:00

I'll update the post with the code I used in my project, in the meantime read: Telnet Options and Option Negotiation

History

In 1978, Digital Equipment Corporation (DEC) created the VT100. It was the first digital mass-market terminal to include many terminal graphic renditions. The terminal was on a choice of 80 or 132 column display. The VT100 family implemented the ANSI escape codes, which will be discussed later. Today the VT100 terminal has become the standard for terminal emulators, xterm being one of the more popular ones.

Connection

The server and client will send a series of DOs, DON'Ts, WILLs, and WON'Ts to each other. This is called negotiating and the start of each negotiation line is IAC (Interpret As Command, 0xFF). It is your job to correctly reply to its requests by telling what your client will do by sending your reply to negotiating commands along with your requests to the server.

Negotiation

For example if machine 1 (either the client or the server) sends a DO it must be replied by machine 2 with a WILL or a WON'T, depending on what the machine 2 chooses the implement -- so in general:

DO: Gets replied with a WILL or a WON'T
WILL: Gets replied with a DO or DON'T

Syntax

IAC NEGOTIATION(DO/DON'T/WILL/WON'T) OPTION (Most common ones are 0x00 to 0x31)

Definitions

IAC = 0xFF

DO = 0xFD

SUPPRESS_GO_AHEAD = 0x03

Example

IAC DO SUPPRESS_GO_AHEAD

0xFF 0xFD 0x03

Sub-Negotiation
Most negotiation options are on or off but some require more information.

Definitions

TERMINAL_TYPE = 0x18

SUB_NEGOTIATE = 0xFA

SUB_NEGOTIATE_END = 0xF0

IS = 0x00

Example
Conversation between the server asking the client's terminal type and the client responding with XTERM:

Server: IAC DO TERMINAL_TYPE

Client: IAC WILL TERMINAL_TYPE

Server: IAC SUB_NEGOTIATE TERMINAL_TYPE

Client: IAC SUB_NEGOTIATE TERMINAL_TYPE IS "XTERM" SUB_NEGOTIATE_END

After Negotiation

Once the server is finished with its primary negotiations, it will start sending data. A chunk of data begins with a byte other than IAC (unless followed by two 0xFF's). Furthermore, terminal controls implementing the ANSI escape control start with ESC[ (known as Control Sequence Introducer or CSI) followed by the control information.

Terminal Control

As mentioned above, within the data packet are terminal controls. They start with the ESC[ (0x1B 0x5B) bytes and (always?) end with the NULL byte (0x00). These terminal controls can range from status, setup, fonts, cursor, scrolling, tabs, erasing, printing, keyboard, and colors. Probably the most prominent of these are cursor and color control.

Color Control Syntax

ESC[{attr1};...;{attrn}m

Color Control Example

ESC[42mNULL ESC[34mGreen Background with Blue ForgroundNULL ESC[0mNULL

The first control sets the background to green, the next control sets the foreground to blue, outputs the text, then finally resets the terminal to default colors.

C# Code

Here are two C# classes I wrote in light of helping with myself with telnet programming. The code is still being developed and was written for my purposes so some things may not be what you need. However, you can download it and modify/add what you need:

TelnetHelper (Methods for constructing telnet messages)
TelnetController (Methods for sending/receiving telnet messages)

Readings and Resources
Telnet programming with C# isn't all that bad -- with the correct resources.
Here are some I used:

Telnet

The TCP/IP Guide - Telnet Protocol (By far the best resource, explains how the protocol works in a comprehensive manner)
Telnet options
Telnet (also the RFC links at the bottom of the page)

Terminal (xterm / VT100)