C# Design Patterns: #5 – Builder

September 29, 2014 Andrew Palczewski Leave a comment

The Builder pattern is a narrowly-focused pattern that enables incremental creation of new products. This pattern, though limited in application, when applied correctly, brings significant power and flexibility.

The guiding concept behind the Builder pattern is separation of the actual “building” of an product from its design plan. The prototypical example of the builder pattern is saving files to multiple formats. If an application allows saving files to different formats, it will have an internal representation of the data, and will need to “build” different formats dynamically from the same source object.
Continue reading →

Oracle CEO Steps Down Amid Titanic Shift

September 26, 2014 Andrew Palczewski 1 Comment

I usually don’t write about news, or in this case olds, but in this case the technology is amazing enough to merit mention. As most of the tech world knows, Oracle CEO Larry Ellison stepped down from his post earlier this week, after a 37 year career leading the company to become one of the dominant players in the IT industry. With all of the publicity and commotion that this move made, it had completely overshadowed an even more titanic shift happening in the database world: Oracle’s June launch of its In-Memory Database for 12c.
Continue reading →

Are Programmers Resources?

September 25, 2014 Andrew Palczewski Leave a comment

One of the more amusing parts of my workday is getting 2-3 calls each day from offshore companies asking me to outsource our development work. A good portion of their pitches refer to their developers as “resources.” It’s a wistful thought, that I could simply pull out a checkbook and buy a programming resource or two to help out with work when we are overbooked.
Continue reading →

Scalable Web Development

September 24, 2014 Andrew Palczewski Leave a comment

As the content revolution has taken hold of web development, the information architecture of a website has become increasingly important. Although a site might start with twenty to fifty pages, it will need to scale to several hundred throughout its lifecycle. It’s no longer enough to create a design that elegantly accommodates the information that will be available at launch – websites must be built to scale.
Continue reading →

License to Code

September 23, 2014 Andrew Palczewski Leave a comment

With the recent string of high-profile software project failures, from the Healthcare.gov website to the Target / Home Depot data breaches – in many cases caused by a lack of planning, understaffed teams, or underperforming project managers and architects, the field is ripe for creation of a regulatory body to provide guidance and ensure compliance to development standards. While the actual implementation of a wide-reaching government-sponsored regulatory system is still at least a decade away, the early stages of such a system are already becoming apparent in both business and technology.
Continue reading →

Crowdsourced Monolingual Translation

September 22, 2014 Andrew Palczewski Leave a comment

A recent paper by a researcher at the University of Maryland explores that use of crowdsourcing in text translation. Instead of requiring bilingual translators to convert books from one language to another, Google Translate was used for the bulk of the translation, with crowdsourced monolingual translators on either side to verify the text and add corrections.
Continue reading →

C# Design Patterns: #4 – Abstract Factory

September 19, 2014 Andrew Palczewski Leave a comment

The Abstract Factory pattern, although not present in many end-user applications, finds ample grace in the development of user-configurable toolkits and frameworks. Instead of locking the developer into a particular set of controls or objects that will be used by the framework, the abstract factory instead lets developers substitute their own controls when necessary.
Continue reading →

C# Design Patterns: #3 – The Prototype

September 18, 2014 Andrew Palczewski Leave a comment

What do CAD design tools, workflow automation, and digital audio synthesizers have in common? They can all benefit from the Prototype pattern in their software architecture.

Although the Prototype pattern achieves true glory in languages such as JavaScript, which base their entire class structures on Prototypes instead of traditional classes, the pattern still brings powerful functionality to C#. Its primary use is in a very specific niche: when the users of the application will perform design work, and then group those designs into reusable subcomponents.
Continue reading →

C# Design Patterns: #2 – The Factory Method

September 17, 2014 Andrew Palczewski 3 Comments

One of the less useful C# design patterns is the Factory Method. Primarily used for framework and toolkit development, this design pattern is rarely used in a language like C# that has templated classes, anonymous functions, interfaces, and reflection.
Continue reading →

C# Design Patterns: #1 – The Singleton

September 16, 2014 Andrew Palczewski 2 Comments

The Singleton is one of the simpler design patterns. As the name suggests, the Singleton creates a single, static, globally accessible class. It is an alternative to global variables and static classes, each which come with their own limitations.

Singletons are excellent areas to store global information, such as database connection strings, system paths, and parsed XML configurations. In addition, Singletons can be used to store global image caches so that images can be shared between functions.
Continue reading →

Software Sagacity

Monthly Archives: September 2014