Functional C# Application Composition, Part 2: Delegates

In my previous post on the Stateless Single-Responsibility Object (SSRO) approach to C# application composition I reviewed the concept and its shortcomings.

To recap:

  1. You end up with a ton of classes splitting up semi-related logic across multiple files. This is necessary to conform to the classname == filename convention.

Read more on Functional C# Application Composition, Part 2: Delegates…

Web Application Architecture from 10,000 Feet, Part 2 – Persistent Data & Relational Databases

In part 1 of this series, I briefly discussed the difference between the client and the server. In part 2, I’m going to focus on how to structure your server side code.

If you’re making a single-page app—which you should be, if you want an app that’s as responsive as your typical desktop application—your backend “only” has a few concerns (heh): Read more on Web Application Architecture from 10,000 Feet, Part 2 – Persistent Data & Relational Databases…

CMock – Make Support for Easier Integration of Testing

Our tools Unity and CMock were written several years ago to fill a missing gap in testing C projects. We had developed the Ceedling build system, based on Ruby’s Rake. Nevertheless we—and more importantly our user base—would rather not have to use Rake, nor retrofit it into an existing Make build.

Well, we finally made it happen! Read more on CMock – Make Support for Easier Integration of Testing…

Functional C# Application Composition, Part 1: Shortcomings of Single-Responsibility Objects

Functional code is easier to test than code with state or side effects. However, most developers spend the majority of their time in traditional, imperative languages. There’s plenty of value in those imperative languages, but these days when I use one, I also try to bring in applicable functional concepts.

In this post I will explore how a stateful, Object-Oriented approach to composition became painful to me, and in my next post I will discuss my proposed functional solution. Read more on Functional C# Application Composition, Part 1: Shortcomings of Single-Responsibility Objects…

Web Application Architecture from 10,000 Feet, Part 1 – Client-Side vs. Server-Side

Or, Why you can’t get your jQueryUI Datatables plugin to keep your data after you refresh the page.

This three-part series is a general, high-level, first-day-of-Intro-to-Web-Development overview of web app architecture. It is written for the past selves of a few of my college friends, the friends who called and asked me the question in the subtitle above, and then showed me a mess of PHP spaghetti code (copy-pasted from various “This is how you make a form!” type tutorials) when I asked them to show me what they had done so far. Read more on Web Application Architecture from 10,000 Feet, Part 1 – Client-Side vs. Server-Side…

Improving UI Stability with Ember Data and ArrayProxy

I’ve grown fond of Ember.js over the past two years. In that time it has evolved quite a bit. Recently, HTMLBars and more mature versions of Ember Data have been particularly welcome additions. That forward progress, and varying project needs, mean that I’m still regularly learning more about its quirks, tools, and doing things the “Ember way” (or all three at once). Just a week ago, that was the case while working with Ember Data relationships, an ArrayProxy, and rendering controllers. Read more on Improving UI Stability with Ember Data and ArrayProxy…

Hooking up Custom Jersey Servlets in Dropwizard

I’ve been using the Dropwizard Java framework for about a year. It’s a great web application stack for making RESTful service with Java.

I recently ran into a situation where I wanted to add custom servlets to a Dropwizard application. Read more on Hooking up Custom Jersey Servlets in Dropwizard…

Read more on Hooking up Custom Jersey Servlets in Dropwizard…

Optimize EEPROM Writes Across Pages

Because I’m an embedded developer, I often work on projects where I need to store some data on an extern EEPROM or Flash chip. The internal memory of these chips is usually divided up into fixed sized pages. It’s often the case that you’re not allowed to write more than a page at a time. This makes things complicated if you want to do a write that spans multiple pages. It’s even more tricky if you want to support wrap-around, which turns out to be very handy in certain situations.

Read more on Optimize EEPROM Writes Across Pages…

Organizing an Ember.js App with the Awesome {{component}} Helper

In the past year, I’ve spent a lot of time developing a large, complex single-page app using Ember.js. One of the challenges when dealing with a complex SPA is organizing the many views and components within the app, especially when dealing with naturally “typed” data.

In this situation we often found we wanted a different view or component based on the type of the data being presented. The advantage to this is it keeps our templates, controllers, and components from growing out of control. Read more on Organizing an Ember.js App with the Awesome {{component}} Helper…