A couple of easy sort algorithms for you. Look ma, no array subscripts! C is the shit, kiddies!

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define ELEMENTS 10
#define ARRAY_ELEMENT_COUNT(array) (sizeof(array)/sizeof(array[0]))

//type-independent malloc
void *MyMalloc(size_t size)
{
	void *vp;
	
	if ((vp = malloc(size)) == NULL)
	{
		fputs("Cannot allocate memory for malloc.n",stderr);
		exit(EXIT_FAILURE);
	}

	return(vp);
}

//swap void pointers
void SwapElements(void *pa,void *pb,size_t size)
{
	//temp void pointer to hold an element to swap
	void *tmp = MyMalloc(size);
	
	//use memcpy to perform the swaps
	memcpy(tmp,pa,size);
	memcpy(pa,pb,size);
	memcpy(pb,tmp,size);
	
	free(tmp);
}

//bubble sort implementation, fancy-style.
void BubbleSort(float *first,size_t size)
{
	float *current_offset,*current,*last = &first[size - 1];
	int flag_swap;
	
	do
	{
		for (flag_swap=0,current = first; current 		{
			//set a pointer to pointer to current element of array
			current_offset = current;
		
			//increment the temp pointer
			current_offset++;
		
			//compare current element and current[1]
			if (*current > *current_offset)
			{
				//cast to void pointers and swap
				SwapElements(current,current_offset,sizeof(float));
				flag_swap = 1;	
			}
		
		}
	}	
	while(flag_swap);
}

//just for fun
void ShuttleSort(float *first,size_t size)
{
	float *current_offset,*current,*back,*last = &first[size - 1];

	for (current = first; current 	{
		current_offset = current;
		current_offset++;
		
		if (*current > *current_offset)
			SwapElements(current,current_offset,sizeof(float));
		
		for (back = current; back > first; --back)
		{
			current_offset = back;
			current_offset--;
			
			if (*back 				SwapElements(back,current_offset,sizeof(float));
			else
				break;
		}
	}
}

int main()
{
	int i;
	float arrToSort[ELEMENTS];
	
	for (i = 0;i 	{
		puts("Input a floating point number:");
		scanf("%f",&arrToSort[i]);
	}
	
	//BubbleSort(arrToSort,ARRAY_ELEMENT_COUNT(arrToSort));
	ShuttleSort(arrToSort,ARRAY_ELEMENT_COUNT(arrToSort));

	puts("------------------------");
	puts("Output of sorted array:");

	for (i = 0;i 		printf("%fn",arrToSort[i]);

	return(EXIT_SUCCESS);
}

Working for a public company, I am able to see the other side of the tech investment equation. Our company needs investors to grow. But on the other hand, unhappy investors can actually hinder growth.

The problems with many individual and institutional investors are complex, but her’s a couple bullet point that can hopefully help you to spot the pitfalls and safely make money off tech stocks.

* It’s not the 70’s (or the 90’s) anymore.
There was a time, when all of a sudden, a whole bunch of companies came out of nowhere and created technologies that changed the world. The first wave of tech created the HP’s,IBM’s,Apples,Suns, and Microsoft’s of the world. Anyone sitting on those shares today is sitting on pure gold. If you are interested in trading in these kind of stocks check out this resource from SoFi

Similarly, the late 90’s internet boom saw the simultaneous birth of Ebay, Amazon, and Yahoo, which made a lot of money for a lot of people.

The danger here, is that many people seem to think that the ‘next big thing’ is just around the corner. Fact is, it’s most likely not. Technology is like any product, it takes years of slow growth and refinement before it hits the mainstream.

The key to knowing what the ‘next big thing’ is, is described in the next item.

* Be in the Know
The Internet didn’t invent itself. It grew slowly, and somewhat quietly. By the time it had hit mainstream, a mad dash was on to own a piece of these young companies.

If you had a friend in the business, you probably knew what was going on. If you had the foresight to see it’s potential, you probably did quite well for yourself.

The point here is, if you invest in tech, read the trade rags. Know what’s going on. The major media won’t be able to keep you informed. That leads us into our next point.

*Watch our for Market Trends
Analysts, journalists, and armchair brokers love trend-spotting. and Why not? It’s fun, just pick an industry, line up the charts, and watch.

The problem is, that many tech sectors, particularly in software, are not well-defined enough to be judged as a trend indicator. This is due to the great variation in the potential vs current valuation of any company at a given time.

Many investors see smaller companies with weaker bottom lines as shaky, but do not understand fundementals of the business, such as the margin on the product or the maturity of the sector.

As a result, innovators with poor margins and me-toos with identical products often dilute the trends and create misleading indicators of the value of a sector.

There is no substitute for homework, the title of our next section.

* Do your Homework
Know the facts. Know the financials, know the share dilution, know the executive track record. Call the IR people if you can. Familiarize yourself with the product. Know the history of the product, know the history of the company.