My second day at That Conference began with a Keynote delivered by Zach Supalla, CEO of Particle, a startup that has created an Internet of Things (IoT) cloud platform. I’ll be honest, when I saw the speaker information ahead of the conference, I wasn’t sure I was going to be interested in hearing another startup story, but I’m really glad I got a chance to hear him speak. I really liked how his first attempt at a consumer product (an adapter for existing lightbulbs that allowed for wifi connection and thus electonic control from other devices) was created as a solution to his father’s hearing loss. The idea was that the lightbulb would flicker when his father’s cellphone rang, alerting him that a call was incoming. While his landline phone used to do this because the house was wired to support this, the cellphone had no such connection. All in all, I really liked the products that his company has produced and the story was pretty inspirational. Even though this product didn’t succeed, they were able to pivot and find an even larger impact with their IoT platform. Zach’s core messages of learning to perservere in the face of adversity and truly listening to their customers was very inspirational – with the right idea, team, and luck, anyone can succeed.

After the keynote, I kicked around the idea of attending several sessions. There were a lot of interesting ones, but I decided to check out the Open Spaces and talked about becoming a Microsoft MVP. I have never really been sure how people got to be Microsoft MVPs, but the process seems pretty simple: put together a strong body of work by demonstrating a passion for your work and the overall impact in your area of focus. After completing an application, your nomination will be reviewed.

At lunchtime, I went to a presentation given by Inrule about their software that allows businesses to define vocabulary and business rules that remove a dependency on hard-coding rules. The core problem their solution addressed was communication failures between the use cases and user stories that business personnel use compared to the developer implementations. Why have a developer interpret the rules when someone who is actually using the software can define the rules themselves. The presentation was really well done, as they used a Star Wars metophor to demonstrate the problems that changing business rules can introduce (particularly when businesses have sizeable amounts of red tape to cut through in order to implement a change).

For the 1:00 session, I attended a discussion called C#: You don’t know jack by George Heeres. There were a lot of useful tidbits involved in the discussion – some of which I was aware with others being new to me. A lot of the things he presented were things I had learned at one point or another but had forgotten due to lack of use. There was a discussion of string allocation and memory consumption and use of IFormatProvider/ICustomFormatter to allow POCOs to have custom String.Format options. One of the most interesting ideas were the ways to create attributes for enums by using extensions methods on the classes that consume the Enums. These attributes allow you to provide an English readable name for each enum. There was some discussion at the end about returning IEnumerable collections on models from the database instead of IList or List because IList has methods that imply functionality that may not be there (add, update, remove). The argument was that those terms mean add/update/remove to a data store, although I see them as valid because you are modifying the collection regardless of whether that collection is in memory or part of a datastore. Context about where you are using the collection is important.

The 2:30 session wasn’t one of my favorites. It had to do with starting out with IoT, but the presentation was very fast-paced with the intent of doing live demos of several objects built by the presenters. Unfortunately, they ran into problems connecting to wifi, both locally and in the cloud, so they ended up spending a lot of time trying to get their connection working. I am not sure whether they ended up getting everything to work because I left to check out the Open Spaces. Earlier in the day, I had met Maggie Pint, a Microsoft software engineer who also maintains the excellent moment.js library, and she told me about her talk going on at 1:00 and Open Spaces session at 2:30. It was clear after talking with her for just a couple of minutes that she was an expert in her topic regarding the complexities of date and time (anyone who has spent any time thinking about date and time across time zones knows how complicated this topic really is). I caught a little bit of the discussion at her 2:30 open space discussion, but not as much as I would have liked. In retrospect, I really wish I would have been able to attend two 1:00 sessions.

My last session for the day was about domain-driven data, given by Bradley Holt. It was a thought-provoking session that related strongly to Eric Evans 2003 book Domain Driven Design, which I partially read some years ago, and recall being very influential. After the discussion, I think I need to re-read some parts because a lot of the concepts are still relevant to today’s industry. I’ll admit that I haven’t had to think much about my data store – I have mostly worked with low-scale websites, so a relational database has always been the defacto choice for me. However, a strong case was made for a model which leverages the strengths of different persistence strategies: Key-Value stores, document-driven databases, graph databases, relational database models, and some others. One of the most interesting things about the discussion was in the discussion of Aggregate Roots (a DDD concept from the aforementioned book). In the strictest sense, aggregates that are not the root should not also be an aggregate root in another scenario. Consider the following object:

public class Order : IAggregateRoot
{
    public int Id { get; set; }
    public int CompanyId { get; set; }

    public virtual Company Company { get; set; }
}

In this case, the Company object is an aggregate, but not an aggregate root. Therefore, the Company object should not be an Aggregate Root of its own. One solution proposed by another attendee was to have an “OrderCompany” object that had foreign key constraints to the Order and Company table. This way, Company can still exist as an aggregate root, and so can Order. These kinds of sessions are my favorite because they really make me think about architecture, one of my favorite things.