The way less traveled by...

Dynamics 365 Web API Create and Update

2017-03-02T09:52:00.000-08:00

Recap

In the previous post we built a C# client for Dynamics 365 Web API using ServiceStack. Then we talked about reading multiple result sets, allowing us to do this:

var contact = Client.Get<Contact>("/contacts(" + contactGuid + ")");
var contacts = ContactRepository.GetContacts();

Now let's do a couple more items in CRUD (create-read-update-delete), namely create and update:

var updatedContact = ContactRepository.Update(contact);

Create and Update

ServiceStack makes this very easy, though there are a couple of gotchas.

public string create(Contact contactToCreate)
{
    // as mentioned before you'll want to insulate your model from the web api,
    // requiring conversion back and forth
    var odataContact = toCRMContact(contactToCreate);

    // ServiceStack helper to get us something that we can manipulate before we send it
    var contactDictionary = odataContact.ToStringDictionary();

    // gotcha #1
    // if you post with a contactid it will likely error,
    // as this isn't part of the 'create' contract web api
    contactDictionary.Remove("contactid");

    // happily we never have to worry about authentication or serialization
    // thanks to our custom c# web api client
    var result = Client.Post("/contacts", contactDictionary);

    // custom helper
    var guid = getGuidFromODataWebResponse(result);

    // gotcha #2
    // if you don't dispose the HttpWebResponse you'll eventually run out of sockets
    // you could also wrap this in a "using" block
    result.Dispose();

    return guid;
}

public string update(Contact contactToCreate)
{   
    var result = Client.Patch("/contacts(" + contactToUpdate.guid + ")",
        toCRMContact(contactToUpdate));
    var guid = getGuidFromODataWebResponse(result);
    result.Dispose();

    return guid;
}

// example of the conversion
private static ODataContact toCRMContact(Contact contact)
{
    // generated enums
    // https://msdn.microsoft.com/en-ca/library/hh547435.aspx
    var genderCode = (int)ContactGenderCode.Unknown;
    if(contact.gender == "M")
        genderCode = (int)ContactGenderCode.Male;
    else if(contact.gender == "F")
        genderCode = (int)ContactGenderCode.Female;

    return new ODataContact
    {
        contactid = Guid.Parse(contact.guid),
        gendercode = genderCode
    }
}

// helper to grab the guid from the response
private string getGuidFromODataWebResponse(HttpWebResponse response)
{
    var entityId = response.Headers["OData-EntityId"].Split('(').Last();
    return entityId.Remove(entityId.Length - 1, 1);
}

But what about @odata.bind?

OData has an interesting way of dealing with relationships which unfortunately doesn't lend itself well to strongly-typed objects; "somefield@odata.bind" isn't a legal c# field name. For these cases we'll use ServiceStack's JsonObject. In this example we'll do an update to the contact's owner.

public void setContactOwner(string contactGuid, string username)
{
    var response = Client.Patch("/contacts(" + contactGuid + ")",
        new JsonObject
        {
            ["ownerid@odata.bind"] = "/systemusers(" + getSystemUserByUsername(username) + ")",
        });
    response.Dispose();
}

protected string getSystemUserByUsername(string username)
{
    var userId = Client.userId;

    var users = Client.Get("/systemusers?$filter=startswith(domainname,'" + username + "')");
    if (users.Value != null && users.Value.Any())
        userId = users.Value.First().systemuserid.ToString();
    return userId;
}

public class SystemUsers
{
    public List Value { get; set; }
}

public class SystemUser
{
    public Guid? systemuserid { get; set; }
    public string firstname { get; set; }
    public string lastname { get; set; }
    public string title { get; set; }
    public string domainname { get; set; }
}

Activities

Dynamics365 activities have a couple of gotchas worth mentioning. First, you can't create completed activities with the Web API (you could with the SDK), and second, you can't update completed activities (so you'll have to open them first).

private string createEmail(Email email, string entityName)
{
    var userId = getSystemUserByUsername(email.related_username);

    // generated enums
    // https://msdn.microsoft.com/en-ca/library/hh547435.aspx
    var emailParties = new List
    {
        new JsonObject
        {
            ["partyid_systemuser@odata.bind"] = "/systemusers(" + userId + ")",
            ["participationtypemask"] = 
                  Soap.ActivityPartyParticipationTypeMask.Sender.ToString("D")
        },
        new JsonObject
        {
            ["partyid_" + entityName + "@odata.bind"] = "/" + entityName + 
                  "s(" + email.regarding_guid + ")",
            ["participationtypemask"] = 
                  Soap.ActivityPartyParticipationTypeMask.ToRecipient.ToString("D")
        }
    };

    var emailToCreate = new JsonObject
    {
        ["subject"] = email.subject,
        ["description"] = email.description.Replace("\n","
"),
        ["torecipients"] = email.email,
        ["regardingobjectid_" + entityName + "_email@odata.bind"] = "/" + entityName + 
                       "s(" + email.regarding_guid + ")",
        ["emailsender_" + entityName + "@odata.bind"] = "/" + entityName + 
                       "s(" + email.regarding_guid + ")",
        ["email_activity_parties"] = emailParties.ToJson(), // ServiceStack helper
        ["directioncode"] = "false", // inbound
        ["ownerid@odata.bind"] = "/systemusers(" + getSystemUserByUsername(email.related_username) + ")"
    };

    // if your payload has optional values you shouldn't include an entry unless you've got something to send
    if (email.import_id.HasValue)
        emailToCreate["importsequencenumber"] = email.import_id.ToString();

    if (email.is_outbound)
        emailToCreate["directioncode"] = "true";
    
    // date conversions to the web api aren't fun
    if(email.added_date.HasValue)
        emailToCreate["overriddencreatedon"] = 
              DateTime.SpecifyKind(email.added_date.GetValueOrDefault(), DateTimeKind.Utc).ToString("O");

    var result = Client.Post("/emails", emailToCreate);

    var entityId = getGuidFromODataWebResponse(result);
    result.Dispose();

    // gotcha!
    // if you want to complete the email you must do it in a second operation
    if (email.is_completed)
        completeActivity(entityId, "emails");

    return entityId;
}
private string updateEmail(Email email)
{
    if (string.IsNullOrEmpty(email.guid))
        throw new WebServiceException("Unable to update a email without a guid");

    openActivity(email.guid, "emails");

    var stateCode = "0";
    if (email.is_completed)
        stateCode = "1";


    // just allow updating the basics
    var CRMActivityToUpdate = new JsonObject
    {
        ["importsequencenumber"] = email.import_id.ToString(),
        ["subject"] = email.subject,
        ["description"] = email.description,
        ["directioncode"] = "false",
        ["statecode"] = stateCode
    };

    // did I mention that dates are a pain?
    if (email.added_date.HasValue)
        CRMActivityToUpdate["overriddencreatedon"] = yourDateToUTC(email.added_date);

    if (email.is_outbound)
        CRMActivityToUpdate["directioncode"] = "true";

    var response = Client.Patch("/emails(" + email.guid + ")", CRMActivityToUpdate);
    response.Dispose();

    return email.guid;
}
private void openActivity(string guid, string entityPluralName)
{
    var response = Client.Patch("/" + entityPluralName + 
                   "(" + guid + ")", new { statecode = 0 });
    response.Dispose();
}
private void completeActivity(string guid, string entityPluralName)
{
    var response = Client.Patch("/" + entityPluralName + 
                   "(" + guid + ")", new { statecode = 1 });
    response.Dispose();
}
protected string yourDateToUTC(DateTime? date)
{
    if (!date.HasValue || date.GetValueOrDefault().Year < 1900)
        date = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
    
    var convertedDate = TimeZoneInfo.ConvertTimeToUtc(date.GetValueOrDefault(), TimeZoneInfo.Local);
    return convertedDate.ToString("O");
}

Integers and Edm.String

OData is rather protective of its strings - don't you dare submit an integer! Sigh. ServiceStack can serialize anonymous types, which work! http://docs.servicestack.net/http-utils

// some custom entity
// slightly different pattern to show how you might manage exceptions
// with ServiceStack's generic ResponseError
public ResponseError updatePayment(string guid, string financeId)
{
    if (string.IsNullOrEmpty(guid))
        return new ResponseError { Message = "Unable to update payment. Guid must be provided." };

    // can't use jsonobject because OData can't figure out how to convert the int to Edm.String
    var paymentToUpdate = new
    {
        new_finance_id = financeId
    };

    try
    {
        var response = Client.Patch("/payment_entities(" + guid + ")", paymentToUpdate);
        response.Dispose();
    }
    catch (WebServiceException webEx)
    {
        return new ResponseError { ErrorCode = webEx.ErrorCode, Message = webEx.Message };
    }
    return new ResponseError();
}

Dynamics 365 Web API Custom C# Client Result Sets

2016-12-22T18:07:00.000-08:00

Recap

In the previous post we built a C# client for Dynamics 365 Web API using ServiceStack. The benefits include: deserialization to strongly-typed objects, baked-in authentication, and with a repository pattern we essentially treat the Web API as a database, translating contexts and safe-guarding against changes that may come in the future.

Baking this cake takes some time, but the results are beautiful!

var contact = Client.Get<Contact>("/contacts(" + contactGuid + ")");

The next step is to query multiple results at once:

var contacts = ContactRepository.GetContacts();

Notice anything different here? We can't simply deserialize a result because we need to deal with multiple pages of results, which is going to take several roundtrips to the Web API. We'll hide all that heavy lifting inside our repository.

Paged Results

When the Web API has multiple results, and their number exceeds the page size (which cannot be greater than 5,000), then it returns the results in pages, aka result sets. OData actually does something great here. Most APIs will give us the current page, the total number of pages, and the results on each page. Navigating through the pages is kind of a pain. Happily, Web API provides an @odata.nextLink, which is all we need to get the next page!

// The JSON "Value" in the result set is our list of contacts
public class Contacts
{
    public List<Contact> Value { get; set; } 
}

public List<Contact> getContactsPsuedo()
{
    // a holding tank for our results
    var result = new List<Contact>();

    // we make our initial query and just throw it in a string for now
    var contactsString = Client.Get<string>("/contacts");

    // ServiceStack has a bunch of great helper function like .FromJson
    var contacts = contactsString.FromJson<Contacts>();

    // grab the results from this page
    result.AddRange(contacts.Value);

    if (contactsString.Contains("@odata.nextLink"))
    {
        // (another ServiceStack helper)
        // parse the string into a dictionary and grab the link
        var nextUrl = JsonObject.Parse(contactsString).Get("@odata.nextLink");

        // the url will have https://<yourtenant>.crm.dynamics.com/api/etc
        // but our client already has this as it's base url, so it just needs the query
        var nextLink = nextUrl.Replace(Client.apiUrl, "/");
        contactsString = Client.Get<string>(nextLink);

        // then we iterate!
    }
}

// here's the real thing
// though this should probably be refactored to accommodate any entity
public List<Contact> getContacts()
{
    var result = new List<Contact>();

    var contactsString = Client.Get<string>("/contacts");

    while (true)
    {
        var contacts = contactsString.FromJson<Contacts>();

        if (contacts.Value.Count > 0)
        {
            result.AddRange(contacts.Value);
        }

        // when the result set has a nextLink keep going
        if (contactsString.Contains("@odata.nextLink"))
        {
            var nextUrl = JsonObject.Parse(contactsString).Get("@odata.nextLink");

            var nextLink = nextUrl.Replace(Client.apiUrl, "/");
            contactsString = Client.Get<string>(nextLink);
        }
        else // otherwise we're done
        {
            break;
        }
    }
    return result;
}

Build Your Own Dynamics 365 Web API C# Client on ServiceStack

2016-12-06T17:21:00.005-08:00

Build Your Own Client

The days of writing code with the Dynamics 365 SDK are coming to an end. The Web API lets us work on any platform, but it has some short-comings. First, there is a high degree of complexity and challenging documentation (is that 8 pt font?); the price you pay for a one-size-fits-all querying language. Second, Microsoft does not provide a client:

Because the Web API is built on open standards, we don’t provide assemblies for a specific developer experience. You can compose HTTP requests for specific operations or use third-party libraries to generate classes for whatever language or platform you want. You can find a list of libraries that support OData version 4.0 at http://www.odata.org/libraries/.

After spending a few days with the various options, and hitting show-stopping roadblocks, I was not in love with the Web API. Microsoft, if you're listening, the OData clients out there aren't very good - please fix. In this series of blog posts I'll take you through implementing your own client using ServiceStack. Here's a short example of the result to keep you motivated. :)

A Simple Example

var contact = Client.Get<Contact>("/contacts(" + contactGuid + ")");

There are three things to note here:

All of the OData complexity is hidden behind our client, including authorization. The only complexity left to us is constructing proper OData queries, and a few special situations where we can't automatically deserialize the stuff that OData gives us (for example when we have paged data sets).
Deserialization from JSON to our strongly-typed object is done for us.
We need to define our strongly-typed objects by hand. Small amount of pain, big win I promise.

There are several concerns here though. We really don't want to expose the Dynamics 365 field names to the rest of our application, and heaven forbid any other applications that might use this intermediate API. Why?

We can't control whether Microsoft decides to change field names, or for that matter if they change to another API. Always insulate things that are likely to change.
OData is going to give us integers for option sets, unless we do some pretty fancy querying. Always translate language when you cross to different domains. In other words, the language that Dynamics 365 uses to describe an option set is meaningless elsewhere, so don't force anything else to know it.

All of this is happily solved by using the repository pattern.

public class ContactRepository
{
   protected IDynamicsCRMClient Client { get; set; }

   public ContactRepository(IDynamicsCRMClient client)
   {
      Client = client; // our magical client which we'll build below
   }

   public MyContact getByGuid(string contactGuid)
   {
      return toMyContact(Client.Get<Contact>("/contacts(" + contactGuid + ")"));
   }

   public MyContact toMyContact(Contact contact)
   {
      if (contact == null)
         return new MyContact();

      // OptionSets can be generated using the Dynamics 365 SDK
      // \SampleCode\CS\CrmSvcUtilExtensions\GeneratePicklistEnums

      var gender = "";
      if (contact.gendercode == (int)ContactGenderCode.Male)
         gender = "M";
      else if (contact.gendercode == (int)ContactGenderCode.Female)
         gender = "F";

      return new MyContact
      {
         guid = contact.contactid.ToString(),
         first_name = contact.firstname,
         middle_name = contact.middlename,
         last_name = contact.lastname,
         gender = gender // etc
      }
   }
}

Still interested? This approach might involve too much insulation for simple applications, but if we're building for the enterprise, we need to invest in good code. Now let's take care of actually talking with the Web API.

Extending the ServiceStack Client

ServiceStack comes with a JSON client that can be extended.

public class DynamicsCRMClient : ServiceClientBase
{
   // there are a bunch of settings you'll need to inject.
   // OAuth 2.0 is fairly cumbersome
   private static string _crmUrl;
   private static string _apiUrl;
   private static string _oauthUrl;
   // ...

   public DynamicsCRMClient(string crmUrl, string apiVersion, string oauthUrl...)
   {
      _crmUrl = crmUrl;
      _oauthUrl = oauthUrl;
      _apiUrl = crmUrl + "/api/data/" + apiVersion + "/";
      // the rest of the settings...

      // all our calls to the client will use this base url
      SetBaseUri(_apiUrl);

      // add these headers to every outgoing request
      this.RequestFilter = httpReq =>
      {
         // request a token for every call is best practice according to
         // https://msdn.microsoft.com/en-us/library/gg327838.aspx
         // rather than checking expiration. But it's up to you.
         // I've settled on checking the expiration.
         httpReq.Headers.Add("Authorization", "Bearer " + getToken());
         httpReq.Headers.Add("OData-MaxVersion", "4.0");
         httpReq.Headers.Add("OData-Version", "4.0");
      };
   }

   private static string getToken()
   {
      // if the token hasn't expired simply reuse it
      var unixTime = getUnixTime();
      if (expiresOn.HasValue && unixTime + 600 < expiresOn.GetValueOrDefault())
         return accessToken;

      return GetAuthenticationResponse().access_token;
   }

   private static int getUnixTime()
   {
      var dateTimeOffset = new DateTimeOffset(DateTime.UtcNow);
      return (int) dateTimeOffset.ToUnixTimeSeconds();
   }

   // OAuth will give us all this if we authenticate
   private class AuthenticationResponse
   {
      public string token_type { get; set; }
      public string scope { get; set; }
      public int expires_in { get; set; }
      public int expires_on { get; set; }
      public int not_before { get; set; }
      public string resource { get; set; }
      public string access_token { get; set; } // but this is really all we need
      public string refresh_token { get; set; }
      public string id_token { get; set; }
   }

   private static AuthenticationResponse GetAuthenticationResponse()
   {
      var vals = new NameValueCollection
      {
         {"client_id", _clientId},
         {"resource", _crmUrl},
         // all those settings we injected above
      };

      var response = _oauthUrl.PostToUrl(vals.ToFormUrlEncoded(),
         requestFilter: webReq =>
         {
            webReq.Headers["Cache-Control"] = "no-cache";
         }
      );

      var authResponse = response.FromJson<AuthenticationResponse>();
      expiresOn = authResponse.expires_on;
      accessToken = authResponse.access_token;
      return authResponse;
   }

   // there are a few methods that we need to overload to
   // patch in our authentication scheme
   // I'll post the source soon
}

With that client we can simply ask OData questions by doing Client.Get<TheObjectWeAreExpecting>("ourODataQuery"), .Post, .Patch, etc.

Other OData clients may get you that far. But as soon as you need to deal with paged data sets, or $expand'ing into related data, you are going to have to get down to the metal anyway.

In the next post we'll deal with the paged data sets!

Ruby Gem Your ServiceStack

2016-03-02T15:04:00.000-08:00

TL;DR

Here is a Ruby Gem example of how to talk to your ServiceStack.

Let's Be Platform and Language Agnostic

One of the big wins of a data API built on ServiceStack is that our clients can be on any platform and language, not just C#. After all, we're just talking JSON! This means we can pick the best-of-breed language depending on the task at hand. C# is great on the backend, but ASP.NET Razor can be weak when compared to a client-side Javascript framework like Angular, and some would argue Ruby-on-Rails (I'm just going to call it Ruby from here on). Let's have a go at Ruby then shall we?

A Ruby Gem for ServiceStack

Ruby is still pretty foreign to me. I need to keep things as simple as possible. Sure, we could just fire HTTP calls at ServiceStack (I do that all the time with PHP and cURL), but I really want to separate the concerns of my API, like logging in, caching, and JSON serialization. That way I can conserve my precious brain space for the problem I'm working on and just call one thing to get my data.

One of Ruby's claims to fame is that it is an opinionated language. There is a "Ruby way" to do things. But that's not really true when you look at the different gems built to consume APIs. Twitter, Stripe, and Instagram all tackle the problem differently, and are way too complicated.

Pick an Approach

The simplest gem I could find was Yelp. Basically you define three things: your data models, your endpoints for the different ways the models can be populated, and your response objects that populate the models. Pretty standard stuff.

Here is how we're going to lay it out. I live in higher ed, so I've gone with sections we offer in a term with instructors:

The gem will work like this:

require 'servicestack'

ServiceStack.client.configure do |config|
  config.url = "https://theurl"
  config.username = "the_username"
  config.password = "the_password"
  config.cache = ServiceStack::Cache.new(Dalli::Client.new('localhost:11211', { :namespace => "servicestack", :compress => true, :expires_in => 3600 }))
end

@single_section_response = ServiceStack.client.section_get_by_uuid("the_section_uuid")
p @single_section_response.section.secUUID # here it is!

@multiple_section_response = ServiceStack.client.sections_get_by_reporting_term("the_term")
p @multiple_section_response.sections.count # more than 1!

Caching

This particular gem will be used by a high-volume website and I don't want it hammering my API, which services lots of mission critical stuff. So baking in caching was very important. I left it up to the implementer to inject whatever caching engine they liked using config.cache - it just has to respect a few simple methods: initialize, write, read, delete.

One important caveat: Caching only works when the URL is idempotent. i.e. you can't use POST. The problem is that the URL is the cache key, but POST is not part of the URL! So asking different questions is going to get you just one answer. There are definitely ways around this, like hashing the POST payload into the URL, but for proof of concept I'm just using GET requests.

The Guts of Calling ServiceStack

Configuring the client

Faraday will do the heavy lifting for us. CookieJar will remember our ServiceStack session. It's worth going over this in a bit of detail, so here is a snippet from our client:

def connection
return @connection if instance_variable_defined?(:@connection)
 @connection = Faraday.new(@configuration.url, :ssl => {:verify => false}) do |faraday|
  # ssl verify false for self-signed certificates

  faraday.basic_auth(@configuration.username, @configuration.password)
  # ServiceStack supports other auth, but this is the simplest

  faraday.request :json
  # our HTTP header content-type on the way out

  faraday.response :json, :content_type => /\bjson$/
  # expect content-type JSON on the way in

  #faraday.response :logger # uncomment if you want to see what's going on
  
  # faraday has some middleware that handles our cache
  # https://github.com/lostisland/faraday_middleware/wiki/Caching
  faraday.response :caching do
   @configuration.cache
  end
      
  faraday.use :cookie_jar # Preserve the ServiceStack session
  faraday.adapter Faraday.default_adapter # make requests with Net::HTTP
 end
end

Making the call

Our endpoints are injected with the client. Then they'll use our connection method to grab the data. Here is the endpoint we used in the above example:

class Section
 def initialize(client)
    @client = client
  end
  def section_get_by_uuid(uuid)
    response = @client.connection.get "/Section/#{uuid}", { :format => 'json' }
    # I'm hard-coding my ServiceStack endpoint to this method. This feels brittle to me.
    # I also had to add the :format json here too, which I shouldn't have to

    # define which response handles deserialization
    Response::Section.new(response.body)
  end
end

Deserializing

Our base response will step through the JSON to deliver the class "klass" we inject:

class Base
  def initialize(json)
    return if json.nil?

    json.each do |key, value|
      instance_variable_set("@#{key}", value)
    end
  end

  private

  def parse(json, klass)
    return json.collect { |j| klass.new(j) } if json.is_a?(Array)
    return klass.new(json) if json
    nil
  end
end

Then our section response simply inherits from the Base and injects the model to populate:

class Section < Base
  attr_reader :section
 
  def initialize(json)
    @section = parse(json, Model::Section)
  end
end

And finally we have our model which has the same field names that we deserialized:

class Section < Response::Base
  attr_reader :secUUID
  attr_reader :course_name
  attr_reader :course_description
  attr_reader :course_title
  attr_reader :section_code
  ...
  # instructors are embedded in each section
  attr_reader :instructors

  def initialize(json)
    super(json)
 
    @instructors = parse(@instructors, Instructor)
  end

  ...

That's it! Now we can grab our section with a one-liner: ServiceStack.client.section_get_by_uuid("the_section_uuid"). Our data API is decoupled because it's limited to this gem.

The Demon Behind the Curtain

If you're coming from a C# background you need to know something very important about Ruby: It abuses objects. In other words, the class you define can change dynamically during runtime. C# tends to keep our hands tied, but in Ruby you can do some pretty weird stuff, like monkey patching, and in this case method dispatching.

Consider the client again:

  @single_section_response = ServiceStack.client.section_get_by_uuid("the_section_uuid")

Doesn't it seem strange to you that our client is somehow inheriting our section endpoint?

At runtime the client loops through all the endpoints you've defined and attaches their methods to itself! Being a Ruby newbee I left it that way, assuming that's how things are done in this language. Who am I to question its opinions?

Test Drive Angular 2 with Meteor

2016-03-01T14:02:00.003-08:00

TL;DR

Angular 2 is worth taking another look at Angular. It has simpler concepts and less jargon to learn. And the Meteor tutorial is a great way to do it.

The Internet is Slow

Client-side Javascript frameworks solve one of the biggest problems for web-based apps: round-trips to your server. Every time a user navigates around your app, their browser has to ask for data. In a mobile-first world this can be quite painful.

One of the ways to make this a bit better is to selectively update the DOM with JS, rather than doing a whole page refresh.

Take a simple shopping cart example. When the customer selects a product, adds shipping in checkout, and selects a payment method we want to update the shopping cart somewhere on the page. Instead of refreshing everything when they make a selection, we update the shopping cart with jQuery (or vanilla JS).

The only abstraction between us and the DOM at this point are the jQuery helpers - onChange(), val(), etc. In other words, what you see displayed on the page is roughly what you see in your HTML, CSS, and JS. And life is good because it's relatively simple and speeds things up a bit.

But this isn't great. Think of how many times you might go back and forth between different products, over to your checkout to see whether you qualify for free shipping yet, etc. And if you're on mobile (or your server is under heavy load), every time you do something you might be waiting several seconds. And your customer loses interest.

Javascript to the Rescue (again)

Instead of asking the server for the data, let's give more data to the browser in the first place and let it decide when to render it. In fact, let's put an MVC into Javascript! The user can navigate around without chatting with your server. To do that JS needs to change the DOM in very complex ways, much more than jQuery and CSS can do. But what's the best way to do it? There's the rub. Backbone, Knockout, Ember, Angular, React, take your pick, mix and match. And the price is added complexity - a lot of it.

Angular

In Angular's world you don't change the DOM. Instead, your job is to interact with the "Shadow DOM" and let Angular do the heavy-lifting. Here is a very rough idea of what our shopping cart example might look like in Angular:

There is still HTML and CSS at play here, but the state of the application is not reflected by static HTML files (with jQuery sugar on top) but by views (and various templates) rendered by our controller.

The general idea is that we drop in some HTML placeholders and then write Angular code (distinct from JS) against the shadow DOM - a single-source of truth that Angular syncs to the DOM for us. When the user selects a product and goes to the checkout then Angular on their device tells the browser everything it needs to know, instead of asking the server. The customer gets a very responsive experience and hopefully makes it to actually paying.

But in the end, Angular's complexity is just too high, even with all the other stuff it brings to the table like two-way data-binding and unit testing. The concepts sound like MVC, but once you dive in you encounter some pretty weird stuff: $scope, $broadcast, and $emit to name some at random. And we aren't writing JS anymore - it's Angular, and like any language you're going to need to devote additional brain-space to it. I felt like I got burned when I built something with Angular and I haven't gone back.

Angular 2

The second iteration of Angular is worth giving it another shot. Goodbye controllers and scope, hello components. Here is our shopping cart in Angular 2:

The cohesiveness of each part of the app is better. What a product "does" is no longer spread between the controller, the model, and the view, instead most of it is in the component.

Angular 2 apps can also be built using TypeScript, which feels like a good investment. And it also feels like I have to learn less Angular jargon, but that's just my first impression. I took a stab at a couple of tutorials during the Alpha phase, and I wondered again, "is this worth it?" I just wish it was easier to get something off the ground that I can iterate on later. The official quickstart for Angular 2 is just awful.

Meteor!

Meteor is a full-stack NodeJS webserver, Mongo database, and Angular client-side ecosystem. It is very easy to get something off the ground. I would recommend it for three reasons:

1. Meteor has a killer Angular 2 tutorial

The tutorial is very very good (though at the time of this writing it's only 80% done). You get to play with Angular 2 almost immediately, build something cool, and get spoon-fed each piece as you go. And each step is versioned on GitHub!

2. Meteor bakes the database into the client-side for you

Just tell the data API about your types and how it can be accessed and away you go! Just imagine never having to write custom HTTP, cURL, AJAX calls again.

3. Meteor has packages

How many login systems have you written? Account creation, password retrieval/reset, etc, bleh. But in Meteor we can drop in the account package and configure it.

BUT, and it could be a big one, Meteor's ecosystem isn't going to let you drop in a package for NodeJS without some wrangling like this. This can be a major turnoff because if you'd built your app with Angular2 and NodeJS you wouldn't have that problem. Meteor 1.3+ now uses NPM, so that's nice.

Oh and Meteor's ecosystem isn't all there for Angular 2, so you might want to wait before you pull the trigger on building production apps. :)

Composable ServiceStack

2015-03-15T10:30:00.001-07:00

You've got a set of ServiceStack services and DTOs. You want to share these out with other teams, let them add/customize if needed, but they should still be able to get fixes/new services from you by updating from your repository. Turns out this is relatively easy. They just need to manually register their inherited services in Global.asax.cs.

(if you just want them to add services of their own you could give this a try)

Using virtual/override inheritance isn't going to work straight out of the box, as DTOs and their handlers are mapped 1:1 according to myth. I know for sure because I tried this:

[Route("/Test", "POST")]
public class TestRequest
{
    public string item { get; set; }
}

public class TestResponse
{
    public string response { get; set; }
}

// TestService.cs
public class TestService : Service
{
    public virtual TestResponse Post(TestRequest request)
    {
        return new TestResponse { response = "I'm the basic response" };
    }
}

// ImprovedTestService.cs
public class ImprovedTestService : TestService
{
    public override TestResponse Post(TestRequest request)
    {
        return new TestResponse { response = "I'm an improved response" };
    }
}

You'll get this error:

Additional information: Could not register Request 'REGISDataService.Services.TestRequest' with service 'REGISDataService.Services.SomeImprovedTestService' as it has already been assigned to another service.
Each Request DTO can only be handled by 1 service.

Fair enough! It made me pause, read everything related I could find on StackOverflow, and conclude I still had a decent use case.

You just need to register the services manually.

public class TestAppHost : AppHostHttpListenerBase
{
    //public TestAppHost(): base("TestService", typeof(TestService).Assembly)
    // give AppHost the basic ServiceStack assembly instead of yours
    // (you can't give it nothing)
    public TestAppHost(): base("TestService", typeof(Service).Assembly)
    { 
    }
 
    // you could also try overloading ServiceController here, but I got no joy

    public override void Configure(Funq.Container container)
    {
        // some config stuff
    }
}

protected void Application_Start(object sender, EventArgs e)
{
    var appHost = new TestAppHost().Init();

    // register each .cs that has your service
    appHost.RegisterService(typeof(ImprovedTestService));
}

Done! Your derived class is in place. You can add/change services to the base class, overload them, and add services too:

[Route("/Test", "POST")]
public class TestRequest
{
    public string item { get; set; }
}

[Route("/Test/Base", "POST")]
public class BasicTestRequest
{
    public string item { get; set; }
}

[Route("/Test/Another", "POST")]
public class AnotherTestRequest
{
    public string item { get; set; }
}

public class TestResponse
{
    public string response { get; set; }
}

// TestService.cs
public class TestService : Service
{
    public virtual TestResponse Post(TestRequest request)
    {
        return new TestResponse { response = "I'm the basic response" };
    }

    public virtual TestResponse Post(BasicTestRequest request)
    {
        return new TestResponse { response = "I'm a response that doesn't get overloaded" };
    }
}

// ImprovedTestService.cs
public class ImprovedTestService : TestService
{
    public override TestResponse Post(TestRequest request)
    {
        return new TestResponse { response = "I'm an improved response" };
    }

    public TestResponse Post(AnotherTestRequest request)
    {
        return new TestResponse { response = "I'm a response that isn't in the base service" };
    }
}

Of course you could farm out bits and pieces of your DTO-bound services to underlying services and then subclass those. I'm probably going to need to do this for more complex stuff, but the above seems to me a clean and simple way to do most of the work.

Updating to ServiceStack v4.0

2014-01-02T12:31:00.000-08:00

Updating ServiceStack to v4.0 was my task for yesterday. It wasn't as simple as firing up NuGet and updating - I got this error:

Unable to find a version of 'ServiceStack.OrmLite.SqlServer' that is compatible with 'ServiceStack.Common 4.0.5'.

But it wasn't too bad once I dived in. You'll need to browse through the release notes for the breaking changes.

Here are the steps that worked for me:

Reinstall the libraries

Remove all ServiceStack 3.x libraries from the project(s)
Add ServiceStack 4.x libraries (including the new ServiceStack.Interfaces)

Refactor OrmLite

Add "using ServiceStack.Data" to all repositories that need IDbConnectionFactory
Remove the "OrDefault" stuff from the Db API (e.g. SelectOrDefault to Select, FirstOrDefault to Single)
Change Db.Select to Db.SelectFmt (i.e. your select statements that are sql strings)
Remove the "Param" stuff from the Db API as it's now the default (e.g. SelectParam to Select, UpdateParam to Update, DeleteByIdParam to DeleteById)
Some of my .Select() statements starting throwing nulls, but worked when I changed them to .Where() statements.
Change Db.GetById to Db.SingleById
Change Db.GetLastInsertId to Db.LastInsertId
Change Db.List to Db.SqlList
Change ExpressionVisitor to SqlExpression

Refactor 'using' statements

Change "using ServiceStack.ServiceInterface" to "using ServiceStack". Other libraries in that stack must also be changed, e.g. ServiceStack.Auth, ServiceStack.Validation.
Change "using ServiceStack.Common" to "using ServiceStack".
Change "using ServiceStack.ServiceHost" to "using ServiceStack".
Change "using ServiceStack.ServiceClient" to "using ServiceStack".
Remove "ServiceStack.CacheAccess.x". Add "ServiceStack.Caching".

Miscellaneous

Change TranslateTo to ConvertTo. I also had to add a "using ServiceStack" for this step because AutoMapping has moved namespaces. You'll get conflicts if you are using MVC 5 attribute routing, in which case you'll have to use aliases.
I had to change my LINQ .Single() statements to .First()
Change any string.FromJson() to JsonSerializer.DeserializeFromString(theString)
Change any object.ToJson() to JsonSerializer.SerializeToString(theObject)
In global.asax

The AppHost must inherit from AppHostHttpListenerBase (not ServiceStack.WebHost.Endpoints.AppHostBase)
container.Register<someclassinterface>(someObject) to container.Register(someObject)

In Web.config

Rename ServiceStack.WebHost.Endpoints.ServiceStackHttpHandlerFactory to ServiceStack.HttpHandlerFactory

Managing .NET MVC Complexity with ServiceStack in a Higher Ed Project

2013-12-23T14:24:00.000-08:00

Introduction

This post is for intermediate programmers who are growing their first .NET MVC large-scale project and want a high-level understanding of where ServiceStack can help them manage complexity. I found lots of resources to help me understand the nitty-gritty, but when it came to questions like "where should I put the business logic?" and "how many models of the data should I have?" the answers were "it depends," and while I could find different code examples, I couldn't get a high-level feel for the system. I'll show you the design I ended up with for my higher ed project.

I started with Microsoft .NET: Architecting Applications for the Enterprise and Code Complete Second Edition. I also got a lot of help from Pluralsight videos - a subscription is well worth the money when you are starting out.

I am assuming a working knowledge of dependency injection, separation of concern, cohesion, coupling, and several design patterns: repositories, interfaces, factories, data transfer objects (DTOs), object-to-relational mappers, and unit testing.

System Layers

Small-scale projects often don't need layers. For example, a single-page website could be just one PHP file. ServiceStack has lots of examples for this and their tests show how compact the library can be. But as complexity grows you'll find this approach won't work for lots of reasons that I won't get into. In the PHP world this is where you'll probably adopt a MVC framework, or grow your own. In the .NET world layers are strongly encourage; an MVC project gives you three layers (taken from the official tutorial):

Models: Classes that represent the data of the application and that use validation logic to enforce business rules for that data.
Views: Template files that your application uses to dynamically generate HTML responses.
Controllers: Classes that handle incoming browser requests, retrieve model data, and then specify view templates that return a response to the browser.

Notice that each layer has a particular area of concern: Models know about data and its structure; Views know about HTML and how the users want to see data; Controllers know something about both and handle the communication between them.

So far so good. Nothing new here. Medium-scale projects can live comfortably. But large-scale projects need even more separation of concern. My higher ed project has these four general layers: Presentation (the normal MVC setup), Services, Data Access, and Business Logic with ServiceStack wiring it up. It looks like this:

Presentation Layer

This layer only cares about how to present data to the users/reports/scripts, and validate and collect it from them. It doesn't care how the data is processed and stored. This keeps things as simple as possible. Here is how this shakes out in .NET MVC for a student viewing their recent registrations (I've separated out the student sidebar will be used in all sorts of ways in the project ):

But wait! Where's the data? The Service Layer's DTOs can do double-duty for us for simple stuff like this. Just strongly-type your view to the request object.

(When you need more complexity or an aggregate of DTOs you'll want to create a model for each view. However, it may be simpler to just farm out different pieces of the view using Html.RenderPartial in your view)

Where should my business logic go?

This layer should avoid all business logic. Whatever the student wants to see should be contained in the DTOs, already pre-calculated. However in some cases you'll still do some on-the-fly totals, especially if you're using an AJAX approach to the client-side.

How many models of the data should I have?

This layer talks with the ServiceStack DTOs. If you need to decouple the data further in this layer you'd end up with two models of the data.

The DataClientFactory needs to be injected into your controllers so they can ask for data. There are several ways to do ServiceStack dependency injection.

Service Layer

This layer is... well, it's hard to get a good general definition. I'd rather just give you an example. In my project it does this:

Gets a request object from the Presentation Layer (and sometimes other services in its own layer)
Gets the necessary data from the Data Access Layer
Performs some operation on the data (complex operations should be moved onto the Business Logic Layer)
Returns a response object

In my example the Presentation Layer submits a RecentRegistrationRequest to the Service Layer. It contains a unique identifier for the student. The Service Layer grabs all the data it needs about the student, massages and returns it as a RecentRegistrationResponse. It contains the unique identifier for the student, some student details, some registrations details (something like a List), etc.

The services are grouped by similar functions.

Where should my business logic go?

If the Service Layer needs to iterate the registrations for a student and produce a total attempted credits result for the Presentation Layer there really isn't any need to segregate this off into the Business Logic Layer.

How many models of the data should I have?

This layer doesn't have it's own models of the data. It simply talks with the ServiceStack DTOs and the plain C# objects you define in the Data Access Layer.

Data Access Layer

Here we do CRUD. Try to keep everything else out of this layer. You'll want to understand how persistence shouldn't happen here. Each repository generally takes care of one table (but they are functionally cohesive so they may span several tables). Thanks to ServiceStack's OrmLite this is quite simple. Each table just needs a plain C# class. Note the repository factory and the repository interfaces so we can mock and unit test our Service Layer.

Where should my business logic go?

Sometimes you'll have simple business logic that can live here, like calculating someone's age from date of birth.

How many models of the data should I have?

This layer has a one-class-to-one-table model. You'll also have the ServiceStack DTOs. If you created view-specific models in the Presentation Layer you'll now have three models of the data.

Business Logic Layer

Here is where we do the heavy-lifting. It's a judgement call as to when something needs to live here. For things that are complex such as calculating an invoice for registrations (see below), or perhaps need to be done across multiple services, these are good candidates for this layer.

For my project I want my invoice business logic to be agnostic to how the data is stored and how it is presented to the user, and because I absolutely need unit testing here, everything must be injected. There is a universal factory for building the components and (almost) everything has an interface, depending on whether it has methods I need to mock later.

Where should my business logic go?

When you have complex routines put them here!

How many models of the data should I have?

This layer should talk in business models in my opinion, not in any other model you've created. This brings our total to three models of the data (or four if you created view-specific models in the Presentation Layer).

Summary

Large-scale projects have enough complexity to warrant a Presentation Layer, Service Layer, Data Access Layer, and Business Logic Layer. Each layer has a particular area of concern. ServiceStack wires the layers together.

Where should my business logic go?

I've suggested that there should be some in the Service Layer, some in the Data Access Layer, but the most complex routines should be offloaded to the Business Logic Layer. At the end of the day it still "depends" on the particular project.

How many models of the data should I have?

I've suggested that you'll probably have three models of the data: The ServiceStack DTOs, plain C# objects representing the tables in your database, and business domain models. You could use a fourth data model in the Presentation Layer if you really wanted to, but I've found that binding ServiceStack DTOs directly to the views works well.

To reduce the overhead in translating data between models you could have a look at this post on StackOverflow.

Happy to incorporate different points of view/corrections/suggestions from your comments.

Here is the complete diagram:

Life Doesn't Grow on Trees

2013-01-27T12:19:00.002-08:00

It is one of the oddities of Judeo-Christianity that its followers believe they are created in dependence on their creator, but their creator does not depend on them.

In the ancient world many religions believed that people were created to serve the gods, but that the gods in turn depended on their creatures - a great symbiosis that served both parties. The people provided food, worship, and a temple for their gods, and the gods returned the favour in protection and blessing.

But it is a system of great uncertainty. Why do the gods get angry with us? What can we do to appease them?

It is also a system of great weariness and futility. The point of existence is to maintain the status quo, eke out what you can, and offers no solution to the problem of death.

Sermon audio - http://winnipegcentrevineyard.com/audio/2013.January.6.CamTucker.mp3

God Saves the King

2012-07-30T09:47:00.002-07:00

1 Samuel 24-26

As near as I can tell bitterness comes from a place of unfulfilled promises. They aren't dreams, for we have those aplenty unfulfilled and it doesn't hurt very much.

A dream come true is an expression of utter joy. A dream left in dreamland is an expression of hope, but not despair.

A promise is an entirely different thing.

Sermon audio: http://winnipegcentrevineyard.com/audio/2012.July.29.CamTucker.mp3

Ecclesiastes 1-6 Translation and Study Guide

2012-03-30T05:08:00.000-07:00

My study guide and translation for Ecclesiastes 1-6 is all done!

https://docs.google.com/open?id=0B0mGcUwFcgmpRi0taDVuaUZRYjJPU3ZNTFQ0NWdzdw

If you like it, consider donating a few dollars to the House of Hesed, a transition house for people living with HIV/AIDS in Winnipeg.

February Poem

2012-02-04T13:21:00.001-08:00

Disheveled is an odd word

to explain a home for even in its most

haphazard ways it speaks of you

in happy stacks of books,

whispers of strewn paper letters from friends,

photographs propped like verbs on your windowsill,

and clothing that punctuates here and there

what you looked like yesterday.

And the noun of course is you,

described in a space that isn't really confused

as it is a poem

- that is beautiful -

with no rules.

2011-11-30T11:25:00.001-08:00

Surely there is a moment
when clarity sings a note
of welcome, harbinger

2011-11-13T08:55:00.001-08:00

The beauty and blessing
of the plant mysterious seeded.
A soil that grows it
and finds it flowering.

Critical Realism

2011-11-05T16:03:00.000-07:00

A modern person (a positivist or naive realist) formulates a hypothesis to solve a problem and tests it in order to obtain objective truth about reality. For her this is a sign of immediate unbiased access to the world. But Wright argues she is doing so according to her story, both in the data she accepts to corroborate her hypothesis, and in the hypothesis itself.

For example, if the story she is telling herself about the world includes a god, then this will affect in some way the solutions she proposes to a problem, the questions she asks to prove or disprove whether her solution works, why she asks the questions she does, and what data she accepts. If her story does not include a god, everything looks different. Both versions of the story cannot claim the objective high-ground, according to Wright. But surprisingly neither does he say that both of these stories are equally true - just subjective perspectives (a postmodern or phenomenalist response). Instead he argues that both stories can be tested for how well they explain the world.

"There is no such thing as ‘neutral’ or ‘objective’ proof; only the claim that the story we are now telling about the world as a whole makes more sense, in its outline and detail, than other potential or actual stories that may be on offer. Simplicity of outline, elegance in handling the details within it, the inclusion of all the parts of the story, and the ability of the story to make sense beyond its immediate subject-matter: these are what count." - N.T. Wright, NTPG, p.42

My question is: How does N.T. Wright's prior commitment to history as the primary category for understanding the world affect his approach to epistemology? And what are the other categories available?

It seems to me that Merold Westphal, at least in the first two chapters of Whose Community? Which Interpretation?, is beginning somewhere else. His discussion of hermeneutics up to this point seems to be more about the communication of ideas rather than events.

2011-10-22T14:41:00.000-07:00

Moving far away and
transporting more than
just boxes.

subtly waiting for advent

On Ecclesiastes

2011-09-03T14:43:00.003-07:00

The measure of a person is not
in the control they exercise upon creation,
but in their response to the influence of God upon them
for creation.

December Poem

2011-02-13T15:16:00.002-08:00

Shall we hear with our hearts
and come to love the Maker?
Or will we remain unturned,
and furrowed, and bowed,
straining against the bit and the dust.
Is it a choice or a plan that
drives history to its centre
once more?
Welcome the King, everything crows.
Bow low and kiss the shackles free.

Two men sit facing...

2010-04-29T18:45:00.004-07:00

Two men sit facing the street, joined by blood, separated by choice, both trying to ignore the latter, and bewildered by the former.
"What happened," he asks himself as his teenage son gets phone call after phone call from people he doesn't know and his son won't tell him about. He asks out of fear for his son, and love, for he has heard about what young people get into these days and can hardly forget what he got himself into so many years ago.
He is afraid his son doesn't love him and never will.
He gets up to leave, earlier than he needs to, and calls him "bud" as he awkwardly hugs him from the side. His mother will be along shortly, and he's not interested in seeing her.

The son retrieves his laptop - he always gets what he wants - and reminds himself that no matter what he or the other man feels, he is the one who decides who he is, no one else, and he is the island he desperately needs to be, amidst a sea of other islands; strong, independent, scared. He isn't sure what it means to be grown up, to really love, because it seems like the whole world doesn't have a clue either. The woman on the screen reaches out with everything that she is, wishing he was strong, willing to give him everything so he'll love her.

And God sees the man who hasn't grown up and the son who wishes he had and the woman who is beautiful and both so lonely and the mother who spends weekdays and nights with the boy so powerless to help him become something she isn't even sure exists. And the church across the street is empty, but none of them know or care, just like none of them know or care that God sees, and burns.

Leisure or Sabbath?

2009-03-12T17:51:00.003-07:00

“Leisure and sabbath have much in common: They are both personally restorative, enjoyable, nonutilitarian, and playful. Though sabbath and leisure delightfully overlap, there are discernible differences. Leisure is a matter of personal choice; sabbath is divinely mandated (Exod. 20:8-11). Leisure is usually perceived as avocational – something we do alongside our vocation; sabbath is vocational – part of the response of our entire person to the call of God. Leisure is usually directed to self, while sabbath, which is also personally satisfying, is directed ultimately to the pleasure of God. Both are aesthetic, but leisure tends toward hedonism while sabbath invites contemplation. Sometimes we must admit that leisure is more of a diversion from sabbath than an experience of it.”
- The Equipping Pastor, Stevens and Collins, 1993, p. 86

Eugene on the Song of Songs

2009-01-19T11:20:00.003-08:00

"All pastoral conversation is a conversation between lovers"

(Five Smooth Stones..., Eugene Peterson, p. 44)

Ecclesiastes

2008-12-03T12:05:00.002-08:00

"So I commend the enjoyment of life, because nothing is better for a man under the sun than to eat and drink and be glad. Then joy will accompany him in his work all the days of the life God has given him under the sun" (Eccl. 8:15).

Accepting our human limitations as the gift of God is a difficult task. Look at all the injustice around us! How the poor are mistreated, and millions die in war and famine and meaninglessness. We are bent on fixing the world, and rightly so, for that is God’s work that he is already doing.

But we are tempted to leave behind what it means to be human – finding simple and good pleasure in life – and instead trade it for "super"-human existence, in the guise of self-sacrifice and cross-bearing, that leaves us acting and behaving like gods who "really" know how the world should work, and do our damnedest to see our vision become a reality. Broken families and burned out pastors and church congregations are our legacy. Few know what it means to be human. And then the justice and peace-making we so passionately pursue, though a crucial and central part of being human, not only does not deliver the oppressed, but we are, in fact, never delivered ourselves.

My reaction to Job 38-42

2008-11-05T12:17:00.002-08:00

What can really be said in the face of meaningless suffering? We question life and God, and he and life turn and question us instead. “Who are you,” he asks. “You act like, and strive for knowledge, as if you were god, but you are not. Consider my unfathomable ways.” Is it impossible to ask the meaning of life, for it is beyond our reach? Is our control of our lives only an illusion, just as we fool ourselves into thinking we can control the world? If you believe yourself to be suffering unjustly and meaninglessly, perhaps you have bought into the illusion that you can determine and order your life by righteousness, instead of living by trust. Perhaps you are being tempted to indict God.

Ultimate salvation does not rest with us, for we cannot even save ourselves day to day. Science advances, we live like kings, but cancer laughs at our impotence, and there is no peace in the land, no matter how much we believe in the power of the United Nations. The more we appear to succeed, according to the voices we prefer to listen to, the more believable the illusion becomes, and the more tempted we are to sit in judgement upon God when he won’t get with our program and vindicate our godhood.

What is Job's journey? He admits he has spoken of things he did not understand. Does he include his first and best reaction in 1:21 and 2:10? Perhaps he did not speak wrongly in those cases, but did not really understand. A change of knowledge has happened in his encounter with God. Perhaps his suffering was not ultimately meaningless, as his inner being has been brought into congruity with his words – “The Lord gave and the Lord has taken away; may the name of the Lord be praised.” (1:21)

Wanting to Read Dune

2008-10-13T12:44:00.004-07:00

The more I do Hebrew, and consequently the more I read, "in my father's house," which tends to crop up often, I remember all the talk about "houses" in Frank Herbert's Dune.

Not for the last time do I wonder whether I should have done English as my undergrad and then wrote/read/taught fiction.

Hebrew'ness

2008-09-27T11:01:00.003-07:00

For those who may still be following this blog... perhaps I'll write more when I'm not writing so much for school, which will be done in June/July!

I spent the summer learning Hebrew, and am now in "intermediate" Hebrew.

"Intermediate" may lead you, as it did me, to the conclusion that I would be attaining some sort of proficiency in the language. Sorry to disappoint, but I just spent 45 minutes "translating" Exodus 34:11-13. I must place "translating" in quotations because I purchased BibleWorks and rely heavily upon it. Hopefully Hebrew won't disappear as quickly from my brain as Greek did.

I'm also doing a class on Proverbs/Job/Ecclesiastes. The most interesting thing I've read lately consequently has been Eccl. 3:9-14. The burden of being pulled into the beauty of present and also carrying eternity in our hearts - being a limited and yet unlimited people - can be quite paralyzing, confusing, disheartening. I want to know the meaning of existence, and yet I can often do no better than enjoy a sunset and a cup of coffee; so beautiful in itself, and yet barely scratches the surface.

Consider that the teacher then comes to 3:12-14 where he finally for the first time says, "I know." All his questions, and now he says, "I know" something. What does he know? Give us some answers already! The focus shifts decisively towards God, the one who authors all of this.

Is he good? Can he be trusted? Can we find some sort of rest, caught between limited'ness and unlimited'ness given that this good and trustworthy God has made us this way "so that men will revere him?"

Hmmmm...