VIIKIPEDIA

THE MEGA NERD: AGILE - WHAT, WHERE, WHY (BASICS)

WORDS-N-EXPRESSIONS: IPHONE APPS BUSINESS: AN INSIGHT FOR DUMMIES

Difference Between SMTP and POP

POWERVOCAB- 8 REASONS TO USE THIS VOCABULARY BUILDING IPHONE APP

OFFERING TECHNICAL SERVICES TO HELP THE UNDER PRIVILEGE CHILDREN

VOCABULARY BUILDING APP LIVE ON APPLE STORE

COOL APP FOR VOCABULARY BUILDING

Rework Effort Ratio

Requirements Stability Index and Requirements Creep

Effort Variance, Schedule Variance, Schedule Slippage

DEFECT DENSITY

QA EFFECTIVENESS OR TEST EFFECTIVENESS

DEFECT REMOVAL EFFICIENCY(DRE)

IS 100% TEST CASE COVERAGE ENOUGH??

REVIEW EFFECTIVENESS

METRICS

ARTICLE ON IPHONE APPLICATIONS

CMMI

CRONJOB-CRONTAB

fork()

fork()

SHARED MEMORY IN UNIX

Script make backup of all file names

How to add two floating point numbers ?

How would you get the character positions 10-20 from a text file?

How to: UNIX List just directories or directory names

IF IN SHELL SCRIPT

SHELL COMPARISONS, CONDITIONS, CHECKS

FEW LINUX COMMANDS RELATED TO PROCESS

HOW TO READ LINES OF DATA IN A SHELL SCRIPT?

Shell Built in Variables

SQL JOINS

DDL, DML & DCL

What are the difference between DDL, DML and DCL commands?

ENTRY & EXIT CRITERIA FOR TESTING

FOREIGN KEY

Quality Center

QTP TEST FRAMEWORKS

Referential CONSTRAINT

DATABASE- Hierarchical Model & Relational Model

INHERITANCE REVISITED

TYPE CASTING C/C++

Type Casting

BUBBLE SORT

Pipes and FIFOs

Mutex vs. Semaphore, what is the difference?

Mutex vs. Semaphore, what is the difference?

GOOD EXAMPLE OF CALL BY REFERENCE VS CALL BY VALUE

FURPS

Difference between Router and Switch

Codd's Rules for Relational Database Design

CANDIDATE KEY, PRIMARY KEY, UNIQUE KEY, ALTERNATE KEY, COMPOSITE KEY

THE XOR OPERATION

C++ Static Functions

INLINE FUNCTIONS VS MACROS

CHGRP & CHOWN

SCRUM

Explicit Constructors

Stack unwinding?

What is a dangling pointer?

delete operator C++

VIIKIPEDIA

THE MEGA NERD: AGILE - WHAT, WHERE, WHY (BASICS)

WORDS-N-EXPRESSIONS: IPHONE APPS BUSINESS: AN INSIGHT FOR DUMMIES

Difference Between SMTP and POP

POWERVOCAB- 8 REASONS TO USE THIS VOCABULARY BUILDING IPHONE APP

OFFERING TECHNICAL SERVICES TO HELP THE UNDER PRIVILEGE CHILDREN

VOCABULARY BUILDING APP LIVE ON APPLE STORE

COOL APP FOR VOCABULARY BUILDING

Rework Effort Ratio

Requirements Stability Index and Requirements Creep

Effort Variance, Schedule Variance, Schedule Slippage

DEFECT DENSITY

QA EFFECTIVENESS OR TEST EFFECTIVENESS

DEFECT REMOVAL EFFICIENCY(DRE)

IS 100% TEST CASE COVERAGE ENOUGH??

REVIEW EFFECTIVENESS

METRICS

ARTICLE ON IPHONE APPLICATIONS

CMMI

CRONJOB-CRONTAB

fork()

fork()

SHARED MEMORY IN UNIX

Script make backup of all file names

How to add two floating point numbers ?

How would you get the character positions 10-20 from a text file?

How to: UNIX List just directories or directory names

IF IN SHELL SCRIPT

SHELL COMPARISONS, CONDITIONS, CHECKS

FEW LINUX COMMANDS RELATED TO PROCESS

HOW TO READ LINES OF DATA IN A SHELL SCRIPT?

Shell Built in Variables

SQL JOINS

DDL, DML & DCL

What are the difference between DDL, DML and DCL commands?

ENTRY & EXIT CRITERIA FOR TESTING

FOREIGN KEY

Quality Center

QTP TEST FRAMEWORKS

Referential CONSTRAINT

DATABASE- Hierarchical Model & Relational Model

INHERITANCE REVISITED

TYPE CASTING C/C++

Type Casting

BUBBLE SORT

Defect Density Uses

Display or list all directories

You have current dir containing set of directories which contain files.
One file can reside in many directories.
Write script which returns number of unique file names in
all the subdirectories of a current dir.

Display or list only files

Different SQL JOINs

SQL LEFT JOIN Keyword

SQL RIGHT JOIN Keyword

SQL FULL JOIN Keyword

Modules

Hierarchical Model

Relational Model

Pipes and FIFOs

Change Group Ownership with chgrp

Change User Ownership

Explicit Constructors

Defect Density Uses

Display or list all directories

You have current dir containing set of directories which contain files.One file can reside in many directories.Write script which returns number of unique file names inall the subdirectories of a current dir.

Display or list only files

Different SQL JOINs

SQL LEFT JOIN Keyword

SQL RIGHT JOIN Keyword

SQL FULL JOIN Keyword

Modules

Hierarchical Model

Relational Model

You have current dir containing set of directories which contain files.
One file can reside in many directories.
Write script which returns number of unique file names in
all the subdirectories of a current dir.

Metrics_spv

SQL INNER JOIN Syntax

SQL LEFT JOIN Syntax

SQL RIGHT JOIN Syntax

SQL FULL JOIN Syntax

DDL

DML

DCL

TCL

Releases

Requirements

Test Plan

Test Lab

Defects

Reports

Constraints on the database that require relations to satisfy certain properties. Relations that satisfy all such constraints are legal relations.

Defining referential constraints

Implicit conversion

Explicit conversion

dynamic_cast

static_cast

reinterpret_cast

const_cast

typeid

Metrics_spv

SQL INNER JOIN Syntax

SQL LEFT JOIN Syntax

SQL RIGHT JOIN Syntax

SQL FULL JOIN Syntax

DDL

DML

DCL

TCL

Releases

Requirements

Test Plan

Test Lab

Defects

Reports

Constraints on the database that require relations to satisfy certain properties. Relations that satisfy all such constraints are legal relations.

Defining referential constraints

Implicit conversion

Explicit conversion

dynamic_cast

static_cast

reinterpret_cast

const_cast

typeid

Accessing Static Function:

2011-09-10T11:25:00.000-07:00

THE MEGA NERD: AGILE - WHAT, WHERE, WHY (BASICS): What Is Agile? Agile methodology is an approach to project management used in software development. It helps teams respond to the unpred...

2011-05-18T07:47:00.000-07:00

WORDS-N-EXPRESSIONS: IPHONE APPS BUSINESS: AN INSIGHT FOR DUMMIES: "With the popularity of iPhone (for that matter Apple’s all other products such as iPad and iPod Touch) in the global market, the iPhone ..."

2011-04-14T07:40:00.000-07:00

There are two standards currently used for most e-mail sent today. SMTP stands for simple mail transfer protocol. POP is an acronym Post Office Protocol. Though it may sound confusing, the difference is not hard to understand. POP is a protocol for storage of email. SMTP is a protocol for sending and receiving.

To give a real-world illustration, SMTP would be like a letter carrier or mailman. He or she can deliver or pick up mail for transfer to another location. POP is like a mailbox or Post Office Box. It is the location the mail is delivered to and where it stays until the recipient is ready to read it. Outgoing mail can also be put in the mailbox.

POP was first designed in 1984 with the idea of allowing users to access an e-mail server, retrieve messages to a local folder located on the computer, and then go offline for reading and writing replies. In part, the offline capabilities were developed at a time when logging on to the Internet was relatively expensive and users were charged per minute. Currently, most of those using the POP standard are using the third version, developed in 1988. This is often referred to as POP3.

2011-01-26T05:01:00.000-08:00

Today when I’m writing this post I’m really captivated for the developers (Faqden Labs) of this sensational vocabulary building Iphone app- “PowerVocab”. Yes, I did the pre-launch review for this wonderful vocabulary building Iphone app, and I’m glad that it has got no less response from the people across the globe than what was my enthusiasm at the time of writing the pre-launch review for the PowerVocab. If you are still thinking what I’m talking about you need to check this and this.

Ok, if you are thinking why I’m scripting so boastfully about this just another vocabulary building Iphone application then here are my 8 reasons for using the PowerVocab-

1. It’s a free downloadable vocabulary building Iphone app on the Apple Itunes store.

2. PowerVocab for Iphone was downloaded 233 times in 4 days of its launch.

3. It is 5/5-star rated Iphone app on Apple itunes.

4. It is among the top rated Iphone app in Education category on Apple Iphone apps store.

5. It’s a brain child of the highly proficient thinking minds of engineers from MIT and Cornell.

6. The analytics to track the learning curves of its users has been described phenomenal.

7. PowerVocab has been highly appreciated by the students preparing for GRE/SAT/CAT/GMAT vocabulary.

8. The developers of PowerVocab- Faqden Labs are soon launching PowerVocab Pro for Iphone with enhanced features and PowerVocab for Android.

I reckon PowerVocab to be the smartest app for learning vocab. So, go and download PowerVocab Lite for free on Apple itunes now.

FAQDEN LABS- http://www.faqden.com/index.html
Read more about it- http://paragonist.blogspot.com/2011/01/powervocab-8-reasons-to-use-this.html

2011-01-22T21:34:00.000-08:00

For long I’m trying to do my best to help the under privilege children here in India, but there are so many things that can be done and yet we shy away from them. So, I’ve decided to come out of the shell and to help the poor children in whatever possible way I can. I did a bit of thinking and finally I’ve come up with an idea.

MY IDEA:
Since, I’m a Software Engineer I’ve decided to use my skills in that area to help the poor. I will be offering following services to the customers on a nominal price-

Testing the web-applications.
Writing testing articles.
Writing other technical articles like product reviews, research articles etc.
Testing mobile applications.
Doing website reviews.
Website/application usability review and feedbacks.
Feedback/reviews about the blog templates.
Advertising and promoting firms/products on my blog.
Providing technical resources like e-books, webcasts, links etc related to Software Testing, SQL, RDBMS, C++, Unix.

All the money made by providing above services to various customers will be used to help the poor and the under privileged children in India. Once I get the money, I’ll be posting pictures and videos on my blogs showcasing the money has been spent in the correct way for the needy.

HOW YOU CAN HELP:

I know every one of you want to see a beautiful world out there, and everyone wants to do its bit to make the world better. So, it’s quite simple to be part of this phenomenon either you avail my services or you help me spread the word. See if you want any of the above services or just see how you can get me clients.

It’s just the beginning and I’m sure there will be several others who will be soon joining me. I truly believe there will be several others who will figure out their own ways to help the under privilege children.

LET’S NOT JUST HOPE IT TO WORK, RATHER LET’S MAKE IT WORK!!

Check out my other blog- http://paragonist.blogspot.com/

2011-01-19T11:02:00.001-08:00

CHECK OUT THIS LINK TO KNOW MORE:

http://paragonist.blogspot.com/2011/01/powervocab-is-live-on-apple-store.html

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

I'm always on the lookout for the great mobile apps. I found this simple and useful vocabulary building app- PowerVocab for iPhones/Androids/iPad/BlackBerry by Faqden. This app could be really useful not only to all the GMAT/GRE/SAT takers but also to all others who are striving hard to improve their vocabulary especially from a non-English speaking countries.

To know more about the PowerVocab click the photo-

Which are some of your favorites?

P.S. I got the advance copy of the app from the developers for review and it will be soon launched. So, watch out for its release in few days :)

2010-12-04T11:47:00.000-08:00

Rework Effort Ratio
(Actual rework effort spent in that particular phase / Total actual efforts spent in that phase) * 100

2010-12-04T11:43:00.000-08:00

Requirements Stability Index:
{1 - (Total number of changes /number of initial requirements)}

the GOAL should be to have the Index value as 1 ideally.

Requirements Creep:
(Total Number of requirements added/Number of initial requirements) * 100

Ideally, the Requirements Creep should be Zero.

2010-12-04T11:30:00.001-08:00

Effort Variance:
Effort Variance can be calculated as {(Actual Efforts-Estimated Efforts) / Estimated Efforts} *100.

Schedule Variance:
Just like above formula it is similarly calculated as.
{(Actual Duration - Estimated Duration)/Estimated Duration} *100

Schedule Slippage:
When a task has been delayed from its original baseline schedule then the amount of time that it has taken is defined as schedule slippage. Its calculation is as simple as.
(Actual End date - Estimated End date) / (Planned End Date – Planned Start Date) * 100

The GOAL should be to have all of them as ZERO.

2010-12-04T11:28:00.000-08:00

Defect Density is the number of confirmed defects detected in software/component during a defined period of development/operation divided by the size of the software/component.

The 'defects' are:

confirmed and agreed upon (not just reported).
Dropped defects are not counted.

The ‘period’ might be for one of the following:

for a duration (say, the first month, the quarter, or the year).
for each phase of the software life cycle.
for the whole of the software life cycle.

The ‘size’ is measured in one of the following:

Function Points (FP)
Source Lines of Code

DEFECT DENSITY = NUMBER of DEFECTS
---------------------------
SIZE

For comparing the relative number of defects in various software components so that high-risk components can be identified and resources focused towards them
For comparing software/products so that ‘quality’ of each software/product can be quantified and resources focused towards those with low quality.

2010-12-04T11:13:00.000-08:00

QA EFFECTIVENESS OR TEST EFFECTIVENESS =

Total number of internal defects X 100
-----------------------------------------------
Total number of defects( i.e. Internal + External)

4 = Internal Defects raised by QA
6= External defects used by User or customer

QA effectiveness = 4/(4+6) x 100 = 40%

Goal should be to have QA effectiveness as 100%.

2010-12-04T10:52:00.000-08:00

DRE is a measure to detect defects before delivery. It is calculated as a percentage of the defects identified and corrected internally with respect to the total defects found in the complete project life cycle. Thus, DRE is the percentage of bugs eliminated by reviews, inspections, tests etc.

Our prime Goal: D.R.E. = 1.0 (100%)

For e.g.
(E1)Errors Found Before Delivery / Within Activity = 5
(E2) Errors Found After Delivery / After Activity* = 4

DRE = 5/(4+5) x100= 55%

2010-12-04T10:31:00.000-08:00

The term Test Case Coverage means a measure of how many of the product requirements are being tested by the defined test cases. It is the testers’ job to define their test cases based on the requirements and the goal should be 100% coverage or close to that. Please bear in mind that 100% coverage is not the same as exhaustive testing. Exhaustive testing means testing every path through the software using all possible values. So, its very clear that even though the coverage is 100% i.e. all the requirements are covered yet there will be several other test cases that needed to be tested.

2010-12-04T10:26:00.000-08:00

Review Effectiveness is a bit harder to define it. But let me try and explain what I discovered from reading various articles over the internet.

When you hold a review, say for the SRS, then you would have a total number of defects discovered and you also know the number of pages in the document. So, to first order, you could divide the total number of defects by the number of pages and derive a defect density measure for the document. But that number by itself doesn’t tell you a whole lot. You need to have a good understanding of the expected number of defects per page coming out of a review. That number would come from your historical data. But this number still doesn’t yield an effectiveness measure. You could be finding lots of minor defects in a review and the major ones are slipping through. So you have to look for defects that were missed by the review in downstream activities such as testing and other reviews.

So, basically its really important to know two things- 1. Review Defects and 2. Testing defects.
Hence, Review Effectiveness will be =

Total Number of Review Defects X 100
-----------------------------------------------------------------------------
Total Defects (which includes Review defects + Testing Defects)

For e.g. there are 4 Review Defects and 5 Testing Defects.
Hence Review Effectiveness = 4/(4+5) x 100= 44%

2010-12-04T04:18:00.001-08:00

See more presentations by santhoshpv.05 | Upload your own PowerPoint presentations

2010-08-28T21:26:00.000-07:00

An interesting article about the IPHONE APPLICATIONS(APPS.). Do read it here-
http://paragonist.blogspot.com/2010/08/no-halts-pleaseiphone-apps.html

2010-07-07T14:39:00.000-07:00

reference:wiki

2010-06-17T10:45:00.000-07:00

Setting up cron jobs in Unix and Solaris

cron is a unix, solaris utility that allows tasks to be automatically run in the background at regular intervals by the cron daemon. These tasks are often termed as cron jobs in unix , solaris. Crontab (CRON TABle) is a file which contains the schedule of cron entries to be run and at specified times.

1. Crontab Restrictions
You can execute crontab if your name appears in the file /usr/lib/cron/cron.allow. If that file does not exist, you can use
crontab if your name does not appear in the file /usr/lib/cron/cron.deny.
If only cron.deny exists and is empty, all users can use crontab. If neither file exists, only the root user can use crontab. The allow/deny files consist of one user name per line.

2. Crontab Commands

export EDITOR=vi ;to specify a editor to open crontab file.

crontab -e    Edit your crontab file, or create one if it doesn’t already exist.
crontab -l      Display your crontab file.
crontab -r      Remove your crontab file.
crontab -v      Display the last time you edited your crontab file. (This option is only available on a few systems.)

3. Crontab file
Crontab syntax :
A crontab file has five fields for specifying day , date and time followed by the command to be run at that interval.

*     *     *   *    *        command to be executed
-     -     -   -    -
|     |     |   |    |
|     |     |   |    +----- day of week (0 - 6) (Sunday=0)
|     |     |   +------- month (1 - 12)
|     |     +--------- day of        month (1 - 31)
|     +----------- hour (0 - 23)
+------------- min (0 - 59)

* in the value field above means all legal values as in braces for that column.
The value column can have a * or a list of elements separated by commas. An element is either a number in the ranges shown above or two numbers in the range separated by a hyphen (meaning an inclusive range).
Notes
A. ) Repeat pattern like /2 for every 2 minutes or /10 for every 10 minutes is not supported by all operating systems. If you try to use it and crontab complains it is probably not supported.

B.) The specification of days can be made in two fields: month day and weekday. If both are specified in an entry, they are cumulative meaning both of the entries will get executed .

4. Crontab Example
A line in crontab file like below removes the tmp files from /home/someuser/tmp each day at 6:30 PM.

30 18 * * * rm /home/someuser/tmp/*

5. Crontab Environment
cron invokes the command from the user’s HOME directory with the shell, (/usr/bin/sh).
cron supplies a default environment for every shell, defining:
HOME=user’s-home-directory
LOGNAME=user’s-login-id
PATH=/usr/bin:/usr/sbin:.
SHELL=/usr/bin/sh

Users who desire to have their .profile executed must explicitly do so in the crontab entry or in a script called by the entry.

6. Disable Email
By default cron jobs sends a email to the user account executing the cronjob. If this is not needed put the following command At the end of the cron job line .

>/dev/null 2>&1

7. Generate log file
To collect the cron execution execution log in a file :

30 18 * * * rm /home/someuser/tmp/* > /home/someuser/cronlogs/clean_tmp_dir.log

reference: adminschoice.com

2010-06-17T10:01:00.001-07:00

int fork() turns a single process into 2 identical processes, known as the parent and the child. On success, fork() returns 0 to the child process and returns the process ID of the child process to the parent process. On failure, fork() returns -1 to the parent process, sets errno to indicate the error, and no child process is created.

NOTE: The child process will have its own unique PID.

NOTE: The processes have unique ID's which will be different at each run. 

It also impossible to tell in advance which process will get to CPU's time -- so one run may differ from the next. 

When we spawn 2 processes we can easily detect (in each process) whether it is the child or parent since fork returns 0 to the child. We can trap any errors if fork returns a -1. i.e.: 

int pid; /* process identifier */ pid = fork(); if ( pid < 0 ) { printf(``Cannot fork!!n''); exit(1); } if ( pid == 0 ) { /* Child process */ ...... } else { /* Parent process pid is child's pid */ .... }

2010-06-17T09:48:00.000-07:00

In fork() system call, we mentioned that a parent and its children have separate address spaces. While this would provide a more secured way of executing parent and children processes (because they will not interfere each other), they shared nothing and have no way to communicate with each other. A shared memory is an extra piece of memory that is attached to some address spaces for their owners to use. As a result, all of these processes share the same memory segment and have access to it.

Shared memory is a feature supported by UNIX System V, including Linux, SunOS and Solaris. One process must explicitly ask for an area, using a key, to be shared by other processes. This process will be called the server. All other processes, the clients, that know the shared area can access it. However, there is no protection to a shared memory and any process that knows it can access it freely. To protect a shared memory from being accessed at the same time by several processes, a synchronization protocol must be setup.

For a server, it should be started before any client. The server should perform the following tasks:
1. Ask for a shared memory with a memory key and memorize the returned shared memory ID. This is performed by system call shmget().
2. Attach this shared memory to the server's address space with system call shmat().
3. Initialize the shared memory, if necessary.
4. Do something and wait for all clients' completion.
5. Detach the shared memory with system call shmdt().
6. Controlling the shared memory using shmctl(), read below for complete description.
For the client part, the procedure is almost the same:

Ask for a shared memory with the same memory key and memorize the returned shared memory ID.
Attach this shared memory to the client's address space.
Use the memory.
Detach all shared memory segments, if necessary.
Exit.

shmctl() is used to alter the permissions and other characteristics of a shared memory segment. It is prototyped as follows:

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

The process must have an effective shmid of owner, creator or superuser to perform this command. The cmd argument is one of following control commands:

SHM_LOCK: -- Lock the specified shared memory segment in memory. The process must have the effective ID of superuser to perform this command.
SHM_UNLOCK: -- Unlock the shared memory segment. The process must have the effective ID of superuser to perform this command.
IPC_STAT: -- Return the status information contained in the control structure and place it in the buffer pointed to by buf. The process must have read permission on the segment to perform this command.
IPC_SET: -- Set the effective user and group identification and access permissions. The process must have an effective ID of owner, creator or superuser to perform this command.
IPC_RMID: -- Remove the shared memory segment.

2010-06-11T12:32:00.001-07:00

#!/bin/bash
FILES="$@"
for f in $FILES
do
        # if .bak backup file exists, read next file
 if [ -f ${f}.bak ]
 then
  echo "Skiping $f file..."
  continue  # read next file and skip cp command
 fi
        # we are hear means no backup file exists, just use cp command to copy file
 /bin/cp $f $f.bak
done

2010-06-11T10:48:00.000-07:00

You can make you og 'bc' command to do the arithmatic operations in shell script.
Following script illustrates a sample implimentation

a 1.2
b 3.1
x=(echo $a +$b|bc)
echo $x

2010-06-11T10:32:00.000-07:00

cat filename.txt | cut -c 10-20

:)

If you have a string "one two three", Which shell command would you extract the strings?

Input="one two three"
for var in $Input
do
   i=0;
   var.$i=$var
   i=$i+1
done
echo $i
for ( i=0; i< $i; i++)
do
   echo `var.$i`
done

Its a little big solution but thats just a way of playing with script ;)

2010-06-11T10:17:00.000-07:00

Type the following command:
$ ls -l | grep `^d'

ls -R | grep -v "^d" | sort -u

Type the following command:
$ ls -l | grep -v `^d'

2010-06-08T13:01:00.000-07:00

$ cat > elf
#
#!/bin/sh
# Script to test if..elif...else
#
if [ $1 -gt 0 ]; then
  echo "$1 is positive"
elif [ $1 -lt 0 ]
then
  echo "$1 is negative"
elif [ $1 -eq 0 ]
then
  echo "$1 is zero"
else
  echo "Opps! $1 is not number, give number"
fi

Try above script as follows:
$ chmod 755 elf
$ ./elf 1
$ ./elf -2
$ ./elf 0
$ ./elf aHere o/p for last sample run:
./elf: [: -gt: unary operator expected
./elf: [: -lt: unary operator expected
./elf: [: -eq: unary operator expected
Opps! a is not number, give number
Above program gives error for last run, here integer comparison is expected therefore error like "./elf: [: -gt: unary operator expected" occurs, but still our program notify this error to user by providing message "Opps! a is not number, give number".

2010-06-08T12:49:00.000-07:00

For Mathematics, use following operator in Shell Script

Mathematical Operator in Shell Script	Meaning	Normal Arithmetical/ Mathematical Statements	But in Shell
			For test statement with if command	For [ expr ] statement with if command
-eq	is equal to	5 == 6	if test 5 -eq 6	if [ 5 -eq 6 ]
-ne	is not equal to	5 != 6	if test 5 -ne 6	if [ 5 -ne 6 ]
-lt	is less than	5 < 6	if test 5 -lt 6	if [ 5 -lt 6 ]
-le	is less than or equal to	5 <= 6	if test 5 -le 6	if [ 5 -le 6 ]
-gt	is greater than	5 > 6	if test 5 -gt 6	if [ 5 -gt 6 ]
-ge	is greater than or equal to	5 >= 6	if test 5 -ge 6	if [ 5 -ge 6 ]

NOTE: == is equal, != is not equal.

For string Comparisons use

Operator	Meaning
string1 = string2	string1 is equal to string2
string1 != string2	string1 is NOT equal to string2
string1	string1 is NOT NULL or not defined
-n string1	string1 is NOT NULL and does exist
-z string1	string1 is NULL and does exist

Shell also test for file and directory types

Test	Meaning
-s file	Non empty file
-f file	Is File exist or normal file and not a directory
-d dir	Is Directory exist and not a file
-w file	Is writeable file
-r file	Is read-only file
-x file	Is file is executable

Logical Operators

Logical operators are used to combine two or more condition at a time

Operator	Meaning
! expression	Logical NOT
expression1 -a expression2	Logical AND
expression1 -o expression2	Logical OR

2010-06-08T12:34:00.001-07:00

For this purpose	Use this Command	Examples*
To see currently running process	ps	$ ps
To stop any process by PID i.e. to kill process	kill {PID}	$ kill 1012
To stop processes by name i.e. to kill process	killall {Process-name}	$ killall httpd
To get information about all running process	ps -ag	$ ps -ag
To stop all process except your shell	kill 0	$ kill 0
For background processing (With &, use to put particular command and program in background)	linux-command &	$ ls / -R \| wc -l &
To display the owner of the processes along with the processes	ps aux	$ ps aux
To see if a particular process is running or not. For this purpose you have to use ps command in combination with the grep command	ps ax \| grep process-U-want-to see	For e.g. you want to see whether Apache web server process is running or not then give command$ ps ax \| grep httpd
To see currently running processes and other information like memory and CPU usage with real time updates.	top See the output of top command.	$ top Note that to exit from top command press q.
To display a tree of processes	pstree	$ pstree

* To run some of this command you need to be root or equivalnt user.

2010-06-08T11:13:00.000-07:00

There's a very easy way to solve this:

while read myline
do
echo $myline
done < inputfile

If the fields in a given line are separated by a known delimiter, either a tab or a comma, for example, then I suggest that you could use the cut command to extract specific values.

To demonstrate, let's pull some useful data out of the /etc/passwd file, a file that has lines of data in known fields, separated with a ":" as the deilmiter. Here's a typical line of data-

unknown:*:99:99:Unknown User:/var/empty:/usr/bin/false

The first field (remember, they're separated by colons) is the account name, the second the encrypted password (not shown because it's in a separate 'shadow' file for security), then the remaining fields are account ID, group ID, full user name, home directory and login shell.
Let's just pull out login and full name to see what that looks like:

#!/bin/sh

while read inputline
do
login=`(echo $inputline | cut -d: -f1)`
fulln=`(echo $inputline | cut -d: -f5)`
echo login = $login and fullname = $fulln
done < /etc/passwd

exit 0

You can see how the cut program makes this a straightforward task, albeit one that can be done more quickly in other scripting languages like Perl. But if you want to work with shell scripts, the combination of a while read loop with the input redirected and the great cutcommand should give you all the data parsing capabilities you need.

2010-06-08T11:03:00.000-07:00

Shell Built in Variables	Meaning
$#	Number of command line arguments. Useful to test no. of command line args in shell script.
$*	All arguments to shell
$@	Same as above
$-	Option supplied to shell
$$	PID of shell
$!	PID of last started background process (started with &)

$? - (1) If return value is zero (0), command is successful.
(2) If return value is nonzero, command is not successful or some sort of error executing command/shell script.
This value is know as Exit Status.

2010-06-07T10:36:00.000-07:00

SQL joins are used to query data from two or more tables, based on a relationship between certain columns in these tables.

JOIN(inner): Return rows when there is at least one match in both tables
LEFT JOIN: Return all rows from the left table, even if there are no matches in the right table
RIGHT JOIN: Return all rows from the right table, even if there are no matches in the left table
FULL JOIN: Return rows when there is a match in one of the tables

SELECT column_name(s)
FROM table_name1
INNER JOIN table_name2
ON table_name1.column_name=table_name2.column_name

PS: INNER JOIN is the same as JOIN.

The INNER JOIN keyword return rows when there is at least one match in both tables. If there are rows in "Persons" that do not have matches in "Orders", those rows will NOT be listed.

The LEFT JOIN keyword returns all rows from the left table (table_name1), even if there are no matches in the right table (table_name2).

SELECT column_name(s)
FROM table_name1
LEFT JOIN table_name2
ON table_name1.column_name=table_name2.column_name

PS: In some databases LEFT JOIN is called LEFT OUTER JOIN.

The RIGHT JOIN keyword Return all rows from the right table (table_name2), even if there are no matches in the left table (table_name1).

SELECT column_name(s)
FROM table_name1
RIGHT JOIN table_name2
ON table_name1.column_name=table_name2.column_name

PS: In some databases RIGHT JOIN is called RIGHT OUTER JOIN.

The FULL JOIN keyword return rows when there is a match in one of the tables.

SELECT column_name(s)
FROM table_name1
FULL JOIN table_name2
ON table_name1.column_name=table_name2.column_name

The FULL JOIN keyword returns all the rows from the left table (Persons), and all the rows from the right table (Orders). If there are rows in "Persons" that do not have matches in "Orders", or if there are rows in "Orders" that do not have matches in "Persons", those rows will be listed as well.

2010-06-04T13:58:00.000-07:00

Data Definition Language (DDL) statements are used to define the database structure or schema. Some examples:

CREATE - to create objects in the database
ALTER - alters the structure of the database
DROP - delete objects from the database
TRUNCATE - remove all records from a table, including all spaces allocated for the records are removed
COMMENT - add comments to the data dictionary
RENAME - rename an object

Data Manipulation Language (DML) statements are used for managing data within schema objects. Some examples:

SELECT - retrieve data from the a database
INSERT - insert data into a table
UPDATE - updates existing data within a table
DELETE - deletes all records from a table, the space for the records remain
MERGE - UPSERT operation (insert or update)
CALL - call a PL/SQL or Java subprogram
EXPLAIN PLAN - explain access path to data
LOCK TABLE - control concurrency

Data Control Language (DCL) statements. Some examples:

GRANT - gives user's access privileges to database
REVOKE - withdraw access privileges given with the GRANT command

Transaction Control (TCL) statements are used to manage the changes made by DML statements. It allows statements to be grouped together into logical transactions.

COMMIT - save work done
SAVEPOINT - identify a point in a transaction to which you can later roll back
ROLLBACK - restore database to original since the last COMMIT
SET TRANSACTION - Change transaction options like isolation level and what rollback segment to use

2010-06-04T13:50:00.000-07:00

As the name implies Entry criteria denotes the conditions or process that must be present before a process can begin. For example Test Plan, Test Strategy, Test tools are some of the Entry criteria for carrying out the testing process. Exit criteria as the name implies denotes the conditions or process that must be present before a cycle completes. Test results or Test Summary Report, Test Logs are some of the Exit criteria out of the testing process.

The Entrance Criteria specified by the system test controller, should be fulfilled before System Test can commence. In the event, that any criterion has not been achieved, the System Test may commence if Business Team and Test Controller are in full agreement that the risk is manageable.

* All developed code must be unit tested. Unit and Link Testing must be completed and signed off by development team.
* System Test plans must be signed off by Business Analyst and Test Controller.
* All human resources must be assigned and in place.
* All test hardware and environments must be in place, and free for System test use.
* The Acceptance Tests must be completed, with a pass rate of not less than 80%.

The Exit Criteria detailed below must be achieved before the Phase 1 software can be recommended for promotion to Operations Acceptance status. Furthermore, I recommend that there be a minimum 2 days effort Final Integration testing AFTER the final fix/change has been retested.

* All High Priority errors from System Test must be fixed and tested
* If any medium or low-priority errors are outstanding - the implementation risk must be signed off as acceptable by Business Analyst
* Project Integration Test must be signed off by Test Controller and Business Analyst.
* Business Acceptance Test must be signed off by Business Expert.

2010-06-04T13:19:00.000-07:00

A foreign key is a field (or fields) that points to the primary key of another table. The purpose of the foreign key is to ensure referential integrity of the data. In other words, only values that are supposed to appear in the database are permitted.

For example, say we have two tables, a CUSTOMER table that includes all customer data, and an ORDERS table that includes all customer orders. The constraint here is that all orders must be associated with a customer that is already in the CUSTOMER table. In this case, we will place a foreign key on the ORDERS table and have it relate to the primary key of the CUSTOMER table. This way, we can ensure that all orders in the ORDERS table are related to a customer in the CUSTOMER table. In other words, the ORDERS table cannot contain information on a customer that is not in the CUSTOMER table.

The structure of these two tables will be as follows:

Table CUSTOMER

column name	characteristic
SID	Primary Key
Last_Name
First_Name

Table ORDERS

column name	characteristic
Order_ID	Primary Key
Order_Date
Customer_SID	Foreign Key
Amount

In the above example, the Customer_SID column in the ORDERS table is a foreign key pointing to the SID column in the CUSTOMER table.

Below we show examples of how to specify the foreign key when creating the ORDERS table:

MySQL:
CREATE TABLE ORDERS
(Order_ID integer,
Order_Date date,
Customer_SID integer,
Amount double,
Primary Key (Order_ID),
Foreign Key (Customer_SID) references CUSTOMER(SID));

Oracle:
CREATE TABLE ORDERS
(Order_ID integer primary key,
Order_Date date,
Customer_SID integer references CUSTOMER(SID),
Amount double);

SQL Server:
CREATE TABLE ORDERS
(Order_ID integer primary key,
Order_Date datetime,
Customer_SID integer references CUSTOMER(SID),
Amount double);

Below are examples for specifying a foreign key by altering a table. This assumes that the ORDERS table has been created, and the foreign key has not yet been put in:

MySQL:
ALTER TABLE ORDERS
ADD FOREIGN KEY (customer_sid) REFERENCES CUSTOMER(SID);

Oracle:
ALTER TABLE ORDERS
ADD (CONSTRAINT fk_orders1) FOREIGN KEY (customer_sid) REFERENCES CUSTOMER(SID);

SQL Server:
ALTER TABLE ORDERS
ADD FOREIGN KEY (customer_sid) REFERENCES CUSTOMER(SID);

2010-06-04T12:51:00.000-07:00

HP Quality Center (QC) (formerly HP TestDirector for Quality Center) is a web-based test management tool by Mercury Interactive (now HP). It is based on client server technology and has five main modules/tabs: Releases, Requirements, Test Plan, Test Lab and Defects for management of testing processes. There can be additional modules as well, depending on the various add-ins installed, e.g., BPT (Business Process Testing).

This module helps to manage releases and cycles (iterations). User can plan and track application release progress using this module

This module is used for Requirement Management and Requirements Traceability of various Test cases stored in the QC Repository

This plan is used for creating or updating different Test Cases. The Test Cases are contained in different folders, which are displayed in a tree-like structure. It can store both Manual and Automated test cases. Manual Test Cases can be written locally or imported from Microsoft Excel spreadsheets, with each 'Test Step' having Expected Result and ActualResult sections. QC supports automated scripts developed for different Automation Tools such as QTP, LoadRunner, and WinRunner. These scripts can be saved directly from the Tool into the Test Plan tab of QC. However, prior to this, the appropriate QC add-in needs to be installed to support an Automation Tool.

This tab is for execution of the test cases stored in the Test Plan module, which can be imported locally to the Test Lab screen and run. When a Manual Test case is executed, it opens up a pop-up window listing all of the Test Steps, and the user can update the status of each step with Passed, Failed or Not Complete. When an automated test case is run, QC invokes the Automation Tool which in turn executes the script, stores the result in the QC repository, and displays it on the UI.

All defects are logged in this tab. These defects can be mapped to the corresponding test cases that failed and hence to the Requirements tab. Defects can be filtered on the status of the defect or by the user.

The add-on package, QCReporting has been created which is dedicated to QC and produces media, where possible, in the following formats:

PDF
Microsoft Excel
Screen table

soure-wiki

2010-06-04T12:38:00.000-07:00

Now what is a TEST Automation Framework ?

A set of guidelines like coding standards , test-data handling , object repository treatment etc... which when followed during automation scripting produce beneficial outcomes like increase code re-usage , higher portability , reduced script maintenance cost etc. Mind you these are just guidelines and not rules; they are not mandatory and you can still script without following the guidelines. But you will miss out on the advantages of having a Framework.

What are the various Automation Frameworks available?

1) Linear Scripting
2)The Test Library Architecture Framework.
3)The Data-Driven Testing Framework.
4)The Keyword-Driven or Table-Driven Testing Framework.
5)The Hybrid Test Automation Framework.

Lets look at them in detail -

1) Linear Scripting - Record & Playback

It is the simplest of all Frameworks and also know as "Record & Playback".In this Framework , Tester manually records each step ( Navigation and User Inputs), Inserts Checkpoints ( Validation Steps) in the first round . He then , Plays back the recorded script in the subsequent rounds.

Ex : Consider logging into Flight Reservation Application and checking wether the application has loaded on successful log-on. Here , the tester will simply record the steps and add validation steps.

SystemUtil.Run "flight4a.exe","","","open"

Dialog("Login").WinEdit("Agent Name:").Set "Guru99"

Dialog("Login").WinEdit("Password:").Set "Mercury"

Dialog("Login").WinButton("OK").Click

'Check Flight Reservation Window has loaded after successful log-on

Window("Flight Reservation").Check CheckPoint("Flight Reservation")

Advantages

Fastest way to generate script
Automation expertise not required
Easiest way to learn the features of the Testing Tool

Disadvantages

Little reuse of scripts
Test data is hard coded into the script
Maintenance Nightmare

2)The Test Library Architecture Framework.

It is also know as "Structured Scripting" or "Functional Decomposition".

In this Framework , test scripts are initially recorded by “Record & Playback” method. Later, common tasks inside the scripts are identified and grouped into Functions. These Functions are called by main test script called Driver in different ways to create test cases.

Ex: Using the same example as above, the function for logging in to Flight Reservation will look like .

Function Login()

SystemUtil.Run "flight4a.exe","","","open"

Dialog("Login").WinEdit("Agent Name:").Set "Guru99"

Dialog("Login").WinEdit("Password:").Set "Mercury"

Dialog("Login").WinButton("OK").Click

End Function

Now, you will call this function in the main script as follows

'Driver Script

Call Login()

---------------------------

Other Function calls / Test Steps.

---------------------------

Advantages

Higher level of code reuse is achieved in Structured Scripting as compared to “Record & Playback”
The automation scripts are less costly to develop due to higher code re-use
Easier Script Maintenance

Disadvantages

Technical expertise is necessary to write Scripts using Test Library Framework.
More time is needed to plan and prepare test scripts.
Test Data is hard coded within the scripts

3)The Data-Driven Testing Framework.

In this Framework , while Test case logic resides in Test Scripts, the Test Data is separated and kept outside the Test Scripts.Test Data is read from the external files (Excel Files, Text Files, CSV Files, ODBC Sources, DAO Objects, ADO Objects) and are loaded into the variables inside the Test Script. Variables are used both for Input values and for Verification values. Test Scripts themselves are prepared either using Linear Scripting or Test Library Framework.

Ex: Developing the Flight Reservation Login script using this method will involve two steps.

Step 1) Create a Test - Data file which could be Excel , CSV , or any other database source.

AgentName	Password
Jimmy	Mercury
Tina	MERCURY
Bill	MerCURY

Step 2) Develop Test Script and make references to your Test- Data source.

SystemUtil.Run "flight4a.exe","","","open"

Dialog("Login").WinEdit("Agent Name:").Set DataTable("AgentName", dtGlobalSheet)

Dialog("Login").WinEdit("Password:").Set DataTable("Password", dtGlobalSheet)

Dialog("Login").WinButton("OK").Click

'Check Flight Reservation Window has loaded

Window("Flight Reservation").Check CheckPoint("Flight Reservation")

**Note “dtGlobalSheet” is the default excel sheet provided by QTP.

Advantages

Changes to the Test Scripts do not affect the Test Data
Test Cases can be executed with multiple Sets of Data
A Variety of Test Scenarios can be executed by just varying the Test Data in the External Data File

DisAdvantages

More time is needed to plan and prepare both Test Scripts and Test Data

4)The Keyword-Driven or Table-Driven Testing Framework.

The Keyword-Driven or Table-Driven framework requires the development of data tables and keywords, independent of the test automation tool used to execute them . Tests can be designed with or without the Application. In a keyword-driven test, the functionality of the application-under-test is documented in a table as well as in step-by-step instructions for each test.

There are 3 basis components of a Keyword Driven Framework viz. Keyword , Application Map , Component Function.

What is a Keyword ?

Keyword is an Action that can be performed on a GUI Component. Ex . For GUI Component Textbox some Keywords ( Action) would be InputText, VerifyValue, VerifyProperty and so on.

What is Application Map?

An Application Map Provides Named References for GUI Components. Application Maps are nothing but “Object Repositry’

What is Component Function?

Component Functions are those functions that actively manipulate or interrogate GUI component. An example of a function would be click on web button with all error handling , enter data in a Web Edit with all error handling. Component functions could be application dependent or independent.

Ex: To understand Keyword View lets take the same example. It invovles 2 steps

Step 1: Creating Data Table (Different from Test-Data Table created in Data Driven Framework). This Data Table contains Action to be performed on GUI Objects and correspoding arguments if any. Each row respresents one Test Step.

Object (Application MAP)	Action (KEYWORDS)	Argument
WinEdit(Agent Name)	Set	Guru99
WinEdit(Password)	Set	Mercury
WinButton(OK)	Click
Window(Flight Reservation)	Verify	Exists

Step 2: Writing Code in the form of Component Functions.

Once you've created your data table(s), you simply write a program or a set of scripts that reads in each step, executes the step based on the keyword contained the Action field, performs error checking, and logs any relevant information. This program or set of scripts would look similar to the pseudo code below:

Function main()

{

Call ConnectTable(Name of the Table) { //Calling Function for connecting to the table.

while (Call TableParser() != -1) //Calling function for Parsing and extracting values from the table.

{

Pass values to appropriate COMPONENT functions. Like Set(Object Name , Argument) ex. Set( Agent Name , Guru99).

}

Call CloseConnection() //Function for Closing connection after all the operation has been performed.

} //End of main

Thats all to Keyword Driven Framework.

The advantage of Keyword Driven Framework is that the Keywords are re-usable. To understand this consider you want to verify login operation for a Website say YAHOO MAIL. The table will look like this -

Object (APPLICATION MAP)	Action (KEYWORD)	Argument
WebEdit(UserName)	Set	abc@yahoo.com
WebEdit(Password)	Set	xxxxx
WebButton(OK)	Click
Window(Yahoo Mail)	Verify	Loads

If you observe in this case the Keywords Set , Click , Verify remain the same for which corresponding component functions are already developed. All you need to do is change the Application Mapping (Object Repository) from earlier Flight Reservation to Yahoo Mail , with change in argument values and the same script will work!

Advantages

Provides high code re-usability
Test Tool Independent
Independent of Application Under Test, same script works for AUT (with some limitations)
Tests can be designed with or without AUT

Disadvantages

Initial investment being pretty high, the benefits of this can only be realized if the application is considerably big and the test scripts are to be maintained for quite a few years.
High Automation expertise is required to create the Keyword Driven Framework.

NOTE : Even though QTP advertises itself as KeyWord Driven Framework, you can not achieve complete test tool and application idependence using QTP.

5)The Hybrid Test Automation Framework.

As the name suggests this framework is the combination of one or more frameworks discussed above pulling from their strengths and trying to mitigate their weaknesses. This hybrid test automation framework is what most frameworks evolve into over time and multiple projects. Maximum industry uses Keyword Framework in combination of Function decomposition method.

source- guru99

2010-05-29T15:50:00.001-07:00

Referential integrity is imposed by adding referential constraints to table and column definitions. Once referential constraints are defined to the database manager, changes to the data within the tables and columns is checked against the defined constraint. Completion of the requested action depends on the result of the constraint checking.

Referential constraints are established with the FOREIGN KEY clause, and the REFERENCES clause in the CREATE TABLE or ALTER TABLE statements. There are effects from a referential constraint on a typed table or to a parent table that is a typed table that you should consider before creating a referential constraint.
The identification of foreign keys enforces constraints on the values within the rows of a table or between the rows of two tables. The database manager checks the constraints specified in a table definition and maintains the relationships accordingly. The goal is to maintain integrity whenever one database object references another.
For example, primary and foreign keys each have a department number column. For the EMPLOYEE table, the column name is WORKDEPT, and for the DEPARTMENT table, the name is DEPTNO. The relationship between these two tables is defined by the following constraints:

There is only one department number for each employee in the EMPLOYEE table, and that number exists in the DEPARTMENT table.
Each row in the EMPLOYEE table is related to no more than one row in the DEPARTMENT table. There is a unique relationship between the tables.
Each row in the EMPLOYEE table that has a non-null value for WORKDEPT is related to a row in the DEPTNO column of the DEPARTMENT table.
The DEPARTMENT table is the parent table, and the EMPLOYEE table is the dependent table.

The SQL statement defining the parent table, DEPARTMENT, is:

CREATE TABLE DEPARTMENT
      (DEPTNO    CHAR(3)     NOT NULL,
       DEPTNAME  VARCHAR(29) NOT NULL,
       MGRNO     CHAR(6),
       ADMRDEPT  CHAR(3)     NOT NULL,
       LOCATION  CHAR(16),
          PRIMARY KEY (DEPTNO))
   IN RESOURCE

The SQL statement defining the dependent table, EMPLOYEE, is:

CREATE TABLE EMPLOYEE
      (EMPNO     CHAR(6)     NOT NULL PRIMARY KEY,
       FIRSTNME  VARCHAR(12) NOT NULL,
       LASTNAME  VARCHAR(15) NOT NULL,
       WORKDEPT  CHAR(3),
       PHONENO   CHAR(4),
       PHOTO     BLOB(10m)   NOT NULL,
          FOREIGN KEY DEPT (WORKDEPT)
          REFERENCES DEPARTMENT ON DELETE NO ACTION)
   IN RESOURCE

By specifying the DEPTNO column as the primary key of the DEPARTMENT table and WORKDEPT as the foreign key of the EMPLOYEE table, you are defining a referential constraint on the WORKDEPT values. This constraint enforces referential integrity between the values of the two tables. In this case, any employees that are added to the EMPLOYEE table must have a department number that can be found in the DEPARTMENT table.
The delete rule for the referential constraint in the employee table is NO ACTION, which means that a department cannot be deleted from the DEPARTMENT table if there are any employees in that department.
Although the previous examples use the CREATE TABLE statement to add a referential constraint, the ALTER TABLE statement can also be used.
Another example: The same table definitions are used as those in the previous example. Also, the DEPARTMENT table is created before the EMPLOYEE table. Each department has a manager, and that manager is listed in the EMPLOYEE table. MGRNO of the DEPARTMENT table is actually a foreign key of the EMPLOYEE table. Because of this referential cycle, this constraint poses a slight problem. You could add a foreign key later. You could also use the CREATE SCHEMA statement to create both the EMPLOYEE and DEPARTMENT tables at the same time.

2010-05-29T15:43:00.000-07:00

The hierarchical data model organizes data in a tree structure. There is a hierarchy of parent and child data segments. This structure implies that a record can have repeating information, generally in the child data segments. Data in a series of records, which have a set of field values attached to it. It collects all the instances of a specific record together as a record type. These record types are the equivalent of tables in the relational model, and with the individual records being the equivalent of rows. To create links between these record types, the hierarchical model uses Parent Child Relationships. These are a 1:N mapping between record types. This is done by using trees, like set theory used in the relational model, "borrowed" from maths. For example, an organization might store information about an employee, such as name, employee number, department, salary. The organization might also store information about an employee's children, such as name and date of birth. The employee and children data forms a hierarchy, where the employee data represents the parent segment and the children data represents the child segment. If an employee has three children, then there would be three child segments associated with one employee segment. In a hierarchical database the parent-child relationship is one to many. This restricts a child segment to having only one parent segment. Hierarchical DBMSs were popular from the late 1960s, with the introduction of IBM's Information Management System (IMS) DBMS, through the 1970s.

A parent-child hierarchy is a hierarchy in a standard dimension that contains a parent attribute. A parent attribute describes a self-referencing relationship, or self-join, within a dimension main table. Parent-child hierarchies are constructed from a single parent attribute. Only one level is assigned to a parent-child hierarchy, because the levels present in the hierarchy are drawn from the parent-child relationships between members associated with the parent attribute.

(RDBMS - relational database management system) A database based on the relational model developed by E.F. Codd. A relational database allows the definition of data structures, storage and retrieval operations and integrity constraints. In such a database the data and relations between them are organised in tables. A table is a collection of records and each record in a table contains the same fields.

Properties of Relational Tables:

Values Are Atomic

Each Row is Unique

Column Values Are of the Same Kind

The Sequence of Columns is Insignificant

The Sequence of Rows is Insignificant

Each Column Has a Unique Name

Certain fields may be designated as keys, which means that searches for specific values of that field will use indexing to speed them up. Where fields in two different tables take values from the same set, a join operation can be performed to select related records in the two tables by matching values in those fields. Often, but not always, the fields will have the same name in both tables. For example, an "orders" table might contain (customer-ID, product-code) pairs and a "products" table might contain (product-code, price) pairs so to calculate a given customer's bill you would sum the prices of all products ordered by that customer by joining on the product-code fields of the two tables. This can be extended to joining multiple tables on multiple fields. Because these relationships are only specified at retreival time, relational databases are classed as dynamic database management system. The RELATIONAL database model is based on the Relational Algebra.

ref. unixspace.com

2010-05-29T15:33:00.000-07:00

Types of Inheritance:--

1. Single

2. Multi-level ( class 1 derived to class 2 and class 2 derived to class 3)

3. Multiple ( class 3 derived from class 1 and class 2 )

4. Hierarchy type ( class 1 derives to class 2,3,4 )

5. Hybrid ( deadly diamond )

eg,

class Derived-Class : access-specifier Base-class

Case 1 =

When the access specifier for a base class is public, all public members of the base become public members of the derived class, and all protected members of the base become protected members of the derived class. In all cases, the base's private elements remain private to the base and are not accessible by members of the derived class

Case 2 =

When the base class is inherited by using the private access specifier, all public and protected members of the base class become private members of the derived class

When a base class' access specifier is private, public and protected members of the base become private members of the derived class. This means that they are still accessible by members of the derived class but cannot be accessed by parts of your program that are not members of either the base or derived class.

Case 3 =

Inheritance of Protected members of a class, they behave same as private members of the class i.e. they cant be accessed by the member functions of the class only and cannot be accessed by the non-member functions outside of the class.

But the difference between the PRIVATE and PROTECTED members is this -- private members of the class when derived they cannot be accessed by derived class but protected members are accessed through derived class.

Case 4 =

When we inherit a base class as protected(access specifier). When this is done, all public and protected members of the base class become protected members of the derived class.

Multiple inheritance ( multiple base class - single derived class )

// Inherit multiple base classes.

syntex == class derived: public base1, public base2

Constructor and Destructor calls in inheritance:-

Constructors are executed in their order of derivation. Destructors are executed in reverse order of derivation.

Passing Parameters to Base-Class Constructors:-

#include

using namespace std;

class base {

protected:

int i;

public:

base(int x) { i=x; cout << "Constructing base\n"; }

~base() { cout << "Destructing base\n"; }

};

class derived: public base {

int j;

public:

// derived uses x; y is passed along to base.

derived(int x, int y): base(y) ===================> base class's paramter has to be passed in derived class's constructor even though it might not use it.

{ j=x; cout << "Constructing derived\n"; }

~derived() { cout << "Destructing derived\n"; }

void show() { cout << i << " " << j << "\n"; }

};

int main()

{

derived ob(3, 4);

ob.show(); // displays 4 3

return 0;

}

Special Case of accessing the public member of base class derived as privately making that member private for that derived class:

class base {

public:

int j; // public in base

};

// Inherit base as private.

class derived: private base {

public:

// here is access declaration

base::j; // make j public again //using this syntax base::member;

};

Virtual base class ( deadly diamond -- hybrid inheritance )

// This program uses virtual base classes.

#include

using namespace std;

class base {

public:

int i;

};

// derived1 inherits base as virtual.

class derived1 : virtual public base {

public:

int j;

};

// derived2 inherits base as virtual.

class derived2 : virtual public base {

public:

int k;

};

/* derived3 inherits both derived1 and derived2.

This time, there is only one copy of base class. */

class derived3 : public derived1, public derived2 {

public:

int sum;

};

int main()

{

derived3 ob;

ob.i = 10; // now unambiguous

ob.j = 20;

ob.k = 30;

// unambiguous

ob.sum = ob.i + ob.j + ob.k;

// unambiguous

cout << ob.i << " ";

cout << ob.j << " " << ob.k << " ";

cout << ob.sum;

return 0;

}

2010-05-29T15:24:00.001-07:00

Converting an expression of a given type into another type is known as type-casting.

Implicit conversions do not require any operator. They are automatically performed when a value is copied to a compatible type. For example:

short a=2000;

int b;

b=a;

Here, the value of a has been promoted from short to int and we have not had to specify any type-casting operator. This is known as a standard conversion. Standard conversions affect fundamental data types, and allow conversions such as the conversions between numerical types (short to int, int to float, double to int...), to or from bool, and some pointer conversions. Some of these conversions may imply a loss of precision, which the compiler can signal with a warning. This can be avoided with an explicit conversion.
Implicit conversions also include constructor or operator conversions, which affect classes that include specific constructors or operator functions to perform conversions. For example:

class A {};

class B { public: B (A a) {} };

A a;

B b=a;

Here, a implicit conversion happened between objects of class A and class B, because B has a constructor that takes an object of class A as parameter. Therefore implicit conversions from A to B are allowed.

C++ is a strong-typed language. Many conversions, specially those that imply a different interpretation of the value, require an explicit conversion. We have already seen two notations for explicit type conversion: functional and c-like casting:

short a=2000;

int b;

b = (int) a;    // c-like cast notation

b = int (a);    // functional notation

The functionality of these explicit conversion operators is enough for most needs with fundamental data types. However, these operators can be applied indiscriminately on classes and pointers to classes, which can lead to code that while being syntactically correct can cause runtime errors. For example, the following code is syntactically correct:

// class type-casting

#include

using namespace std;

class CDummy {

    float i,j;

};

class CAddition {

        int x,y;

  public:

        CAddition (int a, int b) { x=a; y=b; }

        int result() { return x+y;}

};

int main () {

  CDummy d;

  CAddition * padd;

  padd = (CAddition*) &d;

  cout << padd->result();

  return 0;

The program declares a pointer to CAddition, but then it assigns to it a reference to an object of another incompatible type using explicit type-casting:

padd = (CAddition*) &d;

Traditional explicit type-casting allows to convert any pointer into any other pointer type, independently of the types they point to. The subsequent call to member result will produce either a run-time error or a unexpected result.
In order to control these types of conversions between classes, we have four specific casting operators: dynamic_cast, reinterpret_cast, static_cast and const_cast. Their format is to follow the new type enclosed between angle-brackets (<>) and immediately after, the expression to be converted between parentheses.
dynamic_cast (expression)
reinterpret_cast (expression)
static_cast (expression)
const_cast (expression)
The traditional type-casting equivalents to these expressions would be:

(new_type) expression
new_type (expression)
but each one with its own special characteristics:

dynamic_cast can be used only with pointers and references to objects. Its purpose is to ensure that the result of the type conversion is a valid complete object of the requested class.
Therefore, dynamic_cast is always successful when we cast a class to one of its base classes:

class CBase { };

class CDerived: public CBase { };

CBase b; CBase* pb;

CDerived d; CDerived* pd;

pb = dynamic_cast(&d);     // ok: derived-to-base

pd = dynamic_cast(&b);  // wrong: base-to-derived

The second conversion in this piece of code would produce a compilation error since base-to-derived conversions are not allowed with dynamic_cast unless the base class is polymorphic.
When a class is polymorphic, dynamic_cast performs a special checking during runtime to ensure that the expression yields a valid complete object of the requested class:

// dynamic_cast

#include

#include

using namespace std;

class CBase { virtual void dummy() {} };

class CDerived: public CBase { int a; };

int main () {

  try {

    CBase * pba = new CDerived;

    CBase * pbb = new CBase;

    CDerived * pd;

    pd = dynamic_cast(pba);

    if (pd==0) cout << "Null pointer on first type-cast" << endl;

    pd = dynamic_cast(pbb);

    if (pd==0) cout << "Null pointer on second type-cast" << endl;

  } catch (exception& e) {cout << "Exception: " << e.what();}

  return 0;

Null pointer on second type-cast

Compatibility note: dynamic_cast requires the Run-Time Type Information (RTTI) to keep track of dynamic types. Some compilers support this feature as an option which is disabled by default. This must be enabled for runtime type checking using dynamic_cast to work properly.

The code tries to perform two dynamic casts from pointer objects of type CBase* (pba and pbb) to a pointer object of type CDerived*, but only the first one is successful. Notice their respective initializations:

CBase * pba = new CDerived;

CBase * pbb = new CBase;

Even though both are pointers of type CBase*, pba points to an object of type CDerived, while pbb points to an object of type CBase. Thus, when their respective type-castings are performed using dynamic_cast, pba is pointing to a full object of class CDerived, whereas pbb is pointing to an object of class CBase, which is an incomplete object of class CDerived.

When dynamic_cast cannot cast a pointer because it is not a complete object of the required class -as in the second conversion in the previous example- it returns a null pointer to indicate the failure. If dynamic_cast is used to convert to a reference type and the conversion is not possible, an exception of type bad_cast is thrown instead.
dynamic_cast can also cast null pointers even between pointers to unrelated classes, and can also cast pointers of any type to void pointers (void*).

static_cast can perform conversions between pointers to related classes, not only from the derived class to its base, but also from a base class to its derived. This ensures that at least the classes are compatible if the proper object is converted, but no safety check is performed during runtime to check if the object being converted is in fact a full object of the destination type. Therefore, it is up to the programmer to ensure that the conversion is safe. On the other side, the overhead of the type-safety checks of dynamic_cast is avoided.

class CBase {};

class CDerived: public CBase {};

CBase * a = new CBase;

CDerived * b = static_cast(a);

This would be valid, although b would point to an incomplete object of the class and could lead to runtime errors if dereferenced.
static_cast can also be used to perform any other non-pointer conversion that could also be performed implicitly, like for example standard conversion between fundamental types:

double d=3.14159265;

int i = static_cast<int>(d);

Or any conversion between classes with explicit constructors or operator functions as described in "implicit conversions" above.

reinterpret_cast converts any pointer type to any other pointer type, even of unrelated classes. The operation result is a simple binary copy of the value from one pointer to the other. All pointer conversions are allowed: neither the content pointed nor the pointer type itself is checked.

It can also cast pointers to or from integer types. The format in which this integer value represents a pointer is platform-specific. The only guarantee is that a pointer cast to an integer type large enough to fully contain it, is granted to be able to be cast back to a valid pointer.
The conversions that can be performed by reinterpret_cast but not by static_cast have no specific uses in C++ are low-level operations, whose interpretation results in code which is generally system-specific, and thus non-portable. For example:

class A {};

class B {};

A * a = new A;

B * b = reinterpret_cast(a);

This is valid C++ code, although it does not make much sense, since now we have a pointer that points to an object of an incompatible class, and thus dereferencing it is unsafe.

This type of casting manipulates the constness of an object, either to be set or to be removed. For example, in order to pass a const argument to a function that expects a non-constant parameter:

// const_cast

#include

using namespace std;

void print (char * str)

  cout << str << endl;

int main () {

  const char * c = "sample text";

  print ( const_cast<char *> (c) );

  return 0;

sample text

typeid allows to check the type of an expression:

typeid (expression)
This operator returns a reference to a constant object of type type_info that is defined in the standard header file . This returned value can be compared with another one using operators == and != or can serve to obtain a null-terminated character sequence representing the data type or class name by using its name() member.

// typeid

#include

#include

using namespace std;

int main () {

  int * a,b;

  a=0; b=0;

  if (typeid(a) != typeid(b))

    cout << "a and b are of different types:\n";

    cout << "a is: " << typeid(a).name() << '\n';

    cout << "b is: " << typeid(b).name() << '\n';

  return 0;

a and b are of different types:

a is: int *

b is: int

When typeid is applied to classes typeid uses the RTTI to keep track of the type of dynamic objects. When typeid is applied to an expression whose type is a polymorphic class, the result is the type of the most derived complete object:

// typeid, polymorphic class

#include

#include

#include

using namespace std;

class CBase { virtual void f(){} };

class CDerived : public CBase {};

int main () {

  try {

    CBase* a = new CBase;

    CBase* b = new CDerived;

    cout << "a is: " << typeid(a).name() << '\n';

    cout << "b is: " << typeid(b).name() << '\n';

    cout << "*a is: " << typeid(*a).name() << '\n';

    cout << "*b is: " << typeid(*b).name() << '\n';

  } catch (exception& e) { cout << "Exception: " << e.what() << endl; }

  return 0;

a is: class CBase *

b is: class CBase *

*a is: class CBase

*b is: class CDerived

Notice how the type that typeid considers for pointers is the pointer type itself (both a and b are of type class CBase *). However, when typeid is applied to objects (like *a and *b) typeid yields their dynamic type (i.e. the type of their most derived complete object).
If the type typeid evaluates is a pointer preceded by the dereference operator (*), and this pointer has a null value, typeid throws a bad_typeid exception.

2010-05-29T15:21:00.000-07:00

In the bubble sort, as elements are sorted they gradually "bubble" (or rise) to their proper location in the array, like bubbles rising in a glass of soda. The bubble sort repeatedly compares adjacent elements of an array. The first and second elements are compared and swapped if out of order. Then the second and third elements are compared and swapped if out of order. This sorting process continues until the last two elements of the array are compared and swapped if out of order.

When this first pass through the array is complete, the bubble sort returns to elements one and two and starts the process all over again. So, when does it stop? The bubble sort knows that it is finished when it examines the entire array and no "swaps" are needed (thus the list is in proper order). The bubble sort keeps track of occurring swaps by the use of a flag.

The table below follows an array of numbers before, during, and after a bubble sort fordescending order. A "pass" is defined as one full trip through the array comparing and if necessary, swapping, adjacent elements. Several passes have to be made through the array before it is finally sorted.

The bubble sort is an easy algorithm to program, but it is slower than many other sorts. With a bubble sort, it is always necessary to make one final "pass" through the array to check to see that no swaps are made to ensure that the process is finished. In actuality, the process is finished before this last pass is made.

// Bubble Sort Function for Descending Order
void BubbleSort(apvector &num)
{
      int i, j, flag = 1;    // set flag to 1 to start first pass
      int temp;             // holding variable
      int numLength = num.length( );
      for(i = 1; (i <= numLength) && flag; i++)
     {
          flag = 0;
          for (j=0; j < (numLength -1); j++)
         {
               if (num[j+1] > num[j])      // ascending order simply changes to <
              {
                    temp = num[j];             // swap elements
                    num[j] = num[j+1];
                    num[j+1] = temp;
                    flag = 1;               // indicates that a swap occurred.
               }
          }
     }
     return;   //arrays are passed to functions by address; nothing is returned}

Ref: mathbits.com

2010-05-29T15:17:00.000-07:00

A pipe is a mechanism for interprocess communication; data written to the pipe by one process can be read by another process. The data is handled in a first-in, first-out (FIFO) order. The pipe has no name; it is created for one use and both ends must be inherited from the single process which created the pipe.
A FIFO special file is similar to a pipe, but instead of being an anonymous, temporary connection, a FIFO has a name or names like any other file. Processes open the FIFO by name in order to communicate through it.
A pipe or FIFO has to be open at both ends simultaneously. If you read from a pipe or FIFO file that doesn't have any processes writing to it (perhaps because they have all closed the file, or exited), the read returns end-of-file. Writing to a pipe or FIFO that doesn't have a reading process is treated as an error condition; it generates a SIGPIPE signal, and fails with error code EPIPE if the signal is handled or blocked.
Neither pipes nor FIFO special files allow file positioning. Both reading and writing operations happen sequentially; reading from the beginning of the file and writing at the end.

2010-05-29T15:14:00.000-07:00

The Toilet Example (c) Copyright 2005, Niclas Winquist ;)
Mutex:

Is a key to a toilet. One person can have the key - occupy the toilet - at the time. When finished, the person gives (frees) the key to the next person in the queue.

Officially: "Mutexes are typically used to serialise access to a section of re-entrant code that cannot be executed concurrently by more than one thread. A mutex object only allows one thread into a controlled section, forcing other threads which attempt to gain access to that section to wait until the first thread has exited from that section."
Ref: Symbian Developer Library

(A mutex is really a semaphore with value 1.)

Semaphore:

Is the number of free identical toilet keys. Example, say we have four toilets with identical locks and keys. The semaphore count - the count of keys - is set to 4 at beginning (all four toilets are free), then the count value is decremented as people are coming in. If all toilets are full, ie. there are no free keys left, the semaphore count is 0. Now, when eq. one person leaves the toilet, semaphore is increased to 1 (one free key), and given to the next person in the queue.

Officially: "A semaphore restricts the number of simultaneous users of a shared resource up to a maximum number. Threads can request access to the resource (decrementing the semaphore), and can signal that they have finished using the resource (incrementing the semaphore)."

Ref: Symbian Developer Library

2010-05-29T13:17:00.000-07:00

How many times you get in a situation and think what to use in your function arguments- Call By Reference Or Call By Value?

This ain't tricky et al if you remember all basic simple thing i.e. In call by value, a function call passes arguments by value. The called function creates a new set of variables and copies the values of arguments into them. The function does not have access to the actual variables in the calling program and can only work on the copies of values. This mechanism is fine if the function does not need to alter the values of the original variables in the calling program. But, there may arise situation where we would like to change the values of variables in the calling program. One good example is Bubble Sort, we compare the two adjacent elements in the list and interchange their values if the first element is greater than the second. Now if the function is used for bubble sort, then it should be able to alter the values of variables in the calling function as well, which is not possible if the call by value method is used.
I'm sure this will help you remember the difference for your life now :)

2010-05-26T10:59:00.000-07:00

FURPS is an acronym representing a model for classifying software quality attributes (Functional & Non-functional):

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

The model, developed at HP, was first publicly elaborated by Grady and Caswell. The + was later added to the model after various campaigns at HP to extend the acronym to emphasize various attributes.

FURPS+ is now widely used in the software industry.

2010-05-26T10:22:00.000-07:00

· Router understand IP head, and switch deal with MAC address

· Router has its own IP address(es), and switch don’t

· Router has an operating system running inside, and allow administrator to login into the system.

· You (network administrator) must configure routing table to make it works.

· Switch is usually ready to use.

· Router has routing software running inside, including route discovery protocol.

· Routing software know how to deal with different IP packet, such as ICMP and other IP option functionality. Switches don’t.

· Multiple routers can be connected together as a network.

· You can’t connect directly multiple switches together to form a large network.

   1.Switch are said to be l2 device only but Router are said to be L3 device.
2.Switch is said to be H/W Device.Router are said to be S/W device.
3.Switch perform faster than the router because it is a H/W Device.

Routers and switches are both pieces of networking equipment that help data move across the network to their final location, but they work differently, and actually function at different levels of the networking stack. What is the difference between a router and a switch?
The least intelligent kind of networking device is a hub, which takes data in one port, and then retransmits it out every other port. So any information sent or received by any single computer on a hub is retransmitted to every other computer. This is bad for security, obviously, but it also uses up a lot of bandwidth on the network, as computers have to receive data that they don’t need.

A switch uses a little more intelligence. It learns the IP address of each computer attached to it, by matching up IP addresses with hardware MAC addresses. When data comes into the switch, it only sends data back out the port assigned to that computer’s MAC address. Switches are said to work at a hardware level, and help relieve bandwidth across the network.

A router is the most intelligent networking device. But routers aren’t like really intelligent switches, they actually work in a completely different way. Routers are designed to connect networks together. So, your internal network might have IP addresses, like 192.0.0.100, while your Internet service provider might give your computer an IP address that starts with 64.x.x.x. A router can take internal traffic bound for destinations out on the Internet in general, and route it from your internal network to the external network. Whenever you change networks, you need a router. And vice versa when information comes from the external network to your home network.
So, just to restate, switches connect computers together within the same network, while routers connect entire networks together.

2010-05-25T15:21:00.000-07:00

In 1985, database pioneer Dr. E.F. Codd laid out twelve rules of relational database design. These rules provide the theoretical (although sometimes not practical) underpinnings for modern database design. The rules may be summarized as follows:

All database management must take place using the relational database's innate functionality
All information in the database must be stored as values in a table
All database information must be accessible through the combination of a table name, primary key and column name.
The database must use NULL Values to indicate missing or unknown information
The database schema must be described using the relational database syntax
The database may support multiple languages, but it must support at least one language that provides full database functionality (e.g. SQL)
The system must be able to update all updatable views
The database must provide single-operation insert, update and delete functionality
Changes to the physical structure of the database must be transparent to applications and users.
Changes to the logical structure of the database must be transparent to applications and users.
The database must natively support integrity constraints.
Changes to the distribution of the database (centralized vs. distributed) must be transparent to applications and users.
Any languages supported by the database must not be able to subvert integrity controls.

source: about.com

2010-05-25T14:01:00.000-07:00

CANDIDATE KEY, PRIMARY KEY, UNIQUE KEY, ALTERNATE KEY, COMPOSITE KEY

How many times do we feel confused about these simple database concepts?
The answer is many a times, but I'm sure after reading this post you will never forget any of them.

PRIMARY KEY:-A primary key is a field that uniquely identifies each record in a table. As it uniquely identify each entity, it cannot contain null value and duplicate value.

CANDIDATE KEY:-A nominee's for primary key field are know as candidate key.

ALTERNATE KEY:-A candidate key that is not the primary key is called an Alternate key.

SUPER KEY :- If we add additional attributes to a primary key, the resulting combination would still uniquely identify an instance of the entity set. Such augmented keys are called superkey. A primary key is therefore a minimum superkey.

A candidate key is one that can identify each row of a table uniquely. Generally a candidate key becomes the primary key of the table. If the table has more than one candidate key, one of them will become the primary key, and the rest are called alternate keys.

A key formed by combining at least two or more columns is called composite key.

Difference..
Primary Key..
1.It will not accept null values.
2.There will be only one primary key in a table.
3.Clustered index is created in Primary key.
4.Primary key allows each row in a table to be uniquely identified and ensures that no duplicate rows exist.

Unique Key..
1.Null values are accepted.
2.More than one unique key will be there in a table.
3.Non-Clustered index is created in unique key.
4.Unique key constraint is used to prevent the duplication of key values within the rows of a table and allow null values.

2010-05-25T12:40:00.000-07:00

The outcome of XOR operation is true only when one of the operand is true(but not both).

P Q P^Q
---------------------------------------------
1 1 0
0 0 0
1 0 1
0 1 1

int xor(int a, int b)
{
return (a||b) && !(a && b);
}

2010-05-25T12:15:00.000-07:00

Static member functions have a class scope and they do not have access to the 'this' pointer of the class. When a member is declared as static, a static member of class, it has only one data for the entire class even though there are many objects created for the class. The main usage of static function is when the programmer wants to have a function which is accessible even when the class is not instantiated.

static return_data_type fucntionname()//Static function defined with keyword static
{
statement1;//Statements for execution inside static functionstatement2;
..........
..........
}

For example if a function sys1 returning nothing is to be declared as staic function it is done as follows:

static void sys1()
{
........;
.......;
}

A normal member function is accessed using the object and an operator called the dot member access operator. The functions declared static or static functions are accessed using only the class name and the scope resolution operator, unlike in normal member functions where these are not used.

#include
class example
{
private:
static int sum; //Static dataint x;
public:
example() //Constructor of the class{
sum=sum+1;
x=sum;
}

~example() //Destructor of the class{
sum=sum-1;
}

static void sys1() //Static function exforsys( ) defined with keyword static{
cout<<"\nResult is: "<
}

void number() //Normal member function number( ){
cout<<"\nNumber is: "<
}
};

void main()
{
example e1;
example::sys1();//Static function exforsys() accessed using class name example and the scope resolution operator ::example e2,e3,e4;
example::sys1();
e1.number();//Normal member function accessed using object e1 and the dot member accessoperator.
e2.number();
e3.number();
e4.number();
}

The output of the above program is:

Result is: 1
Result is: 4
Number is: 1
Number is: 2
Number is: 3
Number is: 4

The programmer must note the following while using static member functions:

A static member function can only access static member data, static memberfunctions and data and functions outside the class. The programmer must take note not to use static member function in the same manner as non-static member function, as non-static member function can access all of the above including thestatic data member. .
A non-static member function can be declared as virtual but care must be taken not to declare a static member function as virtual. .
The programmer must first understand the concept of static data while learning the context of static functions. It is possible to declare a data member of a class asstatic irrespective of it being a public or a private type in class definition. If a data is declared as static, then the static data is created and initialized only once. Non-static data members are created again and again. For each separate object of the class, the static data is created and initialized only once. As in the concept ofstatic data, all objects of the class in static functions share the variables. This applies to all objects of the class. .
A non-static member function can be called only after instantiating the class as an object. This is not the case with static member functions. A static member function can be called, even when a class is not instantiated. .
A static member function cannot have access to the 'this' pointer of the class.

reference exforsys.com

2010-05-25T11:27:00.000-07:00

INLINE FUNCTION VS MACROS: the old battle :)

I'm sure sometime or the other you might have had this question popping out of your mind-
"I’m confused about the use of inline functions and macros.What is the difference between them?"

Well the answer is simple->

Inline functions are similar to macros because they both are expanded at compile time, but the macros are expanded by the preprocessor, while inline functions are parsed by the compiler. There are several important differences:

Inline functions follow all the protocols of type safety enforced on normal functions.
Inline functions are specified using the same syntax as any other function except that they include the inline keyword in the function declaration.
Expressions passed as arguments to inline functions are evaluated once. In some cases, expressions passed as arguments to macros can be evaluated more than once.

Now the BIG QUESTION-
When should I use macro and when inline functions?

Besides the difference already pointed out, you also must have in mind that because macros are expanded at pre-compile time, you cannot use them for debugging, but you can use inline functions. This is one important judging factor, isn't it?

2010-05-24T09:21:00.000-07:00

The chgrp command is used to change the group with which a file is associated. The first thing you will need to provide this command is the group which you want to change the file or directory to. After that you can list a single file or directory to be changed or list separate entities separated by spaces. The chgrp command will not have any affect on the access granted to the group (the rw- in the middle of the three permissions sets) but will change who can use those permissions.
Using the chgrp Command on a File

# ls -l
total 12
-rw-rw-r– 1 tclark authors 2229 Jan 13 21:35 declaration.txt
-rw-rw-r– 1 tclark authors 1310 Jan 13 17:48 gettysburg.txt
-rw-rw-r– 1 tclark authors 360 Jan 13 17:48 preamble.txt
# chgrp presidents gettysburg.txt
# ls -l
total 12
-rw-rw-r– 1 tclark authors 2229 Jan 13 21:35 declaration.txt
-rw-rw-r– 1 tclark presidents 1310 Jan 13 17:48 gettysburg.txt
-rw-rw-r– 1 tclark authors 360 Jan 13 17:48 preamble.txt

The chgrp command works the same for directories as it does for files. In the following example, the group ownership of the directory called examples will be changed. Directories are identified by the letter d in the first column of the ls –l display.
Using the chgrp Command on a Directory

# ls -l
total 4
-rw-rw-r– 1 tclark tclark 0 Jan 13 21:13 example1.fil
-rw-rw-r– 1 tclark tclark 0 Jan 13 21:13 example2.xxx
drwxrwxr-x 2 tclark tclark 4096 Jan 13 21:35 examples
# chgrp authors examples
# ls -l
total 4
-rw-rw-r– 1 tclark tclark 0 Jan 13 21:13 example1.fil
-rw-rw-r– 1 tclark tclark 0 Jan 13 21:13 example2.xxx
drwxrwxr-x 2 tclark authors 4096 Jan 13 21:35 examples

You can change the group for multiple files and/or directories by using the –R(recursive) option for the chgrp command. This is one of the few commands (we’ll see two of the others shortly) which use an upper-case R for the recursive option. When applied on a directory the –R option will apply thechgrp command to the directory and all its subdirectories and files. Care should be taken when using the –R option.
Next we’ll look at changing the ownership of files.

The chown (change owner) command can be used to change ownership of a file or directory. The syntax is very similar to chgrp.

# ls -l
total 12
-rw-rw-r– 1 tclark authors 2229 Jan 13 21:35 declaration.txt
-rw-rw-r– 1 tclark authors 1310 Jan 13 17:48 gettysburg.txt
-rw-rw-r– 1 tclark authors 360 Jan 13 17:48 preamble.txt
# chown abe gettysburg.txt
# ls -l
total 12
-rw-rw-r– 1 tclark authors 2229 Jan 13 21:35 declaration.txt
-rw-rw-r– 1 abe authors 1310 Jan 13 17:48 gettysburg.txt
-rw-rw-r– 1 tclark authors 360 Jan 13 17:48 preamble.txt

Just like with chgrp we see that chown accepts the username of the user who should get ownership and the file or directory to change. Again we could list multiple files or directories here with spaces separating them.
The chown command can be used to change the group ownership instead of the user ownership of a file or directory. If you wish to use chown to change the group ownership you can list a group preceded with either a colon (:) or a period (.). Here’s an example of how to use chown to change the group ownership of a file:

# ls -l
total 12
-rw-rw-r– 1 tclark authors 2229 Jan 13 21:35 declaration.txt
-rw-rw-r– 1 abe authors 1310 Jan 13 17:48 gettysburg.txt
-rw-rw-r– 1 tclark authors 360 Jan 13 17:48 preamble.txt
# chown :presidents gettys*
# ls -l
total 12
-rw-rw-r– 1 tclark authors 2229 Jan 13 21:35 declaration.txt
-rw-rw-r– 1 abe presidents 1310 Jan 13 17:48 gettysburg.txt
-rw-rw-r– 1 tclark authors 360 Jan 13 17:48 preamble.txt

If you wish to simultaneously change both the user and group ownership of a file you can specify the user and group in the format of user:group.
In the following example the user will be changed back to tclark and the group back to authors using a single command.
Using the chown Command to Change File Ownership

# ls -l
total 12
-rw-rw-r– 1 tclark authors 2229 Jan 13 21:35 declaration.txt
-rw-rw-r– 1 abe presidents 1310 Jan 13 17:48 gettysburg.txt
-rw-rw-r– 1 tclark authors 360 Jan 13 17:48 preamble.txt
# chown tclark:authors gettys*
# ls -l
total 12
-rw-rw-r– 1 tclark authors 2229 Jan 13 21:35 declaration.txt
-rw-rw-r– 1 tclark authors 1310 Jan 13 17:48 gettysburg.txt
-rw-rw-r– 1 tclark authors 360 Jan 13 17:48 preamble.txt

Here we see the user and group has been changed with a single command. Just like with chgrp the chown command will take the –R (recursive) option and apply the chown command to a directory and its subdirectories. This should be used with care.

reference:http://www.dba-oracle.com/linux

2010-05-20T09:52:00.000-07:00

Scrum is an agile software developement model based on multiple small teams working in an intensive and interdependent manner. The term is named for the scrum (or scrummage) formation in rugby, which is used to restart the game after an event that causes play to stop, such as an infringement.
Scrum employs real time decision-making processes based on actual events and information. This requires well-trained and specialized teams capable of self-management, communication and decision-making. The teams in the organization work together while constantly focusing on their common interests.
Scrum involves:

Initial appointment of a project manager called the "scrum master."
Definition and prioritization of tasks to be done.
Planning sessions for each task.
Daily meetings among teams.
Identification and evaluation of potential project risks and process pitfalls.
Execution of projects in brief, high-intensity, frequent work sessions.
Reviews of progress and evaluations of completed projects.
Openness to constructive criticism and ideas for improvement.

2010-05-18T14:46:00.001-07:00

The explicit keyword in C++ is used to declare explicit constructors. Explicit constructors are simply constructors that cannot take part in an implicit conversion. Consider the following example:

class Array
{
public:
Array(size_t count);
// etc.
};

This seems innocent enough until you realize that you can do this:

Array array = 123;

Well that’s ugly but hardly something to get excited about, or is it? This is known as an implicit conversion. The trouble is that it can occur in more insidious places. Consider the following function:

void UseArray(const Array& array);

Because the compiler will attempt to find an implicit conversion, the following code compiles just find:

UseArray(123);

Yikes! That’s terrible. First there is the problem of code clarity. What does this mean? Secondly, because the implicit conversion involves calling the Array constructor, presumably enough storage is being allocated for a new Array object, not to mention the memory reserved for 123 elements contained in the array. Surely this is not what the programmer intended!?

All of these subtleties can be avoided by making the Array constructor explicit:

class Array
{
public:
explicit Array(size_t size);
// etc.
};

Now a programmer needs to be explicit about her use of the Array constructor.

Array array(123);
UseArray(Array(123));

A thing of beauty.

So why aren’t all constructors explicit? Well in a small number of cases it makes sense to allow an implicit conversion to allow user-defined types to behave like built-in types. A canonical example would probably be a high-precision numeric type:

Number number = 123;

In this case it makes sense to provide a more natural expression.

And finally, if you have two or more required constructor arguments then it does not make sense to make the constructor explicit since it cannot be used in implicit conversions anyway:

class UserName
{
public:
UserName(const std::wstring& principal,
const std::wstring& authority);
};

Making the UserName constructor explicit would have no effect. You might be tempted to give authority a default value and then allow UserName to take part in an implicit conversion. When considering this, you should always think about whether it could introduce an error by default. Consider what happens if we do this.

class UserName
{
public:
    UserName(const std::wstring& principal,
             const std::wstring& authority = std::wstring());
    // etc.
};

Now the programmer can write the following dubious code:

UserName userName = L”kenny@kennyandkarin.com”;

What’s wrong with that? Well the entire string is passed as the principal and the programmer’s entirely innocent code is now incorrect. A better solution is to return to the original UserName class design and then the use of the UserName class is clear:

UserName username(“kenny”,
“kennyandkarin.com”);

Since both arguments are required, it is much harder for the programmer to neglect the one, and setting the authority to an empty string would be easier to spot as an error in a code review. You might even have the UserName constructor throw an ArgumentException if the authority is empty.

2010-05-18T14:35:00.001-07:00

What do you mean by Stack unwinding?
It is a process during exception handling when the destructor is called for all local objects between the place where the exception was thrown and where it is caught.

2010-05-18T14:32:00.000-07:00

What is a dangling pointer?
A dangling pointer arises when you use the address of an object after
its lifetime is over. This may occur in situations like returning
addresses of the automatic variables from a function or using the
address of the memory block after it is freed. The following
code snippet shows this:

class Sample{
public:
int *ptr;
Sample(int i){
ptr = new int(i);}

~Sample(){
delete ptr;}
void PrintVal(){
cout << "The value is " << *ptr;}
};

void SomeFunc(Sample x){
cout << "Say i am in someFunc " << endl;}

int main(){
Sample s1 = 10;
SomeFunc(s1);
s1.PrintVal();}

In the above example when PrintVal() function is
called it is called by the pointer that has been freed by the
destructor in SomeFunc.

2010-05-18T13:51:00.001-07:00

Anything wrong with this code?
T *p = new T[10];
delete p;

Everything is correct, Only the first element of the array will be deleted”, The entire array will be deleted, but only the first element destructor will be called.

Anything wrong with this code?
T *p = 0;
delete p;

Yes, the program will crash in an attempt to delete a null pointer.

Array at beginning:

After Pass #1:

After Pass #2:

After Pass #3:

After Pass #4:

After Pass #5 (done):