What is an Artificial Neural Network (ANN)?

- The artificial neural network or ANN (sometimes also called as just neural network) is a mathematical model that has got its inspiration from the biological neural networks. 

- This network is supposed to consist of several artificial neurons that are interconnected. 

- This model works with a connectionist approach for computing and thus processes information based up on this only. 

- In a number of cases, the neural network can act as an adaptive system that has the ability of making changes in its structure while it is in some learning phase. 

- These networks are particularly used in searching patterns in data and for modeling the complex relationships that exist between the outputs and inputs. 

- An analogy to artificial neural network is the neuron network of the human brain. 

- In an ANN, the artificial nodes are termed as the neurons or sometimes as neurodes or units or the ‘processing elements’. 

- They are interconnected in such a way that they resemble a biological neural network. 

- Till now, no formal definition has been given for the artificial neural networks. - These processing elements or the neurons show a complex global behavior. 

- The connections between the neurons and their parameters is what that determines this behavior.

- There are certain algorithms that are designed for altering the strength of these connections in order to produce the desired flow of the signal. 

- The ANN operates up on these algorithms. 

- As in biological neural networks, in ANN also functions are performed in parallel and collectively by the processing units.

- Here, there is no delineation of the tasks that might be assigned to different units. 

- These neural networks are employed in various fields such as:

1. Statistics
2. Cognitive psychology
3. Artificial intelligence

- There are other neural network models that emulate biological CNS and are part of the following:

1. Computational neuroscience
2. Theoretical neuroscience

- The modern software implementation of the ANNs prefers a more practical approach than biologically inspired approach. 

- This practical approach is based up on the signal processing and statistics. The former approach has been largely abandoned. 

- Many times parts of these neural networks serve as components for the other larger systems that are a combination of non – adaptive and adaptive elements.

- Even though a more practical approach for solving the real world problems is the latter one, the former has more to do with the connectionist models of the traditional artificial intelligence. 

- Well the common thing between them is the principle of distributed, non – linear, local and parallel processing and adaptation. 

- A paradigm shift was marked by the use of neural networks during the late eighties. 

- This shift was from the high level artificial intelligence (expert systems) to low level machine learning (dynamical system). 

- These models are very simple and define functions such as:

f: X à Y

- Three types of parameters are used for defining an artificial neural network:

a)   The interconnection pattern between neuron layers

b)   The learning process

c)   The activation function

- The second parameter updates the weights of the connections and the third one converts the weighted input in to output. 

- Learning is the thing that has attracted many towards it. 

- There are 3 major learning paradigms that are offered by ANN:

1. Supervised learning
2. Un – supervised learning
3. Reinforcement learning

- Training a network requires selecting from a set of models that would best minimize the cost.

- A number of algorithms are available for training purpose where gradient descent is employed by most of the algorithms.

- Other methods available are simulated annealing, evolutionary methods and so on.

How do you check GUI objects? How do you check a bitmap? (In Winrunner)

In this article we discuss about how one can check the GUI objects and also how to check a bitmap. 

How to check GUI objects and Bitmap

- Checking of the GUI objects is possible by the addition of the GUI check points in the test scripts.

- Once these GUI check points have been introduced in to the test scripts, the behavior of the gui objects can be compared in different versions of the same software system or application and defects in them can also be detected. 

- For checking the GUI objects you just need to point the GUI objects that you want to examine and choose those properties which you want to be tested. 

- With Winrunner, you also have the option of checking the default properties as recommended by the winrunner itself or you can even go for the specific properties that you want to check. 

- Information regarding all the GUI objects and their corresponding properties is saved in the form of a check list. 

- The current property values are then captured by the winrunner for the GUI objects and are saved as the expected results. 

- While checking of the GUI objects, an automatic insertion of a GUI check point takes place. 

- The inserted check point appears as either of the following:

1. Win_check_gui statement or
2. Obj_check_gui statement

- A GUI check point consists of two parts one of which contains the check list listing all the objects and properties that are to be checked and the second part consists of the expected results which contains the captured property values.

- When a test is executed, the comparison of the current state of the GUI object with the expected results takes place in the software system or application that is being tested. 

- If in case, there is no matching between the current values and the expected results than that particular check point is said to have failed. 

- A GUI check point can be made a part of a loop also. 

- If you run a GUI check point in a loop then the results obtained are displayed as separate entries for every iteration of the loop. 

- All these results can be viewed in the test results window. 

- In some cases, it may also happen that the few of the GUI objects might not be there in the GUI map. 

- There is no need to worry since those GUI objects are added to a GUI map file that is temporary. 

- A GUI check point can be created either by using a regular expression on an edit object or by using a static text object having a varying name. 

- A built in support in winrunner is provided for the following:

1. Active X control
2. Visual basic
3. Power builder application development environments and so on.

- Whenever the appropriate add in support is loaded, the controls are recognized by the winrunner and are treated as standard GUI objects. 

- The GUI check points can be created for these GUI objects in a similar way the check points are created for the standard GUI objects. 

- GUI check points that could check the properties and contents of a table can also be created. 

However one should be careful about the point that the winrunner does not supports the GUI check points that were created in Xrunner. - Winrunner can be instructed to capture a bitmap of the window whenever some check point fails.

- These captured bitmaps are saved along with the test results in the test results folder whenever a test is run. 

- You can create check points either for testing single property of many objects or just for testing a single object. 

What are the two GUI Map modes available in WinRunner?

When the winrunner executes a test it actually simulates a real world human user by the means of carrying out user like interactions such as clicking GUI objects, moving cursor over the application and entering some input from the keyboard. 

- In order to work with an application, the winrunner needs to learn the graphical user interface of the application just as a human user would do. 

- This learning of the GUI is achieved by the winrunner by learning the GUI objects present in the application along with their properties. 

- The descriptions thus learnt are stored in the GUI map.

But before your winrunner starts learning about the GUI of your software system or application you must decide in what way you need to organize all your GUI map files. 

Winrunner offers two modes for organizing your GUI map files namely:

1. GUI map file per test mode
2. Global GUI map file mode

In this article we take up the talk regarding the gui map file per test mode and global gui map file mode in detail one by one. 

About Global GUI Map File Mode

- This is the default mode in winrunner. 

- This mode is quite advance from the second mode i.e., the GUI map file per test mode so it is recommended that this mode should be used by the much experienced testers. 

- Further, you must take care that you use this mode only when the tests have been created with winrunner versions 6.02 and earlier. 

- Organizing the tests in to groups while designing the test suites is perhaps the most efficient way of working with the winrunner. 

- Same GUI objects in the application should be tested by each test in the group. 

- The information regarding the GUI objects referred by those tests is stored in a common repository. 

- Whenever you have a change to be made in the object you just have to give an update of this in the GUI map as well as in the test scripts instead of making changes to each and every test. 

- It may happen in some cases that even after your winrunner has learned all about the GUI of your software system or application it may not show all the objects in its comprehensive list. 

- Therefore, it is important that the winrunner learns every about the GUI of your software system or application in a comprehensive way.

About GUI Map File per Test Mode

- This mode is especially for the ones who are new at using the winrunner since it is quite easy to be used as you do not need to know how actually the GUI map files are created, saved or loaded. 

- However, care should be taken that the tests created on winrunner versions 7.0 and above as they can only be handled using this mode.

- The plus point of this mode is that your time is saved since you don’t have to teach the winrunner regarding the GUI of your software system or application. 

- In this mode, every time you create a new test, the winrunner creates a new GUI map file.

- Similarly, whenever you save a test, the winrunner saves the test scripts.

- Whenever you open a test, the winrunner opens up the corresponding GUI map file. 

However there are some minus points also! 

- There are some features that do not work under this GUI map file per test mode.

1. The rapid test script wizard.
2. Option for reloading the temporary GUI map file.
3. Mytntt startup becomes unable to load the GUI map files.
4. Compiled modules become unable to load the GUI map files.

What are functions,variables and prototyping in C?

Variables or identifiers are the fundamental basic building blocks of a program. They are general terminology for objects, classes, functions, arrays etc. It can be defined as an arbitrarily long sequence of letters and digits and the first character must always be a letter. Upper and lower case letters are treated differently and all the characters are significant. C is implementation dependent. C is case sensitive as it treats lower and upper case letters differently. These are basically named storage, whose values can be manipulated during the execution of the program. There are 2 values associated with every variable namely r value and l value. The value of the variable is called r value whereas l value is the address in memory where the variable is located. Generally a variable is declared as :

type name;

A simple definition consists of a type specifier followed by a variable name. There are 2 types of variables: local variables and global variables. Local variables are declared inside a function and are available to that function only whereas global variable are declared outside main() and are available to all the functions.

A large program is difficult to manage and understand. Thus, it is broken down into different modules called functions which can be put together to form the complete program. So we can define a function as a sub program that acts on data and often returns a value. A good function contains a number of functions since it is easier to maintain update and debug. Each function has its own name. On the encounter of the function’s name in any part of the program the function is called. There are basically 2 types of functions namely built-in functions and user-defined functions. Built in functions are parts of the compiler package and are made available to the program by header files. For example: exit(), sqrt(), strlen(), size() etc. user defined functions are created by the programmer as per the requirements of the program. A function has 3 parts: function definition, function call and function prototype. In C a function must be defined before it is used anywhere. Generally a function is defined as:

type function-name(parameter list)
{
Body of the function
}

Here the type specifies the type of return value. The parameter list is the list of arguments passed to the function separated by commas. A function may be defined without any arguments or it can also have an open parameter. A function definition must have a return statement.

One of the most important features of C is function prototyping as it describes the function interface to the compiler. It can be defined as the declaration of the function that tells the program about the type of the value returned by the function and the number and type of arguments. Therefore, we can say that a prototype has following parts:
- Return type
- Name of the function
- Argument list

Function prototyping is essential as it allows a compiler to compare each use of the function with the prototype to determine whether the function has been invoked properly or not. This makes it easy for compiler to correct the errors. The function prototype and function definition must exactly agree on the function name, return type, and argument list. The prototype looks just like a function definition except that the code is missing. A prototype introduces a function to the program whereas a definition being a declaration also tells the program what the function is doing and how it is doing. C makes prototyping essential. We can skip the arguments in a prototype but not in the definition.

Naming Schemes of Distributed file systems

Large networks often use a systematic naming scheme, such as using a location (e.g. a department) plus a purpose to generate a name for a computer. However, smaller networks will frequently use a more personalized naming scheme to keep track of the many hosts. Network naming can be hierarchical in nature, such as the Internet's Domain Name System. Indeed, the Internet employs several universally applicable naming methods: Uniform Resource Names (URN), Uniform Resource Locators (URL), and Uniform Resource Identifiers (URI).
A good naming scheme is scalable, unique, and easy to remember. The purpose of these naming schemes is to name network computers, but it can also be used to name projects, variables, streets, pets, kids, or any other project where unique names and remember able names are required.

There are three main approaches to naming files:
 
- Files are named with a combination of host and local name.
* This guarantees a unique name.
* It is neither location transparent nor location independent.
* Same naming works on local and remote files.
- Remote directories are mounted to local directories.
* A local system seems to have a coherent directory structure.  
* The remote directories must be explicitly mounted. The files are location independent.
* SUN (Network File System)NFS is a good example of this technique.
- A single global name structure spans all the files in the system.
* The DFS is built in the same way as a local file system.
* It is location independent.