Our General Approach To Programming

Use Of Layered Abstractions

The general approach that we use for developing code employs layered abstractions. With this approach, protocols and strategies are implemented at the top layers. Tactics such as data management and hardware interfacing are implemented at the bottom layers.

In this section, you find a samples of code that utilize two layers. For example, the C/C++ example demonstrates to you a control thread and a data manager as two layers. At the top layer, you find a message server thread. This thread implements the strategy of reading a message and responding to the message. This layer interacts with a lower layer that handles all message mechanics: reading from the queue and unpacking data from the message structure.

Look at this code. At the strategic thread layer, you see readable code with clearly identifiable logic. Within the tactical message layer, you see interactions with the Windows thread message queue and all sorts of explicit pointer dereferencing.

We use this same layered approach on every kind of software that we develop. We even use this approach for Windows NT device drivers.

Benefits to this approach are ease in debugging and ease in modification. You obtain these benefits by separation of control and data management.

Table Driven Code

Anyone who develops software knows that software requirements always change. You want to add new features to augment your software based upon user feedback and request.

In order to provide flexible software, we heavily utilize table-driven implementations. By emphasizing tables, we can often add major new features to a piece of software simply by incorporating new data into the tables.

Using tables usually results in code that is more compact, performs better, and is easier to debug.

Reusable Templates And Libraries

Over the past years, we have developed a large set of frameworks and libraries. These reusable components enable us to implement your application under an agreed upon schedule.

Templates and libraries are easily modified, especially when implemented using a combination of layered abstractions and table driven coding approaches.