In the meantime the rest of the world as been moving ‘into the cloud’. Such web applications were once sluggish and clunky, but the simplicity of no user installation, universal availability and instant upgrades of the entire user base trumped all other considerations.

A year ago I delivered my fist web application. Guitar informs the user when their guitar was built and by whom, if they type in the serial number.  It is hardly complex, and there is no need for any great performance, but the result is rather neat. Behind the scenes there is a SQLITE database to store all the information about guitars and their makers, a PYTHON script to decode the serial numbers and find the exact information in the database, the WEB2PY framework to generate the dynamic web pages and a LIGHTTPD web server to communicate with the user.

Since then I have delivered several such applications, the most recent is MEDAIM which estimates the effect of a planned media advertising buy.

The big issue that crops up with web applications is configuring and maintaining a server to host them.  It is not clear to me the best way to do this.

For desktop applications I can provide an installer which the client can distribute to the end users.  Almost everyone is familiar and comfortable with this.  Configuring and maintaining a server for a web application is quite intimidating to anyone who has not done this before, and is a cost that was often not considered when planning the project.

MEDAIM is hosted on http://www.fluxflex.com which is ‘free’, but installation and maintenance is a hassle.  I originally hosted it on my own server, which is far more convenient but it so very hard to compete with ‘free’.

Suggestions for making this go smoother would be most welcome!

They use several different devices to measure the patient’s eyes ( an Autorefractor Keratometer ), the lenses ( a lensmeter ) and the improvement a lens gives to the patient’s vision ( a refractor ).

The data gathered about each patient from the first two devices are used to create an initial setting for the third.

Raven’s Point has developed a software system for INNOVA Medical Ophthalmics which gathers data from optometric measurement devices, stores the data for each patient from every source together in a database and downloads the data to the refractor when required.

RTLink is a client-server system. The clients, each communicating with one optometric device over a serial link, are linked by WiLAN to the database server which looks after all the data for the optometrist’s office in a SQLite database.

It took three years. Since one person upvoting an answer gives 10 points, this implies that on average someone liked one of my answers twice each week over those three years.

( Larry Niven’s science fiction stories feature a character named Chmee who is the alien ambassador to Earth.  His title, when translated into English, is Speaker-To-Animals )

• PowerHeater.  This application controls and records wind turbine blade production.  The strength of the composite materials used depends critically on a precise temperature profile imposed during a curing process lasting several days.  Hundreds of heaters, coolers, thermostats and temperature gauges are placed across the surface of the turbine blade, every one individually monitored, controlled and recorded by PowerHeater using the Modbus protocol.

• eCrew.  A modern sailboat has instruments measuring depth, wind speed and direction, and compass bearing.  Occasionally these readings are of vital importance, but usually the captain must watch wind and waves, sails and other sailboats, not the instruments.   eCrew monitors all the instruments using the NMEA protocol, warning when a critical situation arises.

• VisControl.  The chair of a state senate chamber recognizes one of the senators. When the senator begins to speak, one of three cameras has already swung into position and is webcasting the perfect image. VisControl stores over 50 preset positions for each camera, automatically selecting and moving the cameras into position whenever the speaker changes, using the VISCA protocol over RS232.

• Proteus.  A tiny submersible on the end of a long cable threads its way through a pipe and into a huge concrete oil storage container under the North Sea.  Once in position, sonar scans the interior looking for damage and silt build up.  Proteus controls and records the sonar, calculating a real time three dimensional picture.   Proprietary protocol over boosted RS232.

• SLReader.  A wireless detector is used to identify isotopes.  SLReader configures, monitors, and downloads data from the device using the ZigBee protocol.

• RTLink.  Connect the different instruments used to measure the optical properties of a patient’s eyes and eyeglasses, each with its own protocol, to a database server so the ophthalmic doctor can keep everything straight, helping to ensure that all the measurements are connected to the correct patients.

Wrong! If everyone else is co-operating, then some clever fellow will come along and take advantage. So now the game plan is obvious, refuse to co-operate and take advantage of everyone who is naively co-operating.

Stupid! This is so obvious that no-one will co-operate, will they? And, yes, everyone will suffer.

This is clever?

This is a famous dilemma, with all sorts of significant analogies in the real world from Mutually Assured Destruction to the Tragedy of the Commons to the evolution of ethics in a godless universe.

There is a very simple solution, though it only becomes perfectly obvious by using mathematical simulation.

The Nice Guy

Let’s build a player who always co-operates – returns true whenever asked for a response.

class cPlayerNiceGuy : cPlayerBase
{
public:
	cPlayerNiceGuy() : cPlayerBase( L"NiceGuy" ) {}
	bool Response( int , const cHistory& )
	{
		return true;
	}
		cPlayerBase * Reproduce() { return new cPlayerNiceGuy; }

};

Now build an ecology composed only of nice guys.

	cEcology ecology;
	ecology.Add( (cPlayerBase *)new cPlayerNiceGuy() );
	ecology.Add( (cPlayerBase *)new cPlayerNiceGuy() );
	ecology.Add( (cPlayerBase *)new cPlayerNiceGuy() );
	ecology.Add( (cPlayerBase *)new cPlayerNiceGuy() );
	ecology.Add( (cPlayerBase *)new cPlayerNiceGuy() );
	ecology.Add( (cPlayerBase *)new cPlayerNiceGuy() );
	ecology.Add( (cPlayerBase *)new cPlayerNiceGuy() );

The result of this simulation is:

NiceGuy scored 1260
NiceGuy scored 1260
NiceGuy scored 1260
NiceGuy scored 1260
NiceGuy scored 1260
NiceGuy scored 1260
NiceGuy scored 1260

As you would expect, everyone does equally well.

The Black Hat

Now lets introduce someone who tries to take advantage of all these nice guys, someone who always return false when asked for a response

class cPlayerBlackHat : cPlayerBase
{
public:
	cPlayerBlackHat() : cPlayerBase( L"BlackHat" ) {}
	bool Response( int , const cHistory& )
	{
		return false;
	}
	cPlayerBase * Reproduce() { return new cPlayerBlackHat; }

};

	cEcology ecology;
	ecology.Add((cPlayerBase *)new cPlayerNiceGuy() );
	ecology.Add((cPlayerBase *)new cPlayerNiceGuy() );
	ecology.Add((cPlayerBase *)new cPlayerNiceGuy() );
	ecology.Add((cPlayerBase *)new cPlayerNiceGuy() );
	ecology.Add((cPlayerBase *)new cPlayerNiceGuy() );
	ecology.Add((cPlayerBase *)new cPlayerNiceGuy() );
	ecology.Add((cPlayerBase *)new cPlayerBlackHat() );

BlackHat scored 2100
NiceGuy scored 1080
NiceGuy scored 1080
NiceGuy scored 1080
NiceGuy scored 1080
NiceGuy scored 1080
NiceGuy scored 1080

Well now, the Black Hat has gained enormously at the expense of all the nice guys!

Darwin

So now we introduce a little ‘Darwinian Evolution’ – we kill off the lowest scoring player and allow the highest scorer to reproduce.

After a few generations, we have these results:

BlackHat scored 1140
BlackHat scored 1140
BlackHat scored 1140
BlackHat scored 1140
BlackHat scored 1140
NiceGuy scored 360
NiceGuy scored 360

The non co-operative players have multiplied like rabbits and the few remaining co-operators are having a perfectly miserable time of it.

But notice that there are so few co-operators left to take advantage of that the Black Hats are now scoring LESS than the co-operators did when they were the only players.

Tit For Tat

Someone who initially co-operates, and then returns whatever the other did last time, tit for tat

class cPlayerTitForTat : cPlayerBase
{
public:
	cPlayerTitForTat() : cPlayerBase( L"TitForTat" ) {}
	bool Response( int MyRole, const cHistory& history )
	{
		if( ! history.size() )
			return true;
		return history.GetPartnerLastRespone( MyRole );
	}
	cPlayerBase * Reproduce() { return new cPlayerTitForTat; }

};
<verbatim>

Start with an even mixture of all the different players

<verbatim>
	ecology.Add( (cPlayerBase *)new cPlayerRandom() );
	ecology.Add((cPlayerBase *)new cPlayerBlackHat() );
	ecology.Add((cPlayerBase *)new cPlayerTitForTat() );
	ecology.Add((cPlayerBase *)new cPlayerNiceGuy() );
	ecology.Add( (cPlayerBase *)new cPlayerRandom() );
	ecology.Add((cPlayerBase *)new cPlayerBlackHat() );
	ecology.Add((cPlayerBase *)new cPlayerTitForTat() );
	ecology.Add((cPlayerBase *)new cPlayerNiceGuy() );

The results after a few generations

TitForTat scored 650
TitForTat scored 650
TitForTat scored 650
BlackHat scored 444
BlackHat scored 444
BlackHat scored 444
BlackHat scored 444

The naive co-operators go quickly extinct, but the tit-for-tats are easily dominating the black hats. A few more generations and the Black hats will be exinct and the tit-for-tats will settle into a pure co-operative strategy, scoring as much as the naive co-operators ever did.

It is fun to try different combinations of starting populations and try to come up with a strategy that does better than tit-for-tat in a mixed population.

To do this, you will need a basic understanding of C++ programming and the code you can download from this repository.

You know what would be nice?  A way to self-document a database.  The documentation should be contained in the database itself, so it can move with the database, grow with the database, and keep pace with database engine technology and popular documentation presentation.

I would like something like Doxygen for source code, but for a database.  Doxygen uses comments with a specified format, so that when the source code is read by the Doxygen application, pretty and up to data documentation is generated automatically.  The comments can be maintained in the normal course of editing the code, using any code editor without having to worry about special applications, but whenever required Doxygen can be used to generate the documentation for the latest code.

So, could we add a special table to our database which contains documentation of the other tables?  A table that can by updated by any database management tool, even raw SQL, but when read by a special application, will generate the documentation.

I mostly use SQLite for my application databases.  Paweł Salawa offers a nice SQLite database management tool SQLite Studio.  The Studio is open source, written in TCL and has a sophisticated plugin system, so it was easy for me to add what I needed.

A simple example:

Suppose you have a database with the following table

CREATE TABLE config ( pro, KEY );

Now add a new table to document this, plus any other tables.

CREATE TABLE __sqlite_studio_doc ( desc, _table, _column );

Now add the documentation to the new table

desc,   _table,   _column
True if PRO designer is running,   config,   pro
The license key,   config,   KEY
Stores configuration settings,  config,  __sqlite_studio_table

The special _column value, __sqlite_studio_table, is used for the documentation for the table itself.

Pretty simple? Well, it is if you are familiar with maintaining a SQL database.  ( If you are not, why are you reading this? )

Now to generate the documentation.

Install SQLite Studio

Install the new export plugin.  ( Download link  to sqlitestudio-2.0.13\src\plugins\export )

Run the new export plugin HTML+DOC on your database.

The output will look like this, when viewed in a browser:

A noncompete contract prevents employees or consultants from working for a competitor to their employer or client for a period, often as long as two years, after the employment or contract ends.  No compensation for this restriction is ever offered.  A list of specific competitors is not defined, so it is impossible to tell how wide or narrow the restriction might be until the lawyers start calling.

I was once offered a one month contract, if I signed a two year noncompete contract.  The company was a startup that had not been in existence for a year.  They would not budge on this, so I turned down the work.

This issue is currently being actively discussed in the US state of Massachusetts.  This article Some common sense on noncompete clauses – Boston.com by  Scott Kirsner explains why noncompetes are being considered harmful both to employees and to community productivity and prosperity. ( A follow-up article by the same writer, is extended and with a rich collection of links to other resources )

Ten years ago Joel Spolsky wrote this column on noncompetes and other evils that often hide in Non-Disclosure Agreements (NDAs).   Some things change slowly in this business.

It is not very often that I am asked to sign a noncompete, but it can be awkward.  The early stages of contract negotiation are delicate.  I am hoping that posting this now, while there are no negotiations underway, will make things more straightforward.  My objection is not to your noncompete clause, but to everyone’s!

class cMyClass {
  boost::mutex myMutex;
  cSomeClass A;
public:
  cSomeClass getA() {
    boost::mutex::scoped_lock lock( myMutex );
    return A;
  }
};

The problem is that this makes the class non-copyable. This is important, especially if you want to store objects of the class in a container.

I can make things work by making the mutex a static.

class cMyClass {
  static boost::mutex myMutex;
  cSomeClass A;
public:
  cSomeClass getA() {
    boost::mutex::scoped_lock lock( myMutex );
    return A;
  }
};

However, this means that every instance of the class blocks when any other instance is being accessed, because they all share the same mutex.

Theoretically, a class containing a non-static mutex can be made copyable by hand coding the copy constructor and assignment operator so as to leave out the mutex. However, this is difficult and tedious to do properly, especially for a class with a large number of attributes that frequently change during development.

If a static mutex that blocks access to all instances of the class when one is blocked is not acceptable, then the best and simplest approach is to maintain the mutexes outside the class. It might seem unfortunate to expose the inner workings of a class in this way, but the alternatives are way more complex, hence unreliable, and I frequently find significant optimizations when the mutexes are handled at the level of the code accessing the class.

Theoretically this question is dead simple. Start at the point and draw a line parallel to the x-axis and continue until you reach infinity ( or as near to infinity as makes any sense ). As you go, count the occasions when your line crosses an edge of the polygon. If the line crosses a polygon edge an odd number of times then the point was inside but if it crosses an even number of times then it must have been outside.

To get a feeling for how this works, imagine a simple square. From a point inside, any line towards infinity must cross an edge once as it leaves the box. From a point outside the line may never touch the box ( 0 is considered to be an even number ) or it may enter the box and then leave it, for two crossings.

Implementing this simple algorithm in computer code is quite a challenge, especially if you care about performance. When you have some code that seems to work, testing all the special cases could consume days. What if the point is on an edge? On a corner? What if the polygon is not simple, but has holes and several seperate components?

“I have seen farther by standing on the shoulders of giants.” _ Isaac Newton

Many years ago an elegant little piece of code to determine if a point was inside a polygon was published by W. Randolph Franklin. You can find it here with a discussion of how to use it properly, but here is the code itself, all 7 lines of it:

int pnpoly(int nvert, float *vertx, float *verty, float testx, float testy)
{
  int i, j, c = 0;
  for (i = 0, j = nvert-1; i testy) != (verty[j] > testy)) 
       if ( ((verty[i]>testy) != (verty[j]>testy)) &&
            (testx < (vertx[j]-vertx[i]) * (testy-verty[i]) / (verty[j]-verty[i]) + vertx[i]) )
       c = !c;
  }
  return c;
}

Isn’t this quite wonderful? Well, if you have ever tried to code the point inside a polygon problem, you would think it was just outstanding.

The snag is that it uses an ancient dialect of the C programming language, specifically arrays. Arrays are horrible things, which generate endless bugs, off-by-one bugs and out-of-bounds bugs in particular.

Modern code avoids all these bugs ever occurring by using standard template library vectors. So I have taken the liberty of translating Franklin’s code into modern C++

/**

  Is a point inside the boundary

  @param[in] point  the point being tested

  @return 1 if the point is inside, 0 otherwise

  This code is modified James Bremner, to use the STL vector, from that of W. Randolph Franklin
  given here  http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html

  */
int cBoundary::IsInside( c2d point ) const
{
	int c = 0;
	vector<c2d>::const_iterator j = myBoundary.end()-1;
	for ( vector<c2d>::const_iterator i= myBoundary.begin();
		i != myBoundary.end(); j = i++ )
	{
		if( (( i->y > point.y ) != ( j->y > point.y )) &&
			(point.x < ( j->x - i->x ) * ( point.y - i->y ) / ( j->y - i->y ) + i->x ) )
			c  = ! c;
	}
	return c;

}

This the Raven’s Point mission statement. What does it mean? Partly it means that I specialize in delivering more quickly than the competition individually designed and coded software that is carefully tested and documented.

It also means that the programs I deliver run extremely fast, making the best use of optimizing compilers and high speed multi-core hardware.

I enjoy re-arranging computer code so that it goes faster.

Re-arranging code is dangerous. It is very easy to break something that was previously working. An effective test framework and a good set of regression tests are vital to prevent one step forward causing ten steps backward. No-one needs the wrong results reached ten times faster.

Re-arranging code is also seductive. Even if you do not do any harm, you can spend a lot of time achieving nothing. It usually turns out that a program spends most of its time executing a very few lines of code, but it can be very difficult to guess which lines these are going to be. Before optimizing, it is necessary to measure carefully and find exactly where the bottleneck is that will repay being optimized.

::raven::set::cRunWatch is a code timing profiler which can tell exactly how long a program spends executing every piece of code.

It is just two files, so it is easy to integrate with your projects, and requires adding exactly one line to instrument a piece of code.

To start profiling:

raven::set::cRunWatch::Start();

Notes:
*  This can be done anywhere, but usually early in the main function.
*  This can be called without creating an instance of the profiler.
*  If not called, all cRunWatch methods become no-ops
*  If called with a zero parameter, all cRunWatch methods become no-ops.

To profile a code scope:

raven::set::cRunWatch runwatch("<unique name of scope>");

Notes:
*  This should be done as the first line of the scope.
*  The scope is usually a function, but can be any pair of curly braces {}

To write a report to standard output:

raven::set::cRunWatch::Report();

Notes:
*  This can be done anywhere, but usually at the end of the main function.
*  This can be called without creating an instance of the profiler.

Example of Use

void highly_optimised_subroutine()
{
raven::set::cRunWatch runwatch("highly_optimised_subroutine");
Sleep( 2 );
}

void badly_written_function()
{
raven::set::cRunWatch runwatch("badly_written_function");
for (int k = 1; k < 1000; k++ )
{
highly_optimised_subroutine();
}
}

void well_written_function()
{
raven::set::cRunWatch runwatch("well_written_function");
for (int k = 1; k < 10; k++ )
{
highly_optimised_subroutine();
}
}

int _tmain(int argc, _TCHAR* argv[])
{
raven::set::cRunWatch::Start();

well_written_function();
badly_written_function();

raven::set::cRunWatch::Report();

return 0;
}

Report produced:

raven::set::cRunWatch code timing profile
Scope                          Calls   Mean (secs)           Total
highly_optimised_subroutine     1008      0.002923        2.946213
badly_written_function             1      2.926662        2.926662
well_written_function              1      0.026161        0.026161

You can obtain raven::Set::cRunWatch from here.