When Tester Think about programmer they Smile.

Do you know why because due to tester programmer always feel embarrassed because tester find some mistakes in his program.

How the tester do in software.

There is lots of testing types through which tester test the software or websites.

Hi fiend I am not the tester so I don’t have more idea about testing but yes because of my experience in web development and software development I face tester and his ideas and many more thing…. so I can explain about testing.

Some of the types is available in testing it may different from others.

Black box testing

White box testing

Unit testing

Incremental integration testing

Integration testing

Functional testing

System testing

End-to-end testing

Sanity testing

Regression testing

Acceptance testing

Load testing

Stress testing

Performance testing

Usability testing

Install/uninstall testing

Recovery testing

Security testing

Compatibility testing

Comparison testing

Alpha testing

Beta testing

SOME OTHER PEOPLE OR TESTER TOLD ME THESE TYPE OF TESTING

ACCEPTANCE TESTING

BLACK BOX TESTING

COMPATIBILITY TESTING

CONFORMANCE TESTING

FUNCTIONAL TESTING

INTEGRATION TESTING

LOAD TESTING

PERFORMANCE TESTING

REGRESSION TESTING

SMOKE TESTING

STRESS TESTING

SYSTEM TESTING

UNIT TESTING

WHITE BOX TESTING

I am a programmer so I know problem creation of tester not type of testing I feel ……. when tester find out some bug in my application but water goes out of my head when he suggest according to

his opinion. But I want to make aware to all my friends programmer don’t believe on tester when he/she suggest don’t hesitate to told him to send a mail and cc to manager which you are suggesting. This will be good way to work with tester otherwise if you change your application according to his eye the what will be next you can’t imagine some time boss asked about these changes then they are just say it was my opinion and programmer changed so what I do. This will be language of tester when his/her neck in boss cabin.

Some tester without knowing the application start testing. What happens that time tester get more bug or No more bug so every programmer should train him on his/her application which he developed. Otherwise unnecessary you will be let to deliver you application. and this will make bad impression in office.

Some programmer leave bug and try to hide them but this is not the professional way to be a

programmer if you know the bug then it should solved before tester test because you know tester will send you again to solve and the bug list mail will goes to your project manager so don’t ignore any small bug. not even bug try to make some good website or application.

Don’t fight with tester try to be friend but not general friend professional friend it means

tester always think positive about you that “you made means no bug” that sentence you should expect from tester.

Do Bug Free Program and be friend of tester this is the main mantra about programming.

When Tester Think about programmer they Smile.

Do you know why because due to tester programmer always feel embarrassed because tester find some mistakes in his program.

How the tester do in software.

There is lots of testing types through which tester test the software or websites.

Hi fiend I am not the tester so I don’t have more idea about testing but yes because of my experience in web development and software development I face tester and his ideas and many more thing…. so I can explain about testing.

Some of the types is available in testing it may different from others this is like history.

Black box testing – Internal system design is not considered in this type of testing. Tests are based on requirements and functionality.

White box testing – This testing is based on knowledge of the internal logic of an application’s code. Also known as Glass box Testing. Internal software and code working should be known for this type of testing. Tests are based on coverage of code statements, branches, paths, conditions.

Unit testing – Testing of individual software components or modules. Typically done by the programmer and not by testers, as it requires detailed knowledge of the internal program design and code. may require developing test driver modules or test harnesses.

Incremental integration testing – Bottom up approach for testing i.e continuous testing of an application as new functionality is added; Application functionality and modules should be independent enough to test separately. done by programmers or by testers.

Integration testing – Testing of integrated modules to verify combined functionality after integration. Modules are typically code modules, individual applications, client and server applications on a network, etc. This type of testing is especially relevant to client/server and distributed systems.

Functional testing – This type of testing ignores the internal parts and focus on the output is as per requirement or not. Black-box type testing geared to functional requirements of an application.

System testing – Entire system is tested as per the requirements. Black-box type testing that is based on overall requirements specifications, covers all combined parts of a system.

End-to-end testing – Similar to system testing, involves testing of a complete application environment in a situation that mimics real-world use, such as interacting with a database, using network communications, or interacting with other hardware, applications, or systems if appropriate.

Sanity testing – Testing to determine if a new software version is performing well enough to accept it for a major testing effort. If application is crashing for initial use then system is not stable enough for further testing and build or application is assigned to fix.

Regression testing – Testing the application as a whole for the modification in any module or functionality. Difficult to cover all the system in regression testing so typically automation tools are used for these testing types.

Acceptance testing -Normally this type of testing is done to verify if system meets the customer specified requirements. User or customer do this testing to determine whether to accept application.

Load testing – Its a performance testing to check system behavior under load. Testing an application under heavy loads, such as testing of a web site under a range of loads to determine at what point the system’s response time degrades or fails.

Stress testing – System is stressed beyond its specifications to check how and when it fails. Performed under heavy load like putting large number beyond storage capacity, complex database queries, continuous input to system or database load.

Performance testing – Term often used interchangeably with ‘stress’ and ‘load’ testing. To check whether system meets performance requirements. Used different performance and load tools to do this.

Usability testing – User-friendliness check. Application flow is tested, Can new user understand the application easily, Proper help documented whenever user stuck at any point. Basically system navigation is checked in this testing.

Install/uninstall testing – Tested for full, partial, or upgrade install/uninstall processes on different operating systems under different hardware, software environment.

Recovery testing – Testing how well a system recovers from crashes, hardware failures, or other catastrophic problems.

Security testing – Can system be penetrated by any hacking way. Testing how well the system protects against unauthorized internal or external access. Checked if system, database is safe from external attacks.

Compatibility testing – Testing how well software performs in a particular hardware/software/operating system/network environment and different combination s of above.

Comparison testing – Comparison of product strengths and weaknesses with previous versions or other similar products.

Alpha testing – In house virtual user environment can be created for this type of testing. Testing is done at the end of development. Still minor design changes may be made as a result of such testing.

Beta testing – Testing typically done by end-users or others. Final testing before releasing application for commercial purpose.

SOME OTHER PEOPLE OR TESTER TOLD ME THESE TYPE OF TESTING

ACCEPTANCE TESTING

Testing to verify a product meets customer specified requirements. A customer usually does this type of testing on a product that is developed externally.

BLACK BOX TESTING

Testing without knowledge of the internal workings of the item being tested. Tests are usually functional.

COMPATIBILITY TESTING

Testing to ensure compatibility of an application or Web site with different browsers, OSs, and hardware platforms. Compatibility testing can be performed manually or can be driven by an automated functional or regression test suite.

CONFORMANCE TESTING

Verifying implementation conformance to industry standards. Producing tests for the behavior of an implementation to be sure it provides the portability, interoperability, and/or compatibility a standard defines.

FUNCTIONAL TESTING

Validating an application or Web site conforms to its specifications and correctly performs all its required functions. This entails a series of tests which perform a feature by feature validation of behavior, using a wide range of normal and erroneous input data. This can involve testing of the product’s user interface, APIs, database management, security, installation, networking, etcF testing can be performed on an automated or manual basis using black box or white box methodologies.

INTEGRATION TESTING

Testing in which modules are combined and tested as a group. Modules are typically code modules, individual applications, client and server applications on a network, etc. Integration Testing follows unit testing and precedes system testing.

LOAD TESTING

Load testing is a generic term covering Performance Testing and Stress Testing.

PERFORMANCE TESTING

Performance testing can be applied to understand your application or web site’s scalability, or to benchmark the performance in an environment of third party products such as servers and middleware for potential purchase. This sort of testing is particularly useful to identify performance bottlenecks in high use applications. Performance testing generally involves an automated test suite as this allows easy simulation of a variety of normal, peak, and exceptional load conditions.

REGRESSION TESTING

Similar in scope to a functional test, a regression test allows a consistent, repeatable validation of each new release of a product or Web site. Such testing ensures reported product defects have been corrected for each new release and that no new quality problems were introduced in the maintenance process. Though regression testing can be performed manually an automated test suite is often used to reduce the time and resources needed to perform the required testing.

SMOKE TESTING

A quick-and-dirty test that the major functions of a piece of software work without bothering with finer details. Originated in the hardware testing practice of turning on a new piece of hardware for the first time and considering it a success if it does not catch on fire.

STRESS TESTING

Testing conducted to evaluate a system or component at or beyond the limits of its specified requirements to determine the load under which it fails and how. A graceful degradation under load leading to non-catastrophic failure is the desired result. Often Stress Testing is performed using the same process as Performance Testing but employing a very high level of simulated load.

SYSTEM TESTING

Testing conducted on a complete, integrated system to evaluate the system’s compliance with its specified requirements. System testing falls within the scope of black box testing, and as such, should require no knowledge of the inner design of the code or logic.

UNIT TESTING

Functional and reliability testing in an Engineering environment. Producing tests for the behavior of components of a product to ensure their correct behavior prior to system integration.

WHITE BOX TESTING

Testing based on an analysis of internal workings and structure of a piece of software. Includes techniques such as Branch Testing and Path Testing. Also known as Structural Testing and Glass Box Testing.

I am a programmer so I know problem creation of tester not type of testing I feel ……. when tester find out some bug in my application but water goes out of my head when he suggest according to

his opinion. But I want to make aware to all my friends programmer don’t believe on tester when he/she suggest don’t hesitate to told him to send a mail and cc to manager which you are suggesting. This will be good way to work with tester otherwise if you change your application according to his eye the what will be next you can’t imagine some time boss asked about these changes then they are just say it was my opinion and programmer changed so what I do. This will be language of tester when his/her neck in boss cabin.

Some tester without knowing the application start testing. What happens that time tester get more bug or No more bug so every programmer should train him on his/her application which he developed. Otherwise unnecessary you will be let to deliver you application. and this will make bad impression in office.

Some programmer leave bug and try to hide them but this is not the professional way to be a

programmer if you know the bug then it should solved before tester test because you know tester will send you again to solve and the bug list mail will goes to your project manager so don’t ignore any small bug. not even bug try to make some good website or application.

Don’t fight with tester try to be friend but not general friend professional friend it means

tester always think positive about you that “you made means no bug” that sentence you should expect from tester.

Do Bug Free Program and be friend of tester this is the main mantra about programming.

For each file, we want to associate it with a user for ownership, but we also want to be able to associate it with many other users for sharing (read access). So we need to define two separate associations from file to user. We’re going to manage the sharing access with an association called “Has and belongs to many” or HABTM for short. HABTM utilises a join table to associate the two records, and has a standard within CakePHP that we’ll follow so the framework can do all the heavy lifting for us:

CREATE DATABASE `fileshare`;
USE `fileshare`;

CREATE TABLE `uploads` (
	`id` CHAR(36) NOT NULL PRIMARY KEY,
	`user_id` CHAR(36) NOT NULL,
	`title` VARCHAR(45) NOT NULL,
	`description` TEXT,
	`filename` VARCHAR(255) NOT NULL,
	`filesize` INT(11) UNSIGNED NOT NULL DEFAULT 0,
	`filemime` VARCHAR(45) NOT NULL DEFAULT 'text/plain',
	`created` DATETIME,
	`modified` DATETIME
);

CREATE TABLE `users` (
	`id` CHAR(36) NOT NULL PRIMARY KEY,
	`username` VARCHAR(45) NOT NULL,
	`password` VARCHAR(255) NOT NULL,
	`email` VARCHAR(255) NOT NULL,
	`created` DATETIME,
	`modified` DATETIME
);

The join table we mentioned identifies users that have been allowed access to specified files. The standards specify that a join table for a HABTM association is to be the tables in their plural form, joined with an underscore and listed in alphabetical order:

CREATE TABLE `uploads_users` (
  `id` CHAR(36) NOT NULL PRIMARY KEY,
  `upload_id` CHAR(36) NOT NULL,
  `user_id` CHAR(36) NOT NULL
);

Create your tables in a new database, and we’ll push on to baking the project and getting the basics running.

Ready, set… bake!

Bake is a special console command that ships with CakePHP, and is run from the console. In order for this to work effectively the cake/console path within the CakePHP package needs to be in your PATH environment variable. You can achieve this with the following in your shell: $ export PATH=”$PATH:/path/to/cakephp/cake/console” And of course you’ll need PHP available on the command line (usually available in a php-cli package, or similar). To create the skeleton structure for your project, run the following in your shell:

$ cake bake project fileshare
$ cd fileshare

Next, configure the app to connect to the database. Change the settings as shown in the following code in your config/database.php file to the appropriate settings for your databaseL

class DATABASE_CONFIG {
	var $default = array(
		'driver' => 'mysql',
		'persistent' => false,
		'host' => 'localhost',
		'login' => 'username',
		'password' => 'password',
		'database' => 'fileshare',
		'prefix' => '',
	);
}

Setting up the “default” connection is enough. And while we’re baking and having CakePHP handle all the hard work, lets bake the controllers, models and views to get the basis of our project in place.

$ cake bake all user
$ cake bake all upload

What we have at this stage is a completely ready-to-use website that associates users with many uploads and enables us to populate the database in an easy-to-use manner. But thus far, there’s no actual file upload capability, so we need to modify what CakePHP has baked for us to provide additional functionality processing the file uploads and to prevent people from adding and modifying other users’ information. Further to that, we want to secure the whole application so that only authenticated users can modify data.

Locking things down

We already have a ‘users’ table, and the user addition is working as part of the baking process if you browse to your application and append users to the URL. For example: http://localhost/fileshare/users. So what do we need to do? Well, passwords at this stage are being stored in cleartext, and we don’t seem to be asked to log in. Open up the app_controller.php file in the root of your project. This is an empty controller from which all the other controllers in the application inherit functionality. Anything we implement here will be used in all our controllers, so this is the perfect place to enforce logins. Add the Auth and Session components. Your AppController will now look like this:

<?php
class AppController extends Controller {
  var $components = array(‘Auth’, ‘Session’);
}
?>

If you try to refresh your users list, you’ll be presented with an error indicating that the login action doesn’t exist. If you look carefully, the URL has also been changed to /users/login. Fortunately all the juicy hard stuff has been implemented in CakePHP for us, so all we need to do is provide the action (function) on the controller, and a login form for users to view. Open up controllers/users_controller.php and add the login action:

function login() {
}

That’s not a mistake, it’s an empty function, and it’s all we need for authentication to log in on the controller side.

Before we get too ahead of ourselves, we need to ensure that we can register a user in case you have not already registered one. Since we’re about to complete the user authentication section, we’d be locked out of all functionality and if we didn’t make an exception for the user registration page, we’d never be able to get into our funky new system. Create a beforeFilter method on the users controller, and add the following to tell the Auth component that we’re allowed to visit the register page even if we have not yet logged in:

function beforeFilter() {
  $this->Auth->allow(‘add’);
  return parent::beforeFilter();
}

Create the login view in a new file: views/users/login.ctp, as described here:

<div>
<?php echo $this->Form->create('User');?>
	<fieldset>
 		<legend><?php __('Login'); ?></legend>
	<?php
	echo $this->Form->input('username');
	echo $this->Form->input('password');
	?>
	</fieldset>
<?php echo $this->Form->end(__('Submit', true));?>
</div>

Refresh the page that was giving an error message, and you’ll be presented with a login form. Notice that you will be allowed to visit the /users/add page, but everything else will be redirected to the /users/login page. Feel free at this point to register yourself a user. It will be useful in testing further points in the application. Take a moment to check out your database. You’ll notice that the password is hashed for us automatically. Awesome! It’s also handy to clean up some of the automatically generated fields and inputs that we won’t be using, to ensure that users only have access to things we permit. So remove the following input from both the user add and edit views in views/users/add.ctp and views/users/edit.ctp:

echo $this->Form->input(‘Upload’);

The user index is accessible until authentication is added.

Enabling file uploads

It’s high time we got some file uploading action happening. First up, let’s make an uploads directory under the project directory to place our uploaded files, then assign ownership to the user running your web server. On some distributions this user is www-data, on others it’s apache or www. You’ll need to specify the appropriate user for your system.

$ mkdir uploads
$ chown www-data uploads

Time to dive into some code! Let’s start by adjusting the upload add page to accept files, and store them in a safe manner. The bake process has generated a fairly good form for us, but we’re going to remove a couple of the automatically generated fields and replace them with a file upload field. The columns we defined in our database are primarily for automatic population. The file upload will provide all the data we need. Remove the filename, filesize and filemime inputs from the upload add view in views/uploads/add.ctp, and add in a file input. We didn’t create a column called file in the database, so CakePHP isn’t going to do all the fancy behind-the-scenes work for that field, and we also need to tell it what type that field needs to be for the file input to be generated correctly. The other small change we’re making is to remove the user_id input that CakePHP had generated for us. Instead, we’ll add some code in our controller to automatically assign files to the user who is currently logged in. Your form inputs should now look like this:

<?php echo $this->Form->create(‘Upload’, array(‘type’ => ‘file’));?>
  <fieldset>
     <legend><?php __(‘Add Upload’); ?></legend>
  <?php
  echo $this->Form->input(‘title’);
  echo $this->Form->input(‘description’);
  echo $this->Form->input(‘file’, array(‘type’ => ‘file’));
  echo $this->Form->input(‘User’);
  ?>
  </fieldset>
<?php echo $this->Form->end(__(‘Submit’, true));?>

Enabling file uploads is simple.

Processing the uploaded file

Sure, we’ve got a file in place, but we actually need to handle the file in some manner to show up an error when the file is not correctly uploaded, and to save it in our prepared writable uploads folder when it’s been completed successfully. For this we open up controllers/uploads_controller.php in the baked project, and modify the function add() to process the file if it’s available. On the third line of this function, the code attempts to save the model data. Modify the if statement to call a function that we’ll write in a moment called uploadFile(): if ($this->uploadFile() && $this->Upload->save($this->data)) {

Sounds easy enough, doesn’t it? Now let’s create the uploadFile() function in the same controller:

function uploadFile() {
  $file = $this->data[‘Upload’][‘file’];
  if ($file[‘error’] === UPLOAD_ERR_OK) {
    $id = String::uuid();
    if (move_uploaded_file($file[‘tmp_name’], APP.’uploads’.DS.$id)) {
      $this->data[‘Upload’][‘id’] = $id;
      $this->data[‘Upload’][‘user_id’] = $this->Auth->user(‘id’);
      $this->data[‘Upload’][‘filename’] = $file[‘name’];
      $this->data[‘Upload’][‘filesize’] = $file[‘size’];
      $this->data[‘Upload’][‘filemime’] = $file[‘type’];
      return true;
    }
  }
  return false;
}

Again, we’re keeping things simple. We upload the file, and if we’re able to move it successfully into place, we return true. In the process of doing this, we are manually generating an ID which we use as a safe filesystem name for storage. This eliminates any issues that users may attempt to introduce with weird and potentially system-damaging filenames that would otherwise be directly stored on your filesystem. Manually generating the UUID with String::uuid() removes this security hole, and ensures a safe file upload, while maintaining the original filename in the database to send to the user when downloading.

The next thing we’re going to integrate is the ability to download files. But before going too far, try adding a couple of files. You’ll see them successfully being added to the database, and if you look at the uploads directory we created, matching ID named files start appearing within. If you experience any issues at this point, ensure that your web server user has write access to the uploads directory.

The other cool thing we’re doing here is assigning the user with $this->Auth->user(‘id’) which is the ID of the currently logged-in user. Since we locked down the security earlier, we know that users need to be logged in to reach this page, so the value will always be present and valid.

Cleaning up associations

You’ll notice that we’ve doubled up on our associations for both the User and Upload model. Take for example the User model in models/user.php; CakePHP has generated a hasMany and a hasAndBelongsToMany association both with the index Upload. This just won’t do, because the clash in naming will cause incorrect data to output in the views. Change the hasAndBelongsToMany association in the User model to be SharedUpload. And similarly for the Upload model in models/upload.php, change the HABTM association to be SharedUser:

// User Model
var $hasAndBelongsToMany = array(
  ‘SharedUpload’ => array(
    ‘className’ => ‘Upload’,
    ...

// Upload Model
var $hasAndBelongsToMany = array(
  ‘SharedUser’ => array(
    ‘className’ => ‘User’,
      ..

In order for these association key changes to correctly render in the views, you’ll need to change the index referenced on the views in the related section at the bottom of the view indexes. In views/users/view.ctp, the following two lines:

<?php if (!empty($user[‘pload’])):?>
foreach ($user[‘Upload’] as $upload):

are changed to:

<?php if (!empty($user[‘SharedUpload’])):?>
foreach ($user[‘SharedUpload’] as $upload):

At this point you can register a new user, log in to the system, upload files and assign users. We’ve achieved a massive amount of functionality for minimal code and effort. Give the system a good test before moving on the the next step.

Viewing and downloading files

If you have played around with the navigation in the views we have already, you’ll have come across the view page for one of your uploaded files. It shows all the meta information about the file, but at this point you can’t retrieve the file itself. Let’s tweak a few things to enable downloads so we can get at the files. The first thing to do is add a link to the view file views/uploads/view.ctp. You can add this wherever you like (I prefer to add it at the bottom of the existing data):

<dt<?php if ($i % 2 == 0) echo $class;?>><?php __(‘Download’); ?></dt>
<dd<?php if ($i++ % 2 == 0) echo $class;?>>
  <?php echo $this->Html->link(__(‘Download’, true), array(‘action’ => ‘download’, $upload[‘Upload’][‘id’])); ?>

</dd>

With the link created, it’s time to get our hands dirty again and put together the action for the controller to handle the file download. Open up your UploadsController in controllers/uploads_controller.php one more time and add the following download function. This forces download, and returns the file to the user with the original filename that was present when the file was uploaded. Here’s the code:

function download($id = null) {
	if (!$id) {
		$this->Session->setFlash(__('Invalid id for upload', true));
		$this->redirect(array('action' => 'index'));
	}
	$this->Upload->bindModel(array('hasOne' => array('UploadsUser')));
	$upload = $this->Upload->find('first', array(
		'conditions' => array(
			'Upload.id' => $id,
			'OR' => array(
				'UploadsUser.user_id' => $this->Auth->user('id'),
				'Upload.user_id' => $this->Auth->user('id'),
			),
		)
	));
	if (!$upload) {
		$this->Session->setFlash(__('Invalid id for upload', true));
		$this->redirect(array('action' => 'index'));
	}
	$this->view = 'media';
	$filename = $upload['Upload']['filename'];
	$this->set(array(
		'id' => $upload['Upload']['id'],
		'name' => substr($filename, 0, strrpos($filename, '.')),
		'extension' => substr(strrchr($filename, '.'), 1),
		'path' => APP.'uploads'.DS,
		'download' => true,
	));
}

You can now try out your download link, and you’ll get the file being downloaded via your browser! There’s a fair bit going on in this function, but believe me, there’s far more being taken care of by CakePHP that you don’t need to worry about. We’re first inspecting the ID to ensure it was supplied. Next, we try to lookup an upload record from the database with that ID, and while we’re in there, we ensure that the ID of the upload is associated with the currently logged-in user, or that the file was originally uploaded by the user who is logged in. In either case, we are allowed access. If that query failed, the user is attempting to access a file to which they have not specifically been granted permission, so we redirect them to the index list of files.

Showing only what users can access

In order to make the file list make sense for all users, you’ll also need to modify the index() action on the Uploads controller, to perform similar filtering to show only the files that are permitted in the users rendered list, otherwise it’ll clog up with files they don’t actually have access to see! Adjust the index action thus:

function index() {
  $this->Upload->bindModel(array(‘hasOne’ => array(‘UploadsUser’)), false);
  $this->paginate = array(
    ‘conditions’ => array(
      ‘OR’ => array(
        ‘UploadsUser.user_id’ => $this->Auth->user(‘id’),
        ‘Upload.user_id’ => $this->Auth->user(‘id’),
      ),
    )
  );
  $this->set(‘uploads’, $this->paginate());
}

We’ve had to add the false parameter on the bindModel() call this time to ensure that the pagination result came out correctly. Pagination takes two separate database results to return the data. The first of these determines the number of elements in the table that match the query, and the second actually retrieve the data. The false parameter tells CakePHP to retain the binding beyond a single query. The simple rule, of course, is that if you are using bindModel and pagination, you need to add false on the end.

The view() action also benefits from the same filtering:

function view($id = null) {
  if (!$id) {
    $this->Session->setFlash(__(‘Invalid upload’, true));
$this->redirect(array(‘action’ => ‘index’));
  }

  $this->Upload->bindModel(array(‘hasOne’ => array(‘UploadsUser’)));
  $upload = $this->Upload->find(‘first’, array(
    ‘conditions’ => array(
      ‘Upload.id’ => $id,
      ‘OR’ => array(
        ‘UploadsUser.user_id’ => $this->Auth->user(‘id’),
        ‘Upload.user_id’ => $this->Auth->user(‘id’),
      ),
    )
  ));
  if (!$upload) {
    $this->Session->setFlash(__(‘Invalid upload’, true));
    $this->redirect(array(‘action’ => ‘index’));
  }
  $this->set(‘upload’, $upload);
}

Wrapping it up

The only last nicety that would be required to take this site live is a logout function. And I’ll be kind enough to give you the code to put on the UsersController for logout:

public function logout() {
  $this->redirect($this->Auth->logout());
}

There’s no view required, and redirection happens as soon as the user hits the /users/logout URL, after destroying the session and logging out the user.

So we’ve built a secure, file-uploading, multi-user sharing web application, and it’s only taken 20 minutes or so to get it all done. From here, you can add extra functionality such as thumbnail icons to preview content that users have uploaded, or a different sharing mechanism to select users without exposing the complete user list to everyone. You can also enable email notifications for users that you are sharing files with. I hope you’ve enjoyed this tutorial, and I hope it’s useful for you either as a case study, or as a deployable solution for client file sharing.

The additional link enables us to download files that have been uploaded.

very fast. Firstly choose which table being used every time for delete, insert or update make a list and always repair these tables.

after 15 days.

this is very good question for mysql interview best of luck hope this will help for your good career.

Prioritise your queries as LOW_PRIORITY, HIGH_PRIORITY, or DELAYED when it matters

Don’t use SELECT * unless you must

Use the EXPLAIN keyword to see how MySQL will execute your query – make sure your indexes are being used!

Load your data before adding indexes is faster than adding indexes first

Be wary of locks

Use –log-slow-queries to see where your tables can be optimised

Increase your buffer sizes so that MySQL can cache more

Use SHOW STATUS to make sure your MySQL server is in good condition

Don’t create indexes you aren’t going to use

Do as much as your filtering in SQL as you can

Indexes are good for reads, but bad for writes

Use OPTIMIZE TABLE and ANALYZE TABLE regularly

Create your tables with a fixed-table format if possible

Use the most efficient table type for each table

Use the best data type, including NOT NULL if appropriate – don’t rely on automatic type conversion

Use default values for INSERT when you can

Use temporary tables rather than heavy PHP work

SELECT foo IN (list, of, constants) is very fast

When joining tables, use numbers instead of strings if you can

once you optimize your php code then your applicationa and website will be very fast
this will make quality code. Hi php programmer don’t forget these rules if you want to
be good in php and want to work in MNC because all mnc and all good companies follow
these rules strictly even this is gud question for interview for php. best of luck.

What is the process for PHP code Optimisation.

Use the Zend Optimizer and a code cache

Use the comma operator to join arguments when calling echo

Priorities optimisation of tight loops for the most payback

Pre-increment where possible

Don’t rely on references without testing; they are rarely as effective as you’d think

Get a good understanding of how garbage collection works

Listen to all errors, big and small – they slow things down

Store a local pointer to an array element to save indexing into the array each time you need it

Compress your output to save network bandwidth

Try to avoid using PHP in CGI mode

Avoid calling the dl() function

Use persistent resource where appropriate

Optimise compilation of your PHP binary if possible

Avoid mod_access if you can

Don’t fret about Apache 2.0

As a last resort, try inlining function

All of friends I am going to share my Experience about the company and Programmer ,what I feel in last 7 Years and I work at 13

places (What was my position there Trainer, Programmer, Sr. Programmer and finally Team Lead) at some places I do the job on Saturday and Sunday.

What Programmer and Company Think.

Every Programmer Think his/her salary is low as per work they are doing but some freshers think when they get the job in company

after showing some fake experience Company is fool but he/she has no idea that the company know about that even some times I take

interview and I know this is fake company but the person who sited front of me is very talented and fast learner. That’s the reason we entertain.

Every Company always think We are paying more than programmer’s capability But the company show two different strategy First they will realized you to you are getting good salary here and you are the most quality programmer and once you reach your one year or 6 month there or when the times comes for increment then the company always try to demoralize you and will try to proof that you are not right person to get increment.and you will get frustrated and start thinking is really I am not good programmer.

But some exceptional company also available they give you more than you expect but when it happens. the case is when the third person is dealing then you get more salary in any company like the boss is not dealing the salary.

What Programmer should do at work place.

In the software company lots of people work so it’s a natural everybody will have different quality, culture and most is different

Thinking.

Programmers works depend on these three most important categories (quality, culture and Thinking).
If Programmer have good quality then they will do very good job and very good increment and appreciation from boss. If the

programmer quality is not good then they will start freelancing from the company and no doubt freelancing give money but programmer

always feel unsecured because they are doing some wrong with his/her profession.

I have seen most of the programmer do the freelancing at the work place but I felt that instead of doing freelancing at office programmer should concentrate on their work and project. or if you don’t have much work then you should start learning session to make your professional quality stronger.

How any programmer will feel secure in Company.

If you are good learner and like to study at home then you will feel always secure.This is main mantra to feel secure. Other than there are no any formula will work.

How to make good environment.

Once you join, then take some days for fluent interaction means take time to understand people see I have live example.

Don’t Talk personal thing to anybody.
Don’t talk bad about any people even ignore that people who always talks like that try to avoid politics.
Don’t make someone special behave same to everybody.
Always try to share your ideas to your boss and project manager Means always Open your mouth Don’t be Ideal.

In My career one of my best project manager is “SAHU SIR” I can’t disclose the company name. He is always look cool and he always appreciate your work and your honesty.

Most Important Don’t take quick DECISION in company for the people and JOB.

MOST PROFESSIONAL LINE

Great minds discuss ideas,average minds discuss events,small minds discuss about people….!! So what you want to be

Article By: Bagesh Singh
Email : bageshsingh@gmail.com
Highly COPYRIGHTED

But here is the catch, you may want to make sure curl connects to the server under the same session as the browser. So naturally you pass the session cookie through the curl system either by the cookie jar system, or through the query string in the path.

This is where you will get stuck. PHP will need write access to the same session file simultaneously!! causing serious hanging issues!

This is why you should close off your session before you make curl take a page snapshot!

These are the conditions for validation of the postal code of Canada.

1. There are six alphanumeric letters.
2. Alphabate and digits are alternate and first letter must be alphabate.
3. The alphabate shouldn’t contain letters “d”,”f”,”i”,”o”,”q” and “u”.

Postal code “A1B2c5” is a valid postal code whereas “A1f2cZ” or “1AC2E5” are invalid postal code of Canada.

//function to validate postal code of canada
function validateCanadaZip($zip_code)
{
 //function by Roshan Bhattara(http://roshanbh.com.np)
 if(preg_match("/^([a-ceghj-npr-tv-z]){1}[0-9]{1}[a-ceghj-npr-tv-z]{1}[0-9]{1}[a-ceghj-npr-tv-z]{1}[0-9]{1}$/i",$zip_code))
    return true;
 else
    return false;
}

Now, let’s look at the explanation of the regular expression inside the preg_match() to validate the postal code of Canada as specified by the above condition. As you might know that a Perl compatible regular expression enclosed within “/” sign. The “i” at the end of the expression refers that this comparison is case insensitive.As most of you know, “^”sign is the start of the regular expression and “$” represent the end of the regular expression. And there are three repeated expressions like “([a-ceghj-npr-tv-z]){1}[0-9]{1}”. Let me explain it, the expression “([a-ceghj-npr-tv-z]){1}” represents that there should be one alphabate which doesn’t contain “d”,”f”,”i”,”o”,”q” and “i”. Furthermore, the expression “[0-9]{1}” represents that there should be one digit.

The valid format of zip code of USA might be a five digit number like “12345” or in the format of 4 digit followed by first 5 digits like “12345-5434“.And, we need a function to validate the both kind of format of zip code.

Here is the function,

function validateUSAZip($zip_code)
{
  if(preg_match("/^([0-9]{5})(-[0-9]{4})?$/i",$zip_code))
    return true;
  else
    return false;
}

Now, let’s look at the explanation of the regular expression used in this function. A perl regular expression always starts with “/” and ends with “/” and “i” after closing “/” refers that the expression is “case insensitive”.As you know, “^” refers that, it is the beginning of the expression. And, the expression “([0-9]{5})” tells that there should be exactly 5 digits at the beginning of the expression. Furthermor

View Demo

HTML Code

<input type="text" name="quantity" id="quantity" /> <span id="errmsg"></span>

As you can see above, I’ve given the name and id of textbox to “quantity” in this example.This is the textbox which only accepts numbers (digits only). You can see “span” after textbox which is used to display the error message with fading effect using jQuery.

Javascript Code

First of all, we need to use jQuery library as we’re using the jquery’s function to accept only digits.

<script type="text/javascript" src="jquery.js"></script>

Now le’ts write the code in JavaScript using jQuery to accept only digits in textbox and displaying error with animation.

//when key is pressed in the textbox$("#quantity").keypress(function (e)
{
  //if the letter is not digit then display error and don't type anything
  if( e.which!=8 && e.which!=0 && (e.which<48 || e.which>57))
  {
    //display error message
    $("#errmsg").html("Digits Only").show().fadeOut("slow");
    return false;
  }
});

When the key is pressed, we’re using the key’s ASCII value to check which button is pressed. In first expression, delete, tab or backspace button is is checked and “8″ is the ASCII values of the Back-space. Digits are checked in the second expression. “48″ is the ASCII values of “0″ and “57″ is the ASCII values of “9″. The the ASCII values of the other digits lies between “48″ to “57″. And, if the key pressed values doesn’t lies withing these range, then we are displaying the error message with jQuery’s fading effect.

And, the “return false” statement means that this functions returns false values which means not to type anything on the text box.

Download Full Source Code