TechnoBlogy » Tools/Tech

Team Viewer now available for Android

Nauman — Mon, 29 Nov 2010 09:08:48 +0000

Team Viewer is an excellent screen sharing and file transfer application that can be used to facilitate business collaborations and remote desktops sharing.

Team Viewer has launched a new version “Team Viewer 6” in which they have also included it Android application as well. It was great tool for accessing computers remotely, and now it mobile variations gives more quick access. Previously it has been developed for IPhone and IPads, and now its Android beta version is in market.

Here are some of the features:

Support your clients and colleagues spontaneously.
Access your office desktop with all of its documents and installed applications.
Remotely administer unattended computers (e.g. servers).

People get this great tool for free before January 2011.

Traversing DOM using JavaScript

Nauman — Sun, 22 Nov 2009 07:20:52 +0000

The HTML DOM defines a standard way for accessing and manipulating HTML documents.

The DOM presents an HTML document as a tree-structure expressed as an XML document.

DOM is a language independent API, as it can be used in Java, .NET, JavaScript and many more. I will use it with JavaScript to for my sample code provided below.

When talking about DOM trees , you are really talking about a hierarchy of nodes. These are some objects Inside XML(XHTML,HTML) document :

document - is very top level node wich contains all other nodes

element - represents the contents of a start tag and end tag

Attr — Represents an attribute name-value pair

Text — Represents plain text in an XML document contained within start and end tags or inside of a CData Section

CDataSection — The object representation of . This node type may contain any symbols including quotes.

To manipulate this obects i.e makes changes in XML(XHTML, HTML) we have some properties and methods:

nodeName - The name of the node

nodeValue - The value of the node

nodeType - One of the node type constant values

ownerDocument – Pointer to the document that this node belongs to

firstChild - Pointer to the first node in the childNodes list

lastChild – Pointer to the last node in the childNodes list

childNodes – A list of all child nodes

previousSibling – Pointer to the previous sibling; null if this is the first sibling

nextSibling – Pointer to the next sibling; null if this is the last sibling

hasChildNodes() – Returns true when childNodes contains one or more nodes

attributes – Contains Attr objects representing an element’s attributes; only used for Element nodes

appendChild(node) - Adds node to the end of childNodes

removeChild(node) - Removes node from childNodes

replaceChild (newnode, oldnode) – Replaces oldnode in childNodes with newnode

insertBefore (newnode, refnode) — Inserts newnode before refnode in childnodes

Let’s do some example to demonstrate functions and properties mentioned before.

Adding nodes using DOM:

In idex.html we have form tag with textarea and submit button inside

</p> <p>

In script.js addNode() function is triggered on form submit it gets value of textarea, creates text node then paragraph tag and appends all these

as child of body tag.

window.onload=initAll;

function initAll()

{

document.getElementById(“form1″).onsubmit=addNode;

}

function addNode()

{

var inText=document.getElementById(“textarea”).value;

var newText=document.createTextNode(inText);

var newGraf=document.createElement(“p”);

newGraf.appendChild(newText);

var docBody=document.getElementsByTagName(“body”)[0];

docBody.appendChild(newGraf);

return false;

}

PHP Debugging Techniques – Part III

aabi — Wed, 18 Nov 2009 05:00:03 +0000

Use an IDE and Debugger

Most developers use some Integrated Development Environment (IDE) for the majority of their development, and I highly recommend that you do the same. Many PHP developer use Zend Studio and you only have to look at the feature list to see why they find it completely indispensible, especially for debugging. If you have not used an IDE before I recommend you have a look at one of the applications listed at the end of this section.

Also a remote debugger (e.g. ZendDebugger) is used, which ties into the IDE. The remote debugger is a PHP module that allows you to debug code on your server using the IDE on your local machine. You can set breakpoints, inspect variables, examine stack traces, profile code and all the other benefits you would expect from a debugger.

I use Netbeans IDE for my PHP development. Here is an article on Debugging PHP Source Code in the NetBeans IDE

Unit Testing

Testing is an essential aspect of developing in any programming language. If you don’t test your source code then how can you verify it works as expected? Manual testing can only be performed irregularly and usually only in limited ways. The answer to testing source code regularly, and in depth, is to write automated tests which can be frequently executed.

Unit Testing may not be everyone’s idea of fun, but it can be very effective for developing larger projects. It can give you confidence when you have to make significant changes to the code base, as well as point out problems before your code goes into production.

There are two catches with unit tests, the biggest of which is that you have to actually write the Unit tests themselves. Although this should save time in the long run (or at least lead to a more robust product), it is hard to avoid thinking that you could be spending the time developing functionality.

The second catch is that it often forces you to refactor your code into more test-friendly chunks. This is probably a good thing but it will take more time. The best approach would be to write unit tests from the very start of the project or, for an existing project, you can write a unit test for every bug that is fixed.

If you are using unit tests you should also be aware of the concept of code coverage. This is a metric which shows what percentage of your code is run during the testing process. The higher value for this indicates a more robust set of unit tests. You can calculate your code coverage using a debugger, as was discussed in the previous section.

Unit Testing in PHP can be performed using one of three methods. The two common options are Marcus Baker’s SimpleTest and Sebastian Bergmann’s PHPUnit. To add some confusion there’s also the old reliable: phpt. All three allow you to unit test code, and the two Framework libraries also offer numerous extensions.

PHPUnit
PHPUnit is a Unit Testing Suite. It allows for easy creation of regression tests that can be used to determine whether potions of the code meet various operational parameters.

Here is a presentation on Introduction to Unit Testing with PHPUnit

Keep Things Simple

I think this rule probably exists for every profession out there, so it should be no surprise that it applies to software development.
It is good practice to write software using a clear structure and using standard design patterns, but this is only a high level approach to keeping things simple. We also need to keep your individual algorithms as simple as possible as this will make your code easier to understand in six months when it needs fixing, and will also make it easier to fix.

Here are some ways you can achieve this:

Keep an eye on functions that are growing: You may find that you can split the code into several smaller functions.
Functions that are only called in one place may be too specific: You can either bring the code inline, or generalise using several smaller functions. You can always keep the specific function and just use that to call and aggregate the new, smaller, functions.
Watch out for functions with very long names or lots of arguments: This can be a sign that the function could be split into several smaller functions, or it could even be replaced with a class.
Use built in functions where possible: This will help avoid spurious amounts of PHP code and there is a good chance the internal function will be faster as it is written in C (and by the pros!) Some of the most underappreciated internal functions are the array functions.
If you really must have long and complex sections of code, then make sure you add some documentation. You and your fellow developers will be thankful of this when it comes to debugging.

Most of these points are about splitting large functions into smaller ones. It is also important to ensure you do not end up with lots of tiny functions, but I feel this is a much more unusual problem.

Conclusion

The series of three posts was just to give you an overview on debugging techniques in PHP. Hopefully you will have a basic idea now.

PHP Debugging Techniques – Part II

aabi — Wed, 18 Nov 2009 04:33:12 +0000

2. Error Logging

Despite out best efforts, errors can (and do) occur in production environments. When these hiccups do arise we have to ensure that they are dealt with quickly, otherwise users (or even, gasp, clients) get angry.

A logging system can be very useful in tracking down bugs, especially when they happen in a production environment. Such a system can also be useful in debugging during development but lt is found much easier to use an IDE to debug development environment.

Some types of errors we cannot do anything about (think parse errors) and we just have to ensure that we have a close eye on our error logs so we notice when they occur. Fortunately, it is these types of bugs that are normally caught very quickly during development and testing.

As for all the other errors, we need to make sure that they are caught and dealt with properly. Make sure the user is shown a nice error page (with a suitably cute ‘oops-back-soon’ picture) and then log, log
everything in sight! following are strong recommendations:

The stack current trace (see debug_backtrace() and debug_print_backtrace()).
The output of get_defined_vars(). However, this is only useful if you call it at the point the error occurs, not at the point the error is logged. This includes global variables.
Any and all information about the remote user (IP address, user agent, session data)
All global variable data (which includes the contents of $_COOKIES, $_SERVER etc.)
Any other status data which is specific to your application

This information will be invaluable when you come to tracking down errors in production code.

PHP’s Error Logging Facility

# Inside PHP.ini
error_log = /home/vhost/logs/php_error_log
display_errors = Off
log_errors_max_len = 0

Since the errors are being logged there is no need to display them on screen.
Do not limit the error length so the error message is never cutoff.

SysLog

Some errors/bugs are more critical then others and may require immidiate attention. Or you may want to have all your error messages (php, system, etc.) in one place for ease of monitoring.
In these cases instead of using error_log or custom error_handler you may want to use a system logger, syslog.

How you choose to actually capture your errors is your own choice. You can use trigger_error and a custom error handler.

3. Use Manual Redirects When Debugging

Many developers (including myself) will make use of redirects when developing web applications. To refresh your memory, here is how you do a redirect in PHP:

This technique can be very useful for sending the user to the correct page, but it can also be very problematic for debugging. For example, do you keep getting sent off to a bizarre area of your application? Do you know if it is just one redirect sending you there or many? What do you do when you get trapped in an infinite redirect loop?

One answer to these problems is to introduce the concept of manual redirects which would only be used for debugging. Rather than sending a header to the client, a link would be send to the target page as well as a stack trace. This would allow you to monitor the redirects that were happening in my application and clearly see what was happening if the application went wrong.

The code used looks something like this:

function redirect($url, $debug = false)
{
      //If manual page redirects have been enabled then print some html
      if ($debug)
      {
           echo “Redirect: You are being redirected to: $url \n”;
           echo “Backtrace: \n”;
           debug_print_backtrace ();
      }
     else
    {
          header ( “Location: $url” );
    }
exit (0);
}
?>

You may find it useful to pull the $debug value from your configuration system of choice rather than having to pass it for each function call, but it works in this example.

4. Avoid Side Effects

A side effect can be described as a non-obvious effect that was caused by performing an action . For example.
You can see that we start with a $radius and $area variable which we use to show the area of the circle. We then want to display the area of a square with the same dimensions, so we call getSquareArea. Although this function does what its name implies, it also alters the $radius variable (intentionally or not). This is defiantly non-obvious in the rest of our code and can cause severe headaches when it comes to debugging, especially in more complex applications. Of course, you should also avoid global variables for similar reasons.

This also applies to modifying function parameters (which were passed by reference). If you find yourself doing this then you should probably refactor your code. To do this you can either return the parameter rather than modifying it, or you can split the function into several smaller functions. Also, don’t forget that objects are always passed by reference in PHP 5.

PHP Debugging Techniques – Part I

aabi — Thu, 12 Nov 2009 08:06:20 +0000

There are many PHP debugging techniques that can save you countless hours when coding as error reporting, using print statements etc. Let’s go through a little detail of these techniques.

Error Messages

Error messages are your first line of defense as a developer. You don’t want to be developing code in PHP on a server that is not configured to display error messages. However, keep in mind that when your code is debugged and ready to go live, you want to make sure error reporting is turned off because you don’t want visitors to your site seeing error messages that may give them enough knowledge to exploit a weakness and hack your site.
You can also use error messages to your advantage because they display the exact line of code that threw or generated an error. This makes debugging a matter of looking at the line number shown on the browser by the generated error and checking that line number in your code.

1. Error Reporting

An effective but basic debugging technique is to simply turn on error reporting.

Error Reporting in PHP:

There are many configuration settings in the php.ini file. You should already have set up up your php.ini file and placed it in the appropriate directory. There are a couple configuration variables you should know about when debugging your PHP applications. Here they are with their default values (You can discover the current default values of these variables by searching for them in the php.ini file.) :

display_errors = Off
error_reporting = E_ALL

display_errors: The purpose of this variable is self-evident — it tells PHP whether or not to display errors.The default value is Off. To make your life easier in the development process, however, set this value to On by replacing Off:

display_errors = On

error_reporting This variable has a default value of E_ALL. This displays everything from bad coding practices to harmless notices to errors. E_ALL is a little too picky for my liking in the development process because it clutters the browser output by displaying notices on the screen for small things like uninitialized variables. I prefer to see the errors, any bad coding practices, but not the harmless notices.Therefore, replace the default value of error_reporting as follows:

error_reporting = E_ALL & ~E_NOTICE

Why Enable E_NOTICE?
• Warns about un-initialized variables.
• Various non-critical issues that could potentially cause problems.

Error Reporting in Server:

Depending on what Apache is doing, turning error reporting on in PHP may not work because you may have multiple PHP versions on your computer. It’s sometimes hard to tell which PHP version Apache is pointing to because Apache can only look at one php.ini file. Not knowing which php.ini file Apache is using to configure itself is a security problem. However, there is a way to configure PHP variables in Apache to guarantee the setting of the correct error levels.
Also, it’s good to know how to set these configuration variables on the server side to veto or pre-empt the php.ini file, providing a greater level of security.
You should already have toyed with basic configurations in the http.conf file at /conf/httpd.conf when you configured Apache.
To do the same as you just did in the php.ini file, add the following lines to your httpd.conf to override any and all php.ini files:

php_flag display_errors on
php_value error_reporting 2039

This overrides the flag you have set for display_errors in the php.ini file, as well as the value of error_reporting. The value 2039 stands for E_ALL & ~E_NOTICE. If you prefer E_ALL, set the value to 2047, instead. Again, make sure you restart Apache.

As a Summary:

# Inside PHP.ini
error_reporting = E_ALL
# Inside httpd.conf or .htacess
php_value error_reporting 2047
# Inside a script
ini_set(“error_reporting”, E_ALL | E_STRICT);
/* or */
error_reporting(E_ALL | E_STRICT);
?>

Next, we’ll test error reporting on your server.

Testing Error Reporting

You will save a great deal of time if you leave error reporting enabled. Errors in PHP point you right to the error in your code. Create a simple PHP file, test.php, and define it as shown below.

print(“The next line generates an error.”);

printaline(“PLEASE?”);

print(“This will not be displayed due to the above error.”);
?>

The first print() statement should display its contents to the Web browser. However, the second statement generates and displays an error to the Web page. This results in the last print() statement do nothing, as shown in Figure 1

Figure 1 : Generating an Error

Crystal report tutorial – VS 2005

Nauman — Thu, 05 Nov 2009 09:20:48 +0000

A very good book on using Crystal reports in Visual Studio 2005. many small and minute things are discussed in this book.

VS2005 Walkthroughs Crystal Reports

Crystal Report Viewer width – Visual Studio

Nauman — Thu, 05 Nov 2009 07:43:17 +0000

By default Crystal report viewer width is fixed according to it toolbar, but changes due to amount of data present in the report. And the width is not editable (as it is seen). Because of this reason if a crystal report has good amount of data then it goes past page width and disturbs the UI of that webpage.

One method to overcome this problem is hidden in the Crystal Report viewer itself, Viewer has a property named: "Best Fit page". Its value is true by default, change this value to false and then set the width of the report. Now you can change the width of the report to anything.

One drawback/functionality of turning this feature off is the horizontal and vertical scroll bar appears. Now this thing is good or bad, it depends on report scenarios.

The maximum report processing jobs limit configured by your system administrator has been reached.

Nauman — Thu, 05 Nov 2009 07:42:11 +0000

call Close or Dispose method at the end so the reporting engine remove the report entry from its queue.

Opening hyperlink in a new window – Crystal Reports

Nauman — Thu, 05 Nov 2009 07:41:59 +0000

what to do when we want a hyperlink to open in a new window. This seems quite easy in any programming lanuage, but what to do when we want the same functionality in a crystal report.

It is almost the same as with webpages. create formula field for and at the end just add

"target=new;" e.g {report field} + "target = new;"

How to get open Windows in MFC

saim — Thu, 05 Nov 2009 07:41:45 +0000

Hi, i have very little experience in MFC and VC++. I was developing a small project, during development i need to view the list of all opened windows in my explorer. i read somewhere and like to post the solution of this only for you

It is very simple. here is the example by which you can display titles of each window opened. try this and enjoy.
In your OnInitDialog() write this…

HWND hnd = ::GetWindow(::GetDesktopWindow(), GW_CHILD);
CWnd *pWnd;
CString csTitle = "";

while( (hnd != NULL) )
{
pWnd = CWnd::FromHandle(hnd);
pWnd->GetWindowText(csTitle);

MessageBox(csTitle, "Title", NULL);
hnd = *pWnd->GetNextWindow(GW_HWNDNEXT);
}