Development - Paragon Bit Foundry

Go to content


Development Techniques
Code Reuse
Code reuse is a hallmark of great software, and it is also a central theme at Paragon Bit Foundry.  Our applications have been crafted utilizing decades of professional software development experience, all the way from assembly language to C, and then from C++ to C#.  Development over the course of 30+ years on both Apple and Windows platforms has created a robust set of reusable source code modules that form the foundation of all PBF applications.

This ever-expanding library currently consists of over 200 object-oriented classes, and forms a robust platform that allows new applications to be developed quickly and reliably.  All additions and updates to a common class are immediately available to all PBF applications, and this fosters a welcome consistency across all of our software products.

Self-Commenting Code
Often overlooked by beginning developers, our proven source code is built to stand the test of time by incorporating the practice of "self-commenting" method, property and variable names.  These identifiers are typically longer than what may be usually expected, since abbreviations that are too short can lose their original meaning over time.  Names that clearly state the purpose of variables can describe the purpose of a given part of code in a very natural manner while the developer reads through it.  Further, sometimes a decade or more can pass between updates to a given module, so extensive in-line comment documentation is essential to quickly identify a given method’s purpose and to enhance its functionality.

Commenting the Comments
We also do not stop at simply creating descriptive identifier names to serve all of our commenting needs.  The concept of "commenting the comments" adds another important layer on top of self-commenting identifiers, where a brief description of the purpose of a given set of lines is provided as well.  Where the self-commenting identifiers and actual lines of code show what the source code is doing, proper comments explain what the source code should be doing.  Ideally, these two ideas work in concert and one reinforces the other.  When they do not match each other, this is usually a telltale sign of a bug, and the developer will more easily be able to correct the code.

It is important to realize that comments are not written for today, but rather they are written for tomorrow.  While initially creating an area of source code, the developer has the complete purpose clearly in mind, the code appears obvious, and taking the time to write comments may seem like a needless luxury.  As time passes, however, even the developer herself can forget the original intention of the source code, and having to revisit it without proper comments can feel as if they are seeing the code for the very first time.  Paragon Bit Foundry believes in our somewhat tongue-in-cheek maxim of “the worst source code you will see is your own code from six months ago”, so frequent comments are not just a luxury, they are an essential part of creating great and lasting software.

Divide and Conquer
Another important development technique that is used in our solutions is to create many small methods as opposed to a few large methods for a given application.  Small methods, which may consist of a handful of lines or even just a single line, are created that perform a single task and do that task well.  Large tasks are divided into many small methods, and often several of these methods can be migrated to the common library since they can be utilized by other applications.

Large methods are avoided whenever possible, and if necessary, they are simply lists of calls to the smaller methods. Large methods have a tendency to grow and perform multiple tasks, with undesired side effects being introduced along the way.  This, in turn, often leads to code that is confusing to read and more complicated than it needs to be.  The simplest answer to a given problem is usually the correct one, and preferring smaller methods over larger ones is a valuable step in this direction.

Source code style
Line spacing and proper indenting is not simply a "nice to have" part of writing good software, but rather it is fundamental to quickly and easily communicating meaning.  No fixed, "set in stone" source code style is necessarily needed with these techniques either. Instead, the tenet of maximum readability and communication of intent should be the guidelines for writing clean code.

Can you imagine reading a book, magazine, or internet article that has inconsistent paragraph spacing and line indenting? How odd would it seem and how difficult to read would such text be?  These simple techniques are often taken for granted, but they greatly help to organize information and present the material in a clear and understandable manner.  Source code is no different, since it is intended to be read and grasped by multiple developers, sometimes separated by years of time. It is, of course, meant to be compiled by software tools to create our applications, but first and foremost, source code is meant for people to exchange their creative ideas.

Refactoring and hardening
As the saying goes, the largest room is the room for improvement, and even excellent source code is no exception.  Our code is periodically reviewed for enhancement opportunities such as implementing new language constructs and industry standards and styles.  Comments are frequently updated, dead code is removed, and optimization points are identified and put into action.

Solid Builds

All applications created by Paragon Bit Foundry are always built with zero errors, zero warnings, and zero compiler messages.  With today's modern development tools, many application errors can be found and fixed very early in a project. Although many of these compiler warnings and suggestions about code smells are often ignored and go unheeded by beginning developers, we deem these messages as opportunities, and take full advantage of these indicators to further harden and clarify our code.  As Ben Franklin's saying goes, "an ounce of prevention is worth a pound of cure", and it certainly holds true today and pays dividends later while writing great software.

Finally, our extensive professional experience also grants us an industry perspective that is not always found in newer organizations.  The blending of traditional, fundamental techniques such as commenting, code style, and reusable code to the utilization of very modern development tools such as Git and continuous integration and deployment give Paragon Bit Foundry a distinct competitive advantage.  New technologies are identified and embraced quickly, while always keeping an eye on the tried-and-true software development techniques.

Back to content