This example simply takes the array and writes it to a CSV file:

//Example array
$info = array(1, 2, 3, 4, 5); 

//Open a new file
$filehandler = fopen("test.csv", "w");

//Call the fputcsv method
fputcsv($filehandler, $info);

For those not familiar with different search or optimization methods…there are many out there. No, no I’m not going to leave it at that. The in_array function is a linear search or sequential search, meaning it starts at the top of the array and goes to the bottom checking for a match. See the issue? If I’m looking for a value that lives at the bottom of the array then I have to wait a good bit (well for a programmer’s perspective) for the search to complete. So what is a better solution? The binary search.

The binary search works almost exactly like the “High, Low” game. You ask whether the search value is in 2 sets of numbers and it will tell you higher or lower. This seems simple enough, but you must remember this small detail: the set must be in order. Otherwise, the search will get lost because it may hit a smaller number while searching in an upper set. The reality of this is that most over our data comes from SQL queries which means guess what? We can already put our data in order.

Here is the code in PHP:

function binarySearch($elem, $array)
{
   $top = sizeof($array) -1;
   $bot = 0;

   while($top >= $bot)
   {
      $p = floor(($top + $bot) / 2);
      if ($array[$p] < $elem) $bot = $p + 1;
      elseif ($array[$p] > $elem) $top = $p - 1;
      else return TRUE;
   }

   return FALSE;
}

$handle = fopen("test.csv", "r");

while (($data = fgetcsv($handle, 5000, ",")) !== FALSE) {

}

$myArray = array_merge($myArray);

array_filter($myArray, array("myClassName", "myCallbackMethod"));

No Documentation

One of the key features of the Agile methodologies is that documentation is kept to a minimum in order to produce results quickly. This can cause a problem in several ways. First, the client who receives the product is left with little to follow when it comes to maintaining or using the product. Secondly, the developers who are placed on the project, say mid-development, have little to go by when being introduced to the code and therefore, have a huge learning curve to overcome.

No Well Defined Plan

If the waterfall is a straight free fall then the agile process is a hurricane. Being flexible doesn’t always mean getting things done correctly or the most efficient. When business plans change it is not always the easiest for a development team. This can mean that something simple bloats into something huge resulting in a massive overhaul requiring untold amount of time. Likewise, not having a well defined plan to start with can lead to the developer not knowing exactly what the client wants and thus, wasting time building something that the client, in the end, may or may not have wanted.

The Good News

Using the Agile development process can be a good thing given that the fore-mentioned items are taken care of. Having a decent starting plan and understanding of where you want a project to go greatly mitigates turn around time when small details wished to be changed. Building on that is the creation of documentation. If creation of documentation becomes a story for one of the cycles it will make life easier rather than after the project is complete trying to generate documentation for a 3 or 4 year project.

This is a callback function to filter the length of the search criteria to only those terms larger than three characters.

function criteriaLength($criteria){

	if(strlen($criteria) >= 3){

		return true;

	}else{

		return false;

	}
}

Below is the search engine itself, that takes a string criteria and a comma separated list for the search fields.

 function search($criterion, $searchFields){

	//Trim the whitespace from the $criteria
	$criterion = trim($criterion);
	$criterion = explode(" ", $criterion);

	//Filter the criteria for specific length
	$criterion = array_filter($criterion, "criteriaLength");

	//Reset the array index after the filter
	$criterion = array_merge($criterion);

	//Check to see if a search criteria exists
	if(count($criterion) > 0){

	//Explode the criterion to get the search terms
	$numCriteria = count($criterion);

	//Generate SQL Query to search base on fields
	$query = "";

	//Check if there are search fields
	if($searchFields = explode(",",$searchFields)){

	//Explode the search fields string based on commas
	$numFields = count($searchFields);

	//Loop over each field to be aliased
	for($i = 0; $i < $numFields; $i++){

		//Alias the searchfields arrays to match the table structure
		switch($searchFields[$i]){
			case "firstname":
			 $searchFields[$i] = "";
			break;
			case "lastname":
				$searchFields[$i] = "";
				break;
			case "email":
				$searchFields[$i] = "";
				break;
			case "dob":
				$searchFields[$i] = "";
				break;
			case "username":
				$searchFields[$i] = "";
				break;
			case "all":
				//Manually set the columns to be searched on if none were defined
				$searchFields[0] = "";
				$searchFields[1] = "";
				$searchFields[2] = "";
				$searchFields[3] = "";
				$searchFields[4] = "";
				$numFields = count($searchFields);
				break;
                       default:
		}
	}

	}else{

	//Create the search fields array if since there were no search fields defined
	$searchFields = array();

	//Manually set the columns to be searched on
	$searchFields[0] = "";
	$searchFields[1] = "";
	$searchFields[2] = "";
	$searchFields[3] = "";
	$searchFields[4] = "";

	//Get the number of elements in the
	$numFields = count($searchFields);
	}

			//Loop over criteria to generate like statements for each search field
			for($a = 0; $a < $numCriteria; $a++){

				for($i = 0; $i < $numFields; $i++){

					$query = $query." $searchFields[$i] LIKE  '$criterion[$a]%' ";

					//Add OR statements to end of each like, except last one
					if($i != $numFields - 1){

						$query = $query." OR ";
					}
				}

				//Add OR statements to end of each like for the criteria, except last one
				if($a != $numCriteria - 1){
					$query = $query." OR ";
				}
			}

		$query = $query." ORDER BY (";

		//Loop over criteria again, this time to generate case statements in order to calculate relevance
		for($a = 0; $a < $numCriteria; $a++){

				for($i = 0; $i < $numFields; $i++){ 					 					$query = $query." ( CASE WHEN $searchFields[$i] LIKE  '$criterion[$a]%' THEN 1 ELSE 0 END ) "; 					 					//Add + statements to end of each like, except last one					 					if($i != $numFields - 1){ 						 						$query = $query." + "; 					} 				} 				 				//Add + statements to end of each like for the criteria, except last one 				if($a != $numCriteria - 1){ 					$query = $query." + "; 				} 			} 		$query = $query.") DESC"; 		print_r($query); 	 		/* 	 		//Open Global mySQLi Connection 		global $conn; 		 		if ($conn->errno()){

			$returnData = $conn->error(); 

		}else{

			//Clean the query string
			$query = $conn->clean($query);

			//Execute the query and return result set
			if($result = $conn->query($query)){

				//Get an associative array from the result set
				$returnData = $result->fetch_array(MYSQLI_ASSOC); ;

			}else{

				$returnData = false;

			}
		}
	*/
	}else{

		$returnData = false;

	}

	return $returnData;

}

ORDER BY (
( CASE WHEN column_name LIKE  'criteria'
THEN 1
ELSE 0
END )
+
( CASE WHEN column_name2 LIKE  'criteria2'
THEN 1
ELSE 0
END )) DESC

Speed

When it comes to recording on a computer there should be only one word: speed. Speed will be your friend and latency your nemesis. Have you ever tried recording and you throw down a few tracks then go to lay down your amazing solo and then listen back to hear that your shredding skills seem to be milliseconds off the chord changes? Enter latency. It occurs when the computer tries to take your analog input signals (vocals, guitar, drums) and convert them to a digital signal. The faster the computer can do this process the better your recording experience will be.

Your worries don’t stop there though. Processing the analog signal is half the battle, well, maybe half. Once the digital signal has been created there are numerous things that occur. First, you need to physically record the signal to the hard drive. Again, latency can creep up again if computer is forced to use a significant about of RAM to buffer the writing of the signal to the hard drive. Second, what about all those crazy effects you have running like you auto vox? They take your audio signal and process it again. So take a guess what you’ll need to accomplish this? More speed. Finally, if you wish to monitor output/input while recording you are asking the most from your computer. In short you are telling it to do everything previously mention and then output the result at the same time. In the past this would have been catastrophic to most machines, but we live in the 21st century right?

Firewire

I know I will get a lot of complaints about this one and many will want to argue this, but Firewire is faster. USB 2.0 is grand and is fine for your mouse, but we’re not talking mice, we’re talking elephants. Firewire comes in two flavors 400 and 800. Firewire 800 is what you want if you can get it. It has potential to send data at 800Mb/s compared to 400Mb/s with Firewire 400. Notice the top transfer rate for USB 2.0 is 480Mb/s. This isn’t the only reason Firewire is faster, a big reason is how Firewire handles the data. Firewire is built on a “Peer to Peer” architecture which allows the individual peripherals to manage any conflicts. USB forces the computer to manage conflicts, which forces the use of processor cycles thus hindering the performance of your computer.

RAM

Recording is very demanding of a computer and although much of it can be handled by the processor itself there is a high demand for RAM to take care of helping out with plugins and effects. It also contributes greatly to handling live audio data when recording most often when the CPU is under-powered. Needless to say you are going to want to have as much RAM as you can afford. For light demos, running very few tracks and effects, 1 gigabyte of RAM is a minimum. From here I would suggest at least 4 gigabytes to handle most of your needs such as drum machines, live monitoring, and virtual machines. Again, being capable of holding more is simply a bonus to performance.

Hard Drive

Go big, fast or go home is the name of the game. Recording high quality audio means using a lot of storage space. Reducing the load on the CPU and RAM means getting the data written to the hard drive as fast as possible. Taking it a step forward, use an external hard drive while recording. The reasoning is quite simple: why try to read and write from the same drive at the same time? It doesn’t make any sense. The hard drive in your computer is the same drive that is running your audio application, effects, etc. Trying to write to it at the same time is not going to help your performance. Therefore, isolate it in the process of recording by simply writing to the external hard drive. You will notice you need smaller buffers and latency time will decrease. As for specs, try to use , again, a firewire hard drive and something with high RPM’s (7200+) or solid state (no spinning required.)

Audio Devices

On the market today there are many options when it comes to audio recording devices. First, let me say use Firewire. Next, you will want to determine how many tracks you would like to record simultaneously. For simple singer/songwriter just a few tracks 2-4 should do fine. If you plan to record full bands then I would suggest 8-16 tracks to account for mics for drums and the rest of the band. Some devices have mixers built in while others will have simple gain/volume controls, the preference is up to you. Again, the more tracks you wish to record simultaneously the more powerful computer rig you will need.