Windows has a technology I just stumbled upon that should make a few *nix folks jealous. It’s called Esent. It’s been around since Windows 2000 and is still alive and strong in Windows 7.

What is Esent, you ask? It’s a database engine. No, not like SQL Server, it doesn’t do the T-SQL language. But it is an ISAM database, and it’s got several features of a top-notch database engine. According to this page,

ESENT is an embeddable, transactional database engine. It first shipped with Microsoft Windows 2000 and has been available for developers to use since then. You can use ESENT for applications that need reliable, high-performance, low-overhead storage of structured or semi-structured data. The ESENT engine can help with data needs ranging from something as simple as a hash table that is too large to store in memory to something more complex such as an application with tables, columns, and indexes.

Many teams at Microsoft—including The Active Directory, Windows Desktop Search, Windows Mail, Live Mesh, and Windows Update—currently rely on ESENT for data storage. And Microsoft Exchange stores all of its mailbox data (a large server typically has dozens of terrabytes of data) using a slightly modified version of the ESENT code.

Features
Significant technical features of ESENT include:

• ACID transactions with savepoints, lazy commits, and robust crash recovery.
• Snapshot isolation.
• Record-level locking (multi-versioning provides non-blocking reads).
• Highly concurrent database access.
• Flexible meta-data (tens of thousands of columns, tables, and indexes are possible).
• Indexing support for integer, floating point, ASCII, Unicode, and binary columns.
• Sophisticated index types, including conditional, tuple, and multi-valued.
• Columns that can be up to 2GB with a maximum database size of 16TB.

Note: The ESENT database file cannot be shared between multiple processes simultaneously. ESENT works best for applications with simple, predefined queries; if you have an application with complex, ad-hoc queries, a storage solution that provides a query layer will work better for you.

Wowza. I need 16TB databases, I use those all the time. LOL.

My path to stumbling upon Esent was first by looking at RavenDB, which is rumored to be built upon Esent as its storage engine. Searching for more info on Esent, I came across ManagedEsent, which provides a crazy-cool PersistentDictionary and exposes the native Esent with an API wrapper.

To be quite honest, the Jet-prefixed API points look to be far too low-level for my interests, but some of the helper classes are definitely a step in the right direction in making this API more C#-like.

I’m particularly fascinated, however, by the PersistentDictionary. It’s a really neat, simple way to persist ID’d serializable objects to the hard drive very efficiently. Unfortunately it is perhaps too simple; it does not do away with NoSQL services that provide rich document querying and indexing.

Looks like someone over there at Microsoft who plays with Esent development is blogging: http://blogs.msdn.com/b/laurionb/

Caching is a fundamental component of working software. The role of any cache is to decrease the performance footprint of data I/O by moving it as close as possible to the execution logic. At the lowest level of computing, a thread relies on a CPU cache to be loaded up each time the thread context is switched. At higher levels, caches are used to offload data from a database into a local application memory store or, say, a Lucene directory for fast indexing of data.

Although there are some decent hashtable-become-dictionary scenarios in .NET as it has evolved, until .NET 4.0 there was never a general purpose caching table built directly into .NET. By “caching table” I mean a caching mechanism where keyed items get put into it but eventually “expire” and get deleted, whether by:

a) a “sliding” expiration whereby the item expires in a timespan-determined amount of time from the time it gets added,

b) an explicit DateTime whereby the item expires as soon as that specific DateTime passes, or

c) the item is prioritized and is removed from the collection when the system needs to free up some memory.

There are some methods people can use, however.

Method One: ASP.NET Cache

ASP.NET, or the System.Web.dll assembly, does have a caching mechanism. It was never intended to be used outside of a web context, but it can be used outside of the web, and it does perform all of the above expiration behaviors in a hashtable of sorts.

After scouring Google, it appears that quite a few people who have discussed the built-in caching functionality in .NET have resorted to using the ASP.NET cache in their non-web projects. This is no longer the most-available, most-supported built-in caching system in .NET; .NET 4 has an ObjectCache which I’ll get into later. Microsoft has always been adamant that the ASP.NET cache is not intended for use outside of the web. But many people are still stuck in .NET 2.0 and .NET 3.5, and need something to work with, and this happens to work for many people, even though MSDN says clearly:

Note:

The Cache class is not intended for use outside of ASP.NET applications. It was designed and tested for use in ASP.NET to provide caching for Web applications. In other types of applications, such as console applications or Windows Forms applications, ASP.NET caching might not work correctly.

The class for the ASP.NET cache is System.Web.Caching.Cache in System.Web.dll. However, you cannot simply new-up a Cache object. You must acquire it from System.Web.HttpRuntime.Cache.

Cache cache = System.Web.HttpRuntime.Cache;

Working with the ASP.NET cache is documented on MSDN here.

Pros:

1. It’s built-in.
2. Despite the .NET 1.0 syntax, it’s fairly simple to use.
3. When used in a web context, it’s well-tested. Outside of web contexts, according to Google searches it is not commonly known to cause problems, despite Microsoft recommending against it, so long as you’re using .NET 2.0 or later.
4. You can be notified via a delegate when an item is removed, which is necessary if you need to keep it alive and you could not set the item’s priority in advance.
5. Individual items have the flexibility of any of (a), (b), or (c) methods of expiration and removal in the list of removal methods at the top of this article. You can also associate expiration behavior with the presence of a physical file.

Cons:

1. Not only is it static, there is only one. You cannot create your own type with its own static instance of a Cache. You can only have one bucket for your entire app, period. You can wrap the bucket with your own wrappers that do things like pre-inject prefixes in the keys and remove these prefixes when you pull the key/value pairs back out. But there is still only one bucket. Everything is lumped together. This can be a real nuisance if, for example, you have a service that needs to cache three or four different kinds of data separately. This shouldn’t be a big problem for pathetically simple projects. But if a project has any significant degree of complexity due to its requirements, the ASP.NET cache will typically not suffice.
2. Items can disappear, willy-nilly. A lot of people aren’t aware of this—I wasn’t, until I refreshed my knowledge on this cache implementation. By default, the ASP.NET cache is designed to destroy items when it “feels” like it. More specifically, see (c) in my definition of a cache table at the top of this article. If another thread in the same process is working on something completely different, and it dumps high-priority items into the cache, then as soon as .NET decides it needs to require some memory it will start to destroy some items in the cache according to their priorities, lower priorities first. All of the examples documented here for adding cache items use the default priority, rather than the NotRemovable priority value which keeps it from being removed for memory-clearing purposes but will still remove it according to the expiration policy. Peppering CacheItemPriority.NotRemovable in cache invocations can be cumbersome, otherwise a wrapper is necessary.
3. The key must be a string. If, for example, you are caching data records where the records are keyed on a long or an integer, you must convert the key to a string first.
4. The syntax is stale. It’s .NET 1.0 syntax, even uglier than ArrayList or Hashtable. There are no generics here, no IDictionary<> interface. It has no Contains() method, no Keys collection, no standard events; it only has a Get() method plus an indexer that does the same thing as Get(), returning null if there is no match, plus Add(), Insert() (redundant?), Remove(), and GetEnumerator().
5. Ignores the DRY principle of setting up your default expiration/removal behaviors so you can forget about them. You have to explicitly tell the cache how you want the item you’re adding to expire or be removed every time you add add an item.
6. No way to access the caching details of a cached item such as the timestamp of when it was added. Encapsulation went a bit overboard here, making it difficult to use the cache when in code you’re attempting to determine whether a cached item should be invalidated against another caching mechanism (i.e. session collection) or not.
7. Removal events are not exposed as events and must be tracked at the time of add.
8. And if I haven’t said it enough, Microsoft explicitly recommends against it outside of the web. And if you’re cursed with .NET 1.1, you not supposed to use it with any confidence of stability at all outside of the web so don’t bother.

Method Two: The Enterprise Library Caching Application Block

Microsoft’s recommendation, up until .NET 4.0, has been that if you need a caching system outside of the web then you should use the Enterprise Library Caching Application Block.

The Microsoft Enterprise Library is a coordinated effort between Microsoft and a third party technology partner company Avanade, mostly the latter. It consists of multiple meet-many-needs general purpose technology solutions, some of which are pretty nice but many of which are in an outdated format such as a first-generation O/RM that doesn’t support LINQ.

I have personally never used the EntLib Caching App Block. It looks bloated. Others on the web have commented that they thought it was bloated, too, but once they started using it they saw that it was pretty simple and straightfoward. I personally am not sold, but since I haven’t tried it I cannot pass a fair judgment. So for whatever its worth, here are some pros/cons:

Pros:

1. Recommended by Microsoft as the cache mechanism for non-web projects.
2. The syntax looks to be familiar to those who were using the ASP.NET cache.

Cons:

1. Not built-in. The assemblies must be downloaded and separately referenced.
2. Not actually created by Microsoft. (EntLib is an Avanade solution that Microsoft endorses as its own.)
3. The syntax is the same .NET 1.0 style stuff that I believe defaults to normal priority (auto-ejects the items when memory management feels like it) rather than NotRemovable priority, and does not reinforce the DRY principles of setting up your default expiration/removal behaviors so you can forget about them.
4. Potentially bloated.

Method Three: .NET 4.0’s ObjectCache / MemoryCache

Microsoft finally implemented an abstract ObjectCache class in the latest version of the .NET Framework, and a MemoryCache implementation that inherits and implements ObjectCache for in-memory purposes in a non-web setting.

System.Runtime.Caching.ObjectCache is in the System.Runtime.Caching.dll assembly. It is an abstract class that that declares basically the same .NET 1.0 style interfaces that are found in the ASP.NET cache. System.Runtime.Caching.MemoryCache is the in-memory implementation of ObjectCache and is very similar to the ASP.NET cache, with a few changes.

To add an item with a sliding expiration, your code would look something like this:

var config = new NameValueCollection(); 
var cache = new MemoryCache("myMemCache", config); 
cache.Add(new CacheItem("a", "b"), 
          new CacheItemPolicy 
              { 
                  Priority = CacheItemPriority.NotRemovable, 
                  SlidingExpiration=TimeSpan.FromMinutes(30) 
              });

Pros:

1. It’s built-in, and now supported and recommended by Microsoft outside of the web.
2. Unlike the ASP.NET cache, you can instantiate a MemoryCache object instance.
   Note: It doesn’t have to be static, but it should be—that is Microsoft’s recommendation (see yellow Caution).
3. A few slight improvements have been made vs. the ASP.NET cache’s interface, such as the ability to subscribe to removal events without necessarily being there when the items were added, the redundant Insert() was removed, items can be added with a CacheItem object with an initializer that defines the caching strategy, and Contains() was added.

Cons:

1. Still does not fully reinforce DRY. From my small amount of experience, you still can’t set the sliding expiration TimeSpan once and forget about it. And frankly, although the policy in the item-add sample above is more readable, it necessitates horrific verbosity.
2. It is still not generically-keyed; it requires a string as the key. So you can’t store as long or int if you’re caching data records, unless you convert to string.

Method Four: Build One Yourself

It’s actually pretty simple to create a caching dictionary that performs explicit or sliding expiration. (It gets a lot harder if you want items to be auto-removed for memory-clearing purposes.) Here’s all you have to do:

1. Create a value container class called something like Expiring<T> or Expirable<T> that would contain a value of type T, a TimeStamp property of type DateTime to store when the value was added to the cache, and a TimeSpan that would indicate how far out from the timestamp that the item should expire. For explicit expiration you can just expose a property setter that sets the TimeSpan given a date subtracted by the timestamp.
2. Create a class, let’s call it ExpirableItemsDictionary<K,T>, that implements IDictionary<K,T>. I prefer to make it a generic class with <K,T> defined by the consumer.
3. In the the class created in #2, add a Dictionary<K,Expiring<T>> as a property and call it InnerDictionary.
4. The implementation if IDictionary<K,T> in the class created in #2 should use the InnerDictionary to store cached items. Encapsulation would hide the caching method details via instances of the type created in #1 above.
5. Make sure the indexer (this[]), ContainsKey(), etc., are careful to clear out expired items and remove the expired items before returning a value. Return null in getters if the item was removed.
6. Use thread locks on all getters, setters, ContainsKey(), and particularly when clearing the expired items.
7. Raise an event whenever an item gets removed due to expiration.
8. Add a System.Threading.Timer instance and rig it during initialization to auto-remove expired items every 15 seconds. This is the same behavior as the ASP.NET cache.
9. You may want to add an AddOrUpdate() routine that pushes out the sliding expiration by replacing the timestamp on the item’s container (Expiring<T> instance) if it already exists.

Microsoft has to support its original designs because its user base has built up a dependency upon them, but that does not mean that they are good designs.

Pros:

1. You have complete control over the implementation.
2. Can reinforce DRY by setting up default caching behaviors and then just dropping key/value pairs in without declaring the caching details each time you add an item.
3. Can implement modern interfaces, namely IDictionary<K,T>. This makes it much easier to consume as its interface is more predictable as a dictionary interface, plus it makes it more accessible to helpers and extension methods that work with IDictionary<>.
4. Caching details can be unencapsulated, such as by exposing your InnerDictionary via a public read-only property, allowing you to write explicit unit tests against your caching strategy as well as extend your basic caching implementation with additional caching strategies that build upon it.
5. Although it is not necessarily a familiar interface for those who already made themselves comfortable with the .NET 1.0 style syntax of the ASP.NET cache or the Caching Application Block, you can define the interface to look like however you want it to look.
6. Can use any type for keys. This is one reason why generics were created. Not everything should be keyed with a string.

Cons:

1. Is not invented by, nor endorsed by, Microsoft, so it is not going to have the same quality assurance.
2. Assuming only the instructions I described above are implemented, does not “willy-nilly” clear items for clearing memory on a priority basis (which is a corner-case utility function of a cache anyway .. BUY RAM where you would be using the cache, RAM is cheap).

Among all four of these options, this is my preference. I have implemented this basic caching solution. So far, it seems to work perfectly, there are no known bugs (please contact me with comments below or at jon-at-jondavis if there are!!), and I intend to use it in all of my smaller side projects that need basic caching. Here it is: 

Download: ExpirableItemDictionary.zip

Worthy Of Mention: AppFabric, NoSQL, Et Al

Notice that the title of this blog article indicates “Simple Caching”, not “Heavy-Duty Caching”. If you want to get into the heavy-duty stuff, you should look at memcached, AppFabric, ScaleOut, or any of the many NoSQL solutions that are shaking up the blogosphere and Q&A forums.

By “heavy duty” I mean scaled-out solutions, as in scaled across multiple servers. There are some non-trivial costs associated with scaling out

Scott Hanselman has a blog article called, “Installing, Configuring and Using Windows Server AppFabric and the ‘Velocity’ Memory Cache in 10 Minutes”. I already tried installing AppFabric, it was a botched and failed job, but I plan to try to tackle it again, now that hopefully Microsoft has updated their online documentation and provided us with some walk-throughs, i.e. Scott’s.

As briefly hinted in the introduction of this article, another approach to caching is using something like Lucene.Net to store database data locally. Lucene calls itself a “search engine”, but really it is a NoSQL [Wikipedia link] storage mechanism in the form of a queryable index of document-based tables (called “directories”).

Other NoSQL options abound, most of them being Linux-oriented like CouchDB (which runs but stinks on Windows) but not all of them. For example, there’s RavenDB from Oren Eini (author of the popular ayende.com blog) which is built entirely in and for .NET as a direct competitor to the likes of Lucene.net. There are a whole bunch of other NoSQL options listed over here.

I have had the pleasure of working with Lucene.net and the annoyance of poking at CouchDB on Windows (Linux folks should not write Windows software, bleh .. learn how to write Windows services, folks), but not much else. Perhaps I should take a good look at RavenDB next.

When Google announced their new Go programming language, I was quite excited and happy. Yay, another language to fix all the world’s problems! No more suckage! Suckage sucks! Give me a good language that doesn’t suffer suckage, so that my daily routine can suck less!

And Google certainly presented Go as “a C++ fixxer-upper”. I just watched this video of Rob Pike describing the objectives of Go, and I can definitely say that Google’s mantra still lines up. The video demonstrates a lot of evils of C++. Despite some attempts at self-edumacation, I personally cannot read nor write real-world C++ because I get lost in the gobbligook that he demonstrated.

But here’s my comment on YouTube:

100% of the examples of "why C++ and Java suck" are C++. Java's not anywhere near that bad. Furthermore, The ECMA open standard language known as C#--brought about by a big, pushy company no different in this space than Google--already had the exact same objectives as Java and now Go had, and it has actually been fundamentally evolving at the core, such as to replace patterns with language features (as seen in lambdas and extension methods). Google just wanted to be INDEPENDENT, typical anti-MS.

While trying to take Go in with great excitement, I’ve been forced to conclude that Google’s own message delivery sucks, mainly by completely ignoring some of the successful languages in the industry—namely C# (as well as some of the lesser-used excellent languages out there)—much like Microsoft’s message delivery of C#’s core objectives somewhat sucked by refraining from mentioning Java even once when C# was announced (I spent an hour looking for the C# announcement white paper from 2000/2001 to back up this memory but I can’t find it). The video linked above doesn’t even show a single example of Java suckage; it just made these painful accusations of Java being right in there with C++ as being a crappy language to work with. I haven’t coded in Java in about a decade, honestly, but back then Java was the shiznat and code was beautiful, elegant, and more or less easy to work with.

Meanwhile, Java has been evolving in some strange ways and ultimately I find it far less appetizing than C#. But where is Google’s nod to C#? Oh that’s right, C# doesn’t exist, it’s a fragment of someone’s imagination because Google considers Microsoft (C#’s maintainer) a competitor, duh. This is an attitude that should make anyone automatically skeptical of the language creator’s true intentions, and therefore of the language itself. C# actually came about in much the same way as Go did as far as trying to “fix” C++. In fact, most of the problems Go describes of C++ were the focus of C#’s objectives, along with a few thousand other objectives. Amazingly, C# has met most of its objectives so far.

If we break down Google’s objectives themselves, we don’t see a lot of meat. What we find, rather, are Google employees trying to optimize their coding workflow for previously C++ development efforts using perhaps emacs or vi (Rob even listed IDEs as a failure in modern languages). Their requirements in Go actually appear to be rather trivial. It seems that they want to write quick-and-easy C-syntax-like code that doesn’t get in the way of their business objectives, that performs very fast, and fast compilation that lets them escape out of vi to invoke gcc or whatever compiler very quickly and go back to coding. These are certainly great nice-to-haves, but I’m pretty sure that’s about it.

Consider, in contrast, .NET’s objectives a decade ago, .NET being at the core of applied C# as C# runs on the CLR (the .NET runtime):

• To provide a very high degree of language interoperability
  • Visual Basic and C++ and Java, oh my! How do we get them to talk to each other with high performance?
  • COM was difficult to swallow. It didn’t suck because its intentions were gorgeous—to have a language-netural marshalling paradigm between runtimes—but then the same objectives were found in CORBA, and that sucked.
  • Go doesn’t even have language interoperability. It has C (and only C) function invocators. Bleh! Google is not in the real world!
• To provide a runtime environment that completely manages code execution
  • This in itself was not a feature, it was a liability. But it enabled a great deal, namely consolidating QA resources for low-level functionality, which in turn brought about instantaneous quality and productivity on Microsoft’s part across the many languages and the tools because fewer resources had to focus on duplicate details.
  • The Mono runtime can run a lot of languages now. It is slower than C++, but not by a significant level. A C# application, fully ngen’d (precompiled to machine-level code), will execute at roughly 90-95% of C++’s and thus theoretically Go’s performance, which frankly is pretty darn good.
• To provide a very simple software deployment and versioning model
  • A real-world requirement which Google in its corporate and web sandboxes is oblivious to, I’m not sure that Go even has a versioning model
• To provide high-level code security through code access security and strong type checking
  • Again, a real-world requirement which Google in its corporate and web sandboxes is oblivious to, since most of their code is only exposed to the public via HTML/REST/JSON/SOAP.
• To provide a consistent object-oriented programming model
  • It appears that Go is not an OOP language. There is no class support in Go. No objects at all, really. Just primitives, arrays, and structs. Surpriiiiise!! :D
• To facilitate application communication by using industry standards such as SOAP and XML.
  • Google innovated with Protocol Buffers, but I don’t see any of that in Go’s current strategy, at least not yet.
    • .. to which I must point out: http://blogs.tedneward.com/2008/07/11/So+You+Say+You+Want+To+Kill+XML.aspx
• To simplify Web application development
  • I really don’t see Google innovating here, instead they push Python and Java on their app cloud? I most definitely don’t see this applying to Go at all.
• To support hardware independence and portability
  • Although the implementation of this (JIT) is a liability, the objective is sound. Old-skool Linux folks didn’t get this; it’s stupid to have to recompile an application’s distribution, software should be precompiled.
  • Java and .NET are on near-equal ground here. When Java originally came about, it was the silver bullet for “Write Once, Run Anywhere”. With the successful creation and widespread adoption of the Mono runtime, .NET has the same portability. Go, however, requires recompilation. Once again, Google is not out in the real world, they live in a box (their headquarters and their exposed web).

And with the goals of C#,

• C# language is intended to be a simple, modern, general-purpose, object-oriented programming language.
  • Go: “OOP is cruft.”
• The language, and implementations thereof, should provide support for software engineering principles such as strong type checking, array bounds checking, detection of attempts to use uninitialized variables, and automatic garbage collection. Software robustness, durability, and programmer productivity are important.
  • Go: “Um, check, maybe. Especially productivity. Productivity means clean code.”
  • (As I always say, the more you know, the more you realize how little you know. Clearly you think you’ve got it all down, little Go.)
• The language is intended for use in developing software components suitable for deployment in distributed environments.
  • Go: “Yeah we definitely want that. We’re Google.”
• Source code portability is very important, as is programmer portability, especially for those programmers already familiar with C and C++.
  • Go: “Just forget C++. It’s bad. But the core syntax (curly braces) is much the same, so ... check!”
• Support for internationalization is very important.
  • Go: “Check! Check out my samples, I can take Chinese characters in my strings as part of the source code! Oh yes!”
  • (I think Go misses the point here. Rich internationalization support goes far beyond Unicode strings. *facepalm* But since Go has zero support for GUIs, little of internationalization really applies.)
  • http://golang.org/search?q=international
  • http://golang.org/search?q=internationalization
  • http://golang.org/search?q=globalization
  • http://golang.org/search?q=i18n
• C# is intended to be suitable for writing applications for both hosted and embedded systems, ranging from the very large that use sophisticated operating systems, down to the very small having dedicated functions.
  • Go: “Check!”
  • (Yeah, except that Go isn’t an applications platform. At all. So, no. Uncheck that.)
• Although C# applications are intended to be economical with regard to memory and processing power requirements, the language was not intended to compete directly on performance and size with C or assembly language.

Right now, Go just looks like a syntax with a few basic support classes for I/O and such. I must confess I was somewhat unimpressed by what I saw at Go’s web site (http://golang.org/) because the language does not look like much of a readability / maintainability improvement to what Java and C# offered up.

• Go supposedly offers up memory management, but still heavily uses pointers. (C# supports pointers, too, by the way, but since pointers are not safe you must declare your code as “containing unsafe code”. Most C# code strictly uses type-checked references.)
• Go eliminates semicolons as statement terminators. “…they are inserted automatically at the end of every line that looks like the end of a statement…” Sorry, but semicolons did not make C++ unreadable or unmaintainable
  Personally I think code without punctuation (semicolons) looks like English grammar without punctuations (no period)
  You end up with what look like run-on sentences
  Of course they’re not run-on sentences, they’re just lazily written ones with poor grammar
  wat next, lolcode?
• “{Sample tutorial code} There is no implicit this and the receiver variable must be used to access members of the structure.” Wait, what, what? Hey, I have an idea, let’s make all functions everywhere static!
• Actually, as far as I can tell, Go doesn’t have class support at all. It just has primitives, arrays, and structs.
• Go uses the := operator syntax rather than the = operator for assignment. I suppose this would help eliminate the issue where people would type = where they meant to type == and destroy their variables.
• Go has a nice “defer” statement that is akin to C#’s using() {} and try...finally blocks. It allows you to be lazy and disorganized such that late-executed code that should called after immediate code doesn’t require putting it below immediate code, we can just sprinkle late-executed code in as we go. We really needed that. (Except, not.) I think defer’s practical applicability is for some really lightweight AOP (Aspect Oriented Programming) scenarios, except that defer is a horrible approach to it.
• Go has both new() and make(). I feel like I’m learning C++ again. It’s about those pesky pointers ...
  • Seriously, how the heck is
     
      var p *[]int = new([]int) // allocates slice structure; *p == nil; rarely useful
      var v  []int = make([]int, 100) // the slice v now refers to a new array of 100 ints
     
    .. a better solution to “improving upon” C++ with a new language than, oh I don’t know ..
     
      int[] p = null; // declares an array variable; p is null; rarely useful
      var v = new int[100]; // the variable v now refers to a new array of 100 ints
     
    ..? I’m sure I’m missing something here, particularly since I don’t understand what a “slice” is, but I suspect I shouldn’t care. Oh, nevermind, I see now that it “is a three-item descriptor containing a pointer to the data (inside an array), the length, and the capacity; until those items are initialized, the slice is nil.” Great. More pointer gobbligook. C# offers richly defined System.Array and all this stuff is transparent to the coder who really doesn’t need to know that there are pointers, somewhere, associated with the reference to your array, isn’t that the way it all should be? Is it really necessary to have a completely different semantic (new() vs. make())? Ohh yeah. The frickin pointer vs. the reference.
• I see Go has a fmt.Printf(), plus a fmt.Fprintf(), plus a fmt.Sprintf(), plus Print() plus Println(). I’m beginning to wonder if function overloading is missing in Go. I think it is; http://golang.org/search?q=overloading
• Go has “goroutines”. It’s basically, “go func() { /* do stuff */ }” and it will execute the code as a function on the fly, in parallel. In C# we call these anonymous delegates, and delegates can be passed along to worker thread pool threads on the fly with only one line of code, so yes, it’s supported. F# (a young .NET sibling of C#) has this, too, by the way, and its support for inline anonymous delegate declarations and spawning them off in parallel is as good as Go’s.
• Go has channels for communication purposes. C# has WCF for this which is frankly a mess. The closest you can get to Go on the CLR as far as channels go is Axum, which is variation of C# with rich channel support.
• Go does not throw exceptions. It panics, from which it might recover.

While I greatly respect the contributions Google has made to computing science, and their experience in building web-scalable applications (that, frankly, typically suck at a design level when they aren’t tied to the genius search algorithms), and I have no doubt that Google is an experienced web application software developer with a lot of history, honestly I think they are clueless when it comes to real-world applications programming solutions. Microsoft has been demonized the world over since its beginnings, but one thing they and few others have is some serious, serious real-world experience with applications. Between all of the web sites and databases and desktop applications combined everywhere on planet Earth through the history of man, Microsoft has probably been responsible for the core applications plumbing for the majority of it all, followed perhaps by Oracle. (Perhaps *nix and applications and services that run on it has been the majority; if nothing else, Microsoft has most certainly still had the lead in software as a company, to which my point is targeted.)

It wasn’t my intention to make this a Google vs. Microsoft debate, but frankly the fact that Go presentations neglect C# severely causes question to Go’s trustworthiness.

In my opinion, a better approach to what Google was trying to do with Go would be to take a popular language, such as C#, F#, or Axum, and break it away from the language’s implementation libraries, i.e. the .NET platform’s BCL, replacing them with the simpler constructs, support code, and lightweight command-line tooling found in Go, and then wrap the compiler to force it to natively compile to machine code (ngen). Honestly, I think that would be both a) a much better language and runtime than Go because it would offer most of the benefits of Go but in a manner that retains most or all of the advantages of the selected runtime (i.e. the CLR’s and C#’s multitude of advantages over C/C++), but also b) a flop, and a waste of time, because C# is not really broken. Coupled with F#, et al, our needs are quite well met. So thanks anyway, Google, but, really, you should go now.

In the Development branch of Gemli.Data, I finally got around to adding some very, very basic LINQ support. The following test scenarios currently seem to function correctly:

var myCustomEntityQuery = new DataModelQuery<DataModel<MockObject>>();

// Scenarios 1-3: Where() lambda, boolean operator, method exec
var linqq = myCustomEntityQuery.Where(mo => mo.Entity.MockStringValue == "dah");
    linqq = myCustomEntityQuery.Where(mo => mo.Entity.MockStringValue != "dah");
    // In the following scenario, GetPropertyValueByColumnName() is an explicitly supported method
    linqq = myCustomEntityQuery.Where(mo=>((int)mo.GetPropertyValueByColumnName("customentity_id")) > -1);

// Scenario 4: LINQ formatted query
var q = (from mo in myCustomEntityQuery
         where mo.Entity.MockStringValue != "st00pid"
         select mo) as DataModelQuery<DataModel<MockObject>>;

// Scenario 5: LINQ formatted query execution with sorted ordering
var orderedlist = (from mo in myCustomEntityQuery
                   where mo.Entity.MockStringValue != "def"
                   orderby mo.Entity.MockStringValue
                   select mo).ToList();

// Scenario 6: LINQ formatted query with multiple conditions and multiple sort members
var orderedlist = (from mo in myCustomEntityQuery
                    where mo.Entity.MockStringValue != "def" && mo.Entity.ID < 3
                    orderby mo.Entity.ID, mo.Entity.MockStringValue
                    select mo).ToList();

This is a great milestone, one I’m very pleased with myself for finally accomplishing. There’s still a ton more to do but these were the top 50% or so of LINQ support scenarios needed in Gemli.Data.

Unfortunately, adding LINQ support brought about a rather painful rediscovery of critical missing functionality: the absence of support for OR (||) and condition groups in Gemli.Data queries. *facepalm*  I left it out earlier as a to-do item but completely forgot to come back to it. That’s next on my plate. *burp*

We get it, Microsoft. You want us to use Azure. You want us to build highly scalable software that will run in the cloud—your cloud. And we’ll get the wonderful support from Microsoft if we choose Azure. Yes, Microsoft. We get it.

We’re not stupid. You play up Azure like it’s a development skill, or some critical piece of the Visual Studio development puzzle, but we recognize that Azure is a proprietary cloud service that you’re advertising, not an essential tool chain component. Now go away. Please. Stop diluting the MSDN Magazine articles and the msdev Facebook app status posts with your marketing drivel about Azure. You are not going to get any checks written out from me for hosted solutions. We know that you want to profit from this. Heck, we even believe it might actually be a half-decent hosting service. But, Microsoft, you didn’t invent the cloud, there are other clouds out there, so tooling for your operating system using Visual Studio does not mean that I need to know diddly squat about your tirelessly hyped service.

There are a lot of other things you can talk about and still make a buck off of your platform. You can talk about how cool WPF is as a great way to build innovative Windows-only products. You can focus on how fast SQL Server 2008 R2 is and how Oracle wasted their money on a joke (mySQL). You can play up the wonderful extensibility of IIS 7 and all the neat kinds of innovative networked software you can build with it. Honestly, I don’t even know what you should talk about because you’re the ones who know the info, not me.

But Microsoft it’s getting really boring to hear the constant hyping of Azure. I’ve already chosen how my stuff will be hosted, and that’s not going to change right now. So honestly, I really don’t care.

Maybe I need to explain why I don’t care.

Microsoft, there are only two groups of people who are going to choose your ridiculously wonderful and bloated cloud: established mid-market businesses with money to spend, and start-ups with a lot of throw-away capital who drank your kool aid. You shouldn’t worry about those people. The people you should worry about are those who will choose against it, and will have made their decision firmly.

First of all, I believe most enterprises will not want to put their data on a cloud, certainly not with a standardized set of cloud interfaces. It’s too great a security risk. Amazon’s true OS cloud is enticing because companies can roll their own APIs with proprietary APIs and have them talk to each other while rolling out VM instances on a whim. They have sufficient tooling outside of cloud-speak to write what they need and to do what needs doing. But for the most part, companies want to keep internal data internal.

Second, we geeks don’t fiddle a whole lot with accounting and taking corporate risks. We focus on writing code. That code has to be portable. It has to run locally, on a dedicated IIS server, or in a cloud. Writing code that deploys to your cloud—whether a true cloud or locally for testing, it doesn’t matter—if it doesn’t run equally well in other environments it’s at best a redundant effort and at worst a potentially wasted one. We have to write code for your cloud and then we have to write code for running without your cloud. We most certainly would not be comfortable writing code that only runs on your cloud, but the mangled way your cloud APIs are marketed we might as well bet the whole farm on it. And that just ain’t right.

See, I don’t like going into anything not knowing I can pull out and look at alternatives at any time without having completely wasted my efforts. If I’m going to write code for Azure, I want to be assured that the code will have the same functionality outside of Azure. But since Azure APIs only run in the Azure cloud, and Azure cannot be self-hosted (outside of localhost debugging), I don’t have that assurance. Hence, I as a geek and as an entrepreneur have no interest in Azure.

When I choose a tool chain, I choose it for its toolset, not for its target environment. I already know that Windows Server with IIS is adequate for the scale of runtimes I work with. When I choose a hosting service, I choose it expecting to be very low-demand but with potential for high demand. I don’t want to pay out the nose for that potential. I often experiment with different solutions and discover a site’s market potential. But I don’t go in expecting to make a big buck—I only go in hoping to.

What would gain my interest in Azure? Pretty much the only thing that would have me give Azure even a second glance would be a low-demand (low traffic, low CPU, low storage, and low memory) absolutely free account, whereby I am simply billed if I go over my limit. If free’s no good, then a flat ridiculously low rate, like $10/mo for reasonable usage and a reasonable rate when I go over. A trial is unacceptable. I’m not going to develop for something that is going to only be a trial. And I also prefer a reasonable flat rate for low-demand usage over a generated-per-use one. I prefer to have an up-front idea of how much things will cost. I don’t have time to keep adjusting my budget. I don’t want to have to get billed first in order to see what my monthly cost will be.

I’m actually paying quite a bit of money for my Windows 2008 VPS, but the nice thing about it is there are no surprises, the server will handle the load, and if I ever exceed its capacity I can just get another account. Whereas, cloud == surprises. You have to do a lot of manual number crunching in order to determine what your bill is going to look like. “Got a lot of traffic this month? We got you covered, we automatically scaled for you. Now here’s your massive bill!”

Let’s put it this way, Microsoft. If you keep pushing Azure at me, I can abandon your tool chain completely and stick with my other $12/mo Linux VM that would meet my needs for a low-demand server on which I still have the support of some magnificent open source communities, and if my needs grow I can always instance another $12/mo account. Honestly, the more diluted the developer discussions are with Azure hype, the more inclined I am to go down that path. (Although, I’ll admit it’ll take a lot more to get me to go all the way with that.)

Just stop, please. I have no problem with Azure, you can put your banner ads and printed ads into everything I touch, I’m totally fine with that. What is really upsetting to me is when magazine and related content, both online and printed, is taken up to hype your proprietary cloud services, and I really feel like I’m getting robbed as an MSDN subscriber.

Just keep in mind, we’re not stupid. We do know service marketing versus helpful development tips when we see it. You’re only hurting yourselves when you push the platform on us like we’re lemmings. Speaking for myself, I’m starting to dread what should have been a wonderful year of 2010 with the evolution of the Microsoft tool chain.

[UPDATE: According to this, Azure will someday be independently hostable. That's better. Now I might start paying attention.] 

It occurred to me that I’m not blogging enough about how Gemli is shaping, other than mentioning the project on the whole in completely different blog posts.

In the dev branch I’ve dropped the abstract base DataModelQuery class (only DataModelQuery<TModel> remains) and replaced it with an IDataModelQuery interface. This was a long-needed change, as I was really only using it for its interfaces anyway. It was being used because I didn’t necessarily know the TModel type until runtime, namely in the DataProviderBase class which handles all the deep loads with client-side-joins-by-default behavior. But an interface will work for that just as well, and meanwhile the query chaining syntax behavior was totally inconsistent and in some cases useless.

Some recent changes that have been made in the dev branch include some more syntactical sugar, namely the support for loading and saving directly from a DataModel/DataModel<T> class or from a DataModelQuery<TModel> plus support for pagination and getting record counts.

Quick Loads

From DataModel:

List<MyPoco> collectionOfMyPoco = DataModel<MyPoco>.LoadAll().Unwrap<MyPoco>();

There are also Load() and LoadMany() on DataModel, but since they require a DataModelQuery object as a parameter, and DataModelQuery has new SelectFirst() and SelectMany() that do the same thing (forward the task on to the DataProvider), I’m not sure they’re needed and I might just delete them.

From DataModelQuery:

List<MyPoco> collectionOfMyPoco = DataModel<MyPoco>.NewQuery()
    .WhereProperty["Amount"].IsGreaterThan(5000m)
    .SelectMany().Unwrap<MyPoco>();

Pagination

Since Gemli is being built for web development, pagination support with pagination semantics (“page 3”, rather than “the rows between rows X and Y”) is a must. There are many things besides data grids that require pagination—actually, pretty much any list needs pagination if you intend not to show as many items on a page as there are in a database table.

Client-side pagination is implemented by default, but only if DB server-side pagination is not handled by the data provider. I still intend to add DB-side pagination for SQL Server.

// get rows 61-80, or page 4 @ 20 items per page, of my filtered query
var myListOfStuff = DataModel<Stuff>.NewQuery()
    .WhereProperty["IsActive"].IsEqualTo(true)
    .Page[4].OfItemsPerPage(20)
    .SelectMany().Unwrap<Stuff>();

To add server-side pagination support for a proprietary database, you can inherit DbDataProvider and override the two variations of CreateCommandBuilder() (one takes a DataModel for saving, the other takes a DataModelQuery for loading). The command builder object has a HandlePagination property that can be assigned a delegate. The delegate would then add or modify properties in the command builder that inject appropriate SQL text into the command.

Count

Support for a basic SELECT COUNT(*) FROM MyTable WHERE [..conditions..] is a pretty obvious part of any minimal database interaction library (O/RM or what have you). For this reason, GetCount<TModel>(DataModelQuery query) has been added to DataProviderBase, and in DbDataProvider it replaces the normal LoadModel command builder generated text with SELECT COUNT(*)…  The DataModelQuery<TModel> class also has a new SelectCount() method which forwards the invocation to the DataProvider.

long numberOfPeepsInMyNetwork = DataModel<Person>.NewQuery()
    .WhereProperty["Networkid"].IsEqualTo(myNetwork.ID)
    .SelectCount();

All of these changes are still pending another alpha release later. But if anyone wants to tinker it’s all in the dev branch in source code at http://gemli.codeplex.com/ .

LINQ May Be Coming

I still have a lot of gruntwork to do to get this next alpha built, particularly in adding a lot more tests. I still haven’t done enough testing of deep loads and deep saves and I’m not even confident that deep saves are working correctly at the basic level as I haven’t yet used them. Once all of that is out of my way, I might start looking at adding LINQ support. I’m not sure how awfully difficult LINQ support will prove to be yet, but I’m certain that it’s doable.

One of the biggest advantages of LINQ support is strongly typed member checking. For example, in Gemli, you currently have to declare your WHERE clauses with a string reference to the member name or the column name, whereas with LINQ the member name can be referenced as strongly-typed code. As far as I know, it does this by way of syntactic sugar that ultimately boils down to delegates that literally work with the object directly, depending on how the LINQ support was added.

Among the other advantages of adding LINQ support might be in adding support for anonymous types. For example, right now without LINQ you’re limited to DataModels and the class structures they represent. But LINQ lets you select specific members into your return object, for example, rather than the whole enchilada.

LINQ:

// only return ID and Name, not the whole Product
var mySelection = (from p in Product
                   select p.ID, p.Name).ToList();

It’s this underlying behavior that creates patterns for me to work with that I might drag into play the support for aggregate functions in SQL using terse Gemli+LINQ semantics. Right now, it’s literally impossible for Gemli to select the result of an aggregate function (other than Count(*)) unless that was wrapped in a stored procedure on the DB side and then wrapped in a DataModel on Gemli’s side. There’s also no GROUP BY support, etc. I like to believe that LINQ will help me consolidate the interface patterns I need to make all that work correctly. However, so far I’m still just one coder as no one has jumped on board with Gemli yet so we’ll see if LINQ support makes its way in at all.

Earlier this late night I posted the first major overhaul update of Gemli since a month ago. This brings a huge number of design fixes and new features to Gemli.Data and makes it even more usable. It's still alpha, though, as there's a lot more testing to be done, not to mention still some new features to be added.

http://gemli.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=33281

From the release notes:

• Added to DataProviderBase: SupportsTransactions { get; } , BeginTransaction(), and BeginTransaction(IsolationLevel)
• Facilitate an application default provider: Gemli.Data.Providers.ProviderDefaults.AppProvider = myDBProvider .. This allows DataModels and DataModelCollections to automatically use the application's data provider when one hasn't already been associated with the model (so you can, for example, invoke .Save() on a new model without setting its provider manually)
• Replace (and drop) TypeConvertor with DbTypeConverter.
• Operator overloads on DataModelQuery; you can now use == instead of IsEqualTo(), but this comes at the cost of chainability. (IsEqualTo() is still there, and still supports chaining.)
• Added SqlDbType attribute property support. DataType attribute value is no longer a DbType and is instead a System.Type. The properties DbType and SqlDbType have been added, and setting any of these three properties will automatically translate and populate the other two.
• DataType attribute value is no longer a DbType and is instead a System.Type. The properties DbType and SqlDbType have been added, and setting any of these three properties will automatically translate and populate the other two.
• WhereMappedColumn is now WhereColumn
• Facilitate optional behavior of inferring from all properties not marked as ignore, rather than the behavior or inferring from none of the unattributed properties unless no properties are attributed. The latter behavior--the old behavior--currently remains the default. The new behavior can be applied with DataModelTableMappingAttribute's PropertyLoadBehavior property
  • This may change to where the default is InferProperties.NotIgnored (the new behavior), still pondering on this.
• Add sorting to MemoryDataProvider
• TempMappingTable is now DataModelMap.RuntimeMappingTable
• ForeignDataModel.ForeignXXXX was backwards and is now RelatedXXXX (multiple members)
• DataModelFieldMappingAttribute is now DataModelColumnAttribute.
• DataModelMap.FieldMappings is now DataModelMap.ColumnMappings.
• DataModelTableMappingAttribute is now DataModelTableAttribute.
• DataModelForeignKeyAttribute is now ForeignKeyAttribute.
• The XML serialization of all elements now follows these renamings and is also now camelCased instead of ProperCase.
• XML loading of mapping configuration is getting close, if it isn't already there. Need to test.
• Added DataModelMap.LoadMappings(filePath)

As a Microsoft customer, who at times rambles on with a fair share of complaints about Microsoft’s doings, I want to take a moment to discuss Microsoft’s successes in making its development stack affordable, equal to or even more so I’d argue than the LAMP + Adobe stacks.

Let’s Get Started

If you’re developing for the web, Microsoft makes it easy to download everything you need to develop on the Microsoft stack for free with a do-it-all download application called the Microsoft Web Platform. Everything you need to get started is available from that tool for free, including (but not limited to):

• Visual Web Developer 2008 Express (FREE)
• Silverlight tools for Visual Web Developer (FREE)
• Microsoft SQL Server 2008 Express (FREE)
• IIS extensions such as FastCGI for running PHP applications (FREE)
• ASP.NET add-on libraries, including ASP.NET MVC (FREE)
• Tons of free, open source ASP.NET applications (FREE)
• Tons of free, open source PHP applications that can run on IIS (on Windows) (FREE)

I’ll even go so far as to repost a pretty Microsoft-provided button.

(FREE)

Windows

Let’s get the obvious realities of Microsoft stack expenses out of the way first. Microsoft is a platforms company. They make their money off of our dependence upon their platform. That platform is Windows. Many people’s reaction to this is to hold up two fingers to make a cross and shout, “Eww, nooo! No! Monopolies, baaad!” I believe I have a more well-rounded response, which is, “Oh! Well dang. If we’re going to build up a dependency upon a platform, that platform (and its sub-platforms) had better be REALLY FREAKING GOOD—good as in performant, easy to work with, reliable, scalable, and a joy to use, and it had better support all the things most all the other platforms support.”

Enter Windows Server 2008 and Windows 7.

Over the last decade, Microsoft has worked hard to achieve, and since Windows Vista (believe it or not) has already achieved, the right to sing the song to Linux,

Anything you can do,
I can do better!
I can do anything
better than you!

And yeah I think Microsoft gets the girl’s part on this one, but perhaps only because of:

Boy: I can live on bread and cheese.

Girl: And only on that?

Boy: Yup.

Girl: So can a rat.

By this I simply mean that everything that’s on the Linux stack is also on the Windows stack, plus Microsoft has its own proprietary equivalents that, in the opinions of most of its customers, are a lot better than the open source equivalents. Take PHP for example. Internet Information Server 7 does everything Apache can do plus host non-HTTP network applications, but it also does everything Apache does, functionally speaking, including configuration details and hosting PHP. But it also performs faster than Apache at hosting PHP applications with Fast-CGI and binary script caching installed and enabled. But beyond PHP, which in itself is technically not much more than ASP Classic (Javascript flavor), Microsoft’s ASP.NET is far more powerful and versatile than PHP, and it’s 100% free (after the cost of Windows itself). And don’t get me started about how much better I think Windows is at GUIs and graphics with GDI+, DirectX, and WPF, than the Linux flavors. (Apple, on the other hand, competes pretty well.)

Windows can also execute all the Java and Ruby stuff that you see in *nix platforms. In fact, Windows has all the UNIX subsystem underpinnings to make a UNIX enthusiast comfortable. The shell and all that fluff is a separate download but it’s all part of the Windows package and is free after the full Windows Ultimate or Windows Server license. You can snag Cygwin, too, if you like, if you want to get an even richer Linux-like experience.

So that’s Windows; you can go fully-licensed and get Windows 7 Ultimate ($219) + Windows Server 2008 R2 ($999) as a workstation + server combo for a total of $1,218 plus tax. However, if you’re in a position to care about that much money, I can tell you that you do not have to suffer that amount if you don’t want to.

First of all, Windows 7 Ultimate can perform just fine as a server. Windows Server 2008 is intended more for an enterprise environment that requires prison-like security and needs some very enterprisey or advanced features, such as hosting Active Directory domains, hosting Exchange Server, or hosting some unusual network services for developers with very specialized needs. If all your needs can be met with IIS and a database, so long as you don’t have a million hits a month (there is, unfortunately, simultaneous network connection count throttling built into Vista/7), you really don’t need anything more than Windows 7 Ultimate, no matter how many sites you host. It will scale, too, and in fact Windows 7 is built to handle tens of CPU cores. So, going Windows 7 only takes the total cost down to $219.

Second, if you really do want to go with the Server flavor, you have a couple more options, including a COMPLETELY FREE option which is very easily accessible, but I’ll get back to that later.

I just want to say, though, at this point, that I for one am already a Windows user, and you probably are too, statistically speaking. Our investments have already been made; however, only the Ultimate edition of Windows is one I would settle for as a “Microsoft stack” developer. Mind you, I’ve never had to pay the full price for any version of Windows in many, many years, yet I am currently running the latest and greatest. Again, I’ll get into that later.

Now let’s look at the development languages and the tools that support them.

Development Languages and Tools

The big names among the non-Microsoft platforms for languages and sub-platforms are:

• PHP,
• Ruby (on Rails),
• Python, and
• Java

Their tools come in many shapes and sizes. They can be as simple as vi or as complex as NetBeans. Many of the good tools people like to use are free. However, many of them are not.

For example, Aptana Studio is a very good web development IDE that supports Ruby, PHP, and Aptana’s own Javascript/AJAX platform called Jaxer, plus it runs in Eclipse so it supports Java as well. But the Pro version costs $99. That’s not free. There’s also JetBrains RubyMine which is also $99. On the other hand, Ruby developers tend to adore NetBeans, particularly over Aptana, and that is free. So go figure, to each his own.

The point is, if you want to get a rich and richly supported toolset, you’re just as likely going to have to pay for it in the non-Microsoft stacks.

On the Microsoft stack side, everyone knows about Visual Studio. The licensing cost for the Team Suite is $10,939. LAMP developers just love to point that kind of thing out. But folks, the fact is, that price is not measurable as the equivalent of LAMP freeware. It’s for an enterprise shop that needs very advanced and sophisticated tools for performing every corporate software role in a software development lifecycle. If you’re measuring the price here and it’s of concern to you, you probably don’t need to choose the most expensive offering to evaluate the costs of the MS stack!

First of all, the Professional edition of Visual Studio, if you’re crazy enough to have to pay for that out-of-pocket (i.e. not have your employer pay for it or get it in a bundled package such as one of the free ones) only costs $799, not $10,939.

Secondly, if money matters all that much to you, and you’re unable to get one of the free or nearly-free bundles (more on this in a bit), you really should push the limits of Visual Studio Express first. It’s free.

Experience Development Tools: Microsoft Expression vs. Adobe CS

Microsoft has been competing with what was Macromedia, now Adobe, for its designer-oriented web tools for a very long time, and finally came through with a reasonable offering with Expression Studio a few years back, which offers very close to the same functionality, at least at a basic level, for creating compelling web experiences as Adobe’s current CS4 Web Premium offering minus Photoshop.

Dreamweaver vs. Expression Web

A surprisingly large number of web designers use Adobe Dreamweaver (formerly Macromedia Dreamweaver) as their standard web creation tool, not far in similarity to the ubiquity of Adobe Photoshop for editing graphics. Microsoft has had an equivalent web creation tool for well over a decade. It used to be called FrontPage, now it is called Expression Web. But let’s get one thing clear: Expression Web replaces FrontPage, it is not a rename of FrontPage. It is, in fact, a different product that accomplishes the same task and in the same general way. By that I mean, as far as I know, very little of Expression Web’s codebase reuses FrontPage’s legacy codebase; it is a total rewrite and overhaul of both the tools and the rendering engine.

Expression Web supports PHP, in addition to its extensive support for ASP.NET and standards-based raw HTML and CSS. Technically, Expression Web is very close to being on par with Dreamweaver, and I think the differences are a matter of taste more than of function. I for one prefer the taste of Expression Web, and don’t know what Dreamweaver offers that Expression Web doesn’t.

Expression Studio includes Expression Design which is functionally equivalent, albeit to a much lesser extent, to Adobe Illustrator. The rest of the Expression Studio suite accomplishes most of the same functional tasks for web design and development as Adobe CS4 Web Premium Suite’s offering. So, to be functionally complete, you’d need to add a graphics editor to Expression Studio before Expression Studio can be compared with CS4.

As for the costs,

Expression Web: $149
Expression Studio + Paint.NET = $599 + $0 = $599
Expression Studio + Adobe Photoshop: $599 + $699 = $1,198

However, I get Expression Studio for free as it is bundled with my Microsoft suite package. More on this later.

Adobe Dreamweaver: $399
Adobe CS4 Web Premium Suite: $1,699

Silverlight vs. Flash

Inevitably, “the Microsoft stack” has to run into the Silverlight stack because Microsft pushes that product out, too. I’m not going to get into the religious debate over whether Adobe Flash is better than Microsoft Silverlight, except to say a couple very important things. First of all, I understand that it’s a no-brainer that everyone has Flash. 98% of the web’s user base has it. That said, supporting Microsoft Silverlight for your user base—that is, getting your users to obtain it—is not hard at all. So let’s just get that out of the way, okay? Yes, I know that Silverlight comes at this cost of a one-click install versus a no-click install. Life goes on.

Okay. Let’s talk about tools. With Adobe Flash, you have three options, really, for developing Flash solutions: 1) Adobe Flash Professional, 2) Adobe Flex (an Eclipse-based IDE for developing Flash-based applications), or 3) third-party apps like SWiSH. Fortunately, Adobe has recently been rumored to be planning on merging Flash Pro and Flex functionality, which is a relief because Flex did not have the design power of Flash Pro and Flash Pro didn’t have the development power of Flex. Meanwhile, though, Flash Pro and SWiSH are hardly tools I can take seriously as a software developer, and unfortunately, at $249, Flex is expensive.

Microsoft, however, offers the functionally equivalent toolset with the Expression suite and with Visual Studio. The Silverlight Tools for Visual Studio integrate with Visual Web Developer, providing Silverlight developers a completely free IDE for developing compelling Silverlight applications. So let’s get that out of the way: You do not need to spend a dime on dev tools to develop Silverlight apps.

Expression Blend, however, which is a commercial product and is functionally comparable to Adobe Flash Professional as well as, in my opinion, Apple’s Interface Builder (with which iPhone application interfaces are designed), is a rich designer tool for Silverlight as well as for WPF (Windows applications) and outputting XAML, the XML markup required for Silverlight and WPF applications. It provides a syntax-highlighting, IntelliSense (code completion) ready code editor for C# and Javascript code, too, so technically you could accomplish much using just Expression Blend, but Microsoft (and I do, too) recommends using Expression Blend in combination with Visual Studio / Visual Web Developer 2008 Express.

Microsoft Visual Web Developer 2008 Express with Silverlight Tools: $FREE
Microsoft Expression Blend: $599 (full Studio suite)
Together: $599
Microsoft Expression Professional Subscription (Expression Studio plus Windows, Visual Studio Standard Ed., Office, Virtual PC, and Parallels Desktop for Mac): $999

Adobe Flex Builder: $249
Adobe Flash Professional: $699 (standalone)
Together: $948

The long and short of it: in terms of cost savings, Silverlight development costs are on par with Flash development costs, but can in fact go a lot further per dollar including at the price of $FREE, depending on how much tooling you need.

Databases

Then there are the databases. The non-Microsoft stacks include primarily mySQL and PostgreSQL, et al. Mind you, these databases work fine in a Microsoft world, too, just like everything else, but the Microsoft stack tends to work best with Microsoft SQL Server.

Okay, let me just say at this point that Microsoft SQL Server 2008 is, by far, a vastly superior RDBMS than most anything I have seen from anyone, in every respect. Don’t get me wrong, I greatly admire mySQL and the other RDBMSs out there, but SQL Server is seriously the bomb.

But let’s talk about pricing. Just like Visual Studio has a prohibitively expensive offering available to enterprise users, SQL Server 2008 Standard Edition comes to us at a whopping $5,999. That’s just a hair less than the price of my Toyota when I bought it (used).

But, once again, there’s an expensive commercial offering for everything under the sun. MySQL also has a commercial offering at $599, which I’ll admit is only 1/10th the cost of SQL Server standard edition but isn’t exactly free either.

But seriously, who comparing development stacks actually pays for this stuff? Read on.

Everything Starts At Free

Technically, one could download the SDKs (for free) from Microsoft and do most anything. Most of it would be from the command line, but even XamlPad.exe is bundled in with the Windows SDK to you create XAML files for WPF with a WYSIWYG preview. (For Silverlight, you might try Kaxaml’s beta release.)

But who on the Microsoft stack wants to use the command line? If you’re new to the Microsoft development stack, the first place you should turn to is the Express suite, which includes among other things Visual C# Express, Visual Web Developer Express, and SQL Server Express. Empowered with each of the components of the Express suite, you as a developer have all the extremely powerful tools you need to accomplish almost any development task, with absolutely no licensing fees whatsoever. There really is no fine print with this; the Express editions have a few functional limitations that are very rarely (if ever) showstopping, and you’re not allowed to extend the Express product and try to sell your extension or to redistribute the Express products themselves, but there’s no pricing structure at all for any of the Express suite downloads.

I must say, the 2008 flavors of the Express products are, far and away, the most powerful software development solutions I’ve ever seen as a free offering, and definitely compete fairly with the likes of Eclipse and NetBeans in terms of providing what the typical developer needs to build a basic but complete product or solution without a software budget. Ironically, in my opinion, Microsoft specifically created a web site for the Express flavors of Visual Studio to make it all look crappy compared to Visual Studio Team Suite. The Express web site does not do these tools justice. Combined, the Express products are very rich and powerful, and the web site makes them look like a boy’s play dough or G.I. Joe.

I must include SQL Server 2008 Express in saying that the Express products are very rich and powerful, particularly if you get SQL Server 2008 Express with Advanced Services including Management Studio Express, this RDBMS suite is insanely powerful and complete, and is by far more capable and powerful than mySQL. And no, people, SQL Server Express does not come with licensing restrictions. It’s free, completely free. Free, period. It has a few technical/functional limitations, such as for example it cannot consume more physical RAM (not to be confused with database size) than 1 GB, and there are limitations to redistributing the Express products. But there is otherwise no licensing fine print. You can use it for commercial purposes. Have at it.

Beyond these Express versions, there’s also #develop (pronounced “SharpDevelop”). #develop is a non-Microsoft IDE for developing .NET applications on Windows, and it’s quite functional. Initially I think it was built for Mono in mind, but in the long run it never implemented Mono and instead Mono took some of #develop and made it MonoDevelop. #develop is a very well implemented IDE and is worth checking out, particularly given its free price. However, since #develop isn’t a Microsoft tool, it’s not really part of the Microsoft stack.

The Cheap And Free Bundle Package Deals

If the Express flavors aren’t good enough for you, now I get to mention how to get everything you might ever need—and I really mean everything, including Windows Server 2008 R2 Enterprise Edition, SQL Server 2008 Enterprise Edition, Visual Studio Team Suite with Team Foundation Server, and Expression Studio—for absolutely no cost whatsoever. The only catch is that you must be needing this (a free offering). If you don’t need it because you have a heckofalot of money, then, well, go get a life.

Microsoft is still giving away all the tools you need to rely on the Microsoft stack for absolutely no cost whatsoever through a package deal called BizSpark, which basically gives any start-up company—including one-to-five-man micro-ISVs like yourself(??)—an MSDN Subscription with fully licensed rights to use everything under the sun for development tools and operating systems for absolutely no cost (except for a $100 closing fee after a couple years I think?). If you’ve been struggling as a business for more than three years or if your revenue exceeds $1mil a year, you don’t qualify, otherwise if you intend to create a product (including a web site hosted on IIS) that’s core to your start-up, you do. It’s as simple as that. But don’t take my word for it, read the fine print yourself.

[Added 9/26/2009:] If you’re not a software business start-up but more of a web services start-up, creating a web site, or are a web designer, there’s a brand spanking new program for you, too, that’s just like BizSpark but targets you specifically. It’s called WebsiteSpark. I’m injecting mention of this into this blog post but already discussed it in a follow-up post; here are the basics: For a $100 offing fee (a fee that you pay when your license ends, rather than when it begins) you get Windows Web Server 2008 R2, SQL Server 2008 Web Edition, Visual Studio 2008 Professional Edition, and Expression Studio 3, and your license ends in three (3) years (same as BizSpark).

But let’s say you’re not really in business, you’re a college student, and you just need the software, without the pressure of being monitored for pursuing some kind of profit. Assuming that you are indeed in college, there’s hope for you, too, a complete suite of software for you including Windows Server 2008 Standard Edition, SQL Server 2008 Standard Edition, and Visual Studio 2008 Professional Edition, among other things, through a program called DreamSpark. All you need to qualify is to be a student. Congratulations.

An older program I took advantage of a few years ago, while Microsoft was still experimenting with these package deals, was the Empower program, which is like the BizSpark program but costs a few hundred bucks and doesn’t give you the ridiculously extensive Team Suite edition of Visual Studio. You basically have a year or two to enjoy it, and must offer a product within that timespan, after which point they drop you. But it was still a great deal considering the alternative outside of BizSpark was full-on full-priced licensing.

If you want a “normal everyday customer deal”, the MSDN subscription is still a good option. For about $1,200 for the Visual Studio Pro with Premium MSDN, you get everything under the sun (everything in BizSpark), except only the Team Suite flavor of Visual Studio. I’d save up my money for that even now if I didn’t already have what I needed.

Finally, if these still aren’t good enough for you, let me just say that if you work for an employer who provides an MSDN subscription directly to you as an employee (and I’ve had at least five or six employers do this in my career), and you go and use one of the unused licenses of one of the products under MSDN for your own personal use, unless Microsoft or your employer actually bother to check the download or activation history of your MSDN account, *psst* hey buddy, nobody will ever know. *wink* Seriously, don’t pirate. But hey I’m just sayin’. If you’re careful to only use the licenses that are not being and won’t be used (and in most cases with MSDN subscriptions there’s a ton of them), nobody will care.

Windows Web Hosting

All these things said, if you’re building a web site, you don’t likely need to buy Windows at all, other than the Windows instance on which you’re developing your app. You can rely on a third party web host just like nearly everyone else does. The price for hosting an ASP.NET app on a Windows-based server is typically about 20% more than the Linux offerings, but start at $4.99. You typically have to pay a little bit extra, as well, for extensive SQL Server requirements, but the basics are usually bundled in with these hosted deals.

The Costs Of Knowledge

Honestly, at $4.99 or even $10 a month, I don’t know what people would be complaining about. That’s a good price to host a Microsoft tools based solution. Sure, I can get a Linux hosted site running somewhere at as little as $2.99, but this comes at a prohibitive cost to me. First of all, I like most PC users (“most” being statistically speaking) am already familiar with Windows. In order to use Linux hosting effectively, one must explore and consume a lot of knowledge that otherwise has no relevance to my existing work-and-play environment.

Well let’s assume, then, that I know neither, and that I only use Windows for e-mail and web browsing. Let’s assume that I’m looking at PHP vs. ASP.NET and mySQL vs. SQL Server Express.

Linux proponents will say that you can dive right into PHP and mySQL because Linux doesn’t cost anything. But if you’re already running a moderately recent version of Windows, which statistically speaking you probably are, then this point is completely moot. Even with Windows XP (which is nearly a decade old and is showing its flatulent age) you can accomplish much with the tools that are already available to you.

At that point, then, which direction you should choose is going to be purely a matter of taste, vendor support, learning curve, and culture, because you can do pretty much anything on the Microsoft stack absolutely for free, or cheaper than the non-Microsoft alternative (i.e. Expression Studio vs. CS4), at every level, with no or very few strings attached.

I’d argue, then, that the cost of knowledge is the only significant cost factor if you already have Windows and you’re just doing your own thing. Both the Microsoft and the non-Microsoft user communities are strong and will assist you as you learn and grow. However, I prefer the Microsoft path specifically because the education, training materials, documentation, and, yes, marketing, all come from one vendor. It’s not lock-in that I want, not at all, so much as it’s the consistency that I enjoy (not to mention the intuitiveness of the Microsoft platform at every level from a user’s perspective). Everything starts with MSDN and Microsoft employees’ blogs, for example, and from there I get everything I need from help on how to use new C# language features to how to use Visual Studio to how to configure or extend IIS. Whereas, with the LAMP community, everything is fragmented and fractured. If that’s your preferred style, great. Just keep in mind that Windows can do everything you’re already doing in Linux. ;)

[Added 9/26/2009:] As I mentioned (er, injected) above under “The Cheap And Free Package Deals”, Microsoft just created a new program called WebsiteSpark. In addition to the Windows, SQL Server, Visual Studio, and Expression Studio licenses, you also get professional training. This training is still “coming soon”, I suspect it’ll be online training, but it’s professionally produced training nonetheless (no doubt).

Discussions In The Community

Browsing the comments at http://stackoverflow.com/questions/1370834/why-is-microsoft-stack-said-to-be-costly/1376168#1376168 infuriates me. This is actually the reason why I felt compelled to post this blog article. I am so sick and tired of the FUD that ignorant anti-Microsoft proponents keep pumping out. I’m going to assume that the OP’s context was for web applications, but it doesn’t matter much either way.

• “But still, Linux hosting is cheaper than Windows hosting at pretty much every level.”

Ahh yes, web hosting. At $4.99 or even at $10 per month I really don’t care.

If we’re talking about VPS or dedicated server hosting, that’s another story. Let’s just say I have a Linux VPS I pay $30/mo. or so for, but I really don’t use it for much because it just doesn’t do enough for me reliably and intuitively, and meanwhile this blog is hosted on a $160/mo. virtual dedicated server (hosted) with Windows Server 2008, but it’s heavily used. I feel I get what I pay for.

• “Linux hosting is almost always cheaper for the simple reason that the MS stack costs the host more to license (which is the point of most posts). Also you don't get development tools with a hosting service. Let's not forget that you're also liking going to need a more expensive "Ultimate Developer, Don't Gimp It" version of Windows desktop to run the dev tools.”

I don’t know what “Ultimate Developer, Don’t Gimp It” means, but I do agree that Ultimate is the best flavor of Windows to do development on. However, you don’t need Ultimate edition to do Microsoft stack development. Visual Web Developer (which is free) comes with its own test web server and installs fine on Windows XP Service Pack 2 or on Windows Vista Home Basic. And its output works great at targeting Windows based web hosts.

• “I've heard of express editions. I've even downloaded some. I seem to remember a license condition about non-commercial use, although I may be wrong. I don't think the express editions are particularly good for commercial development in any case.”

Hogwash. The Visual Studio Express editions are blatantly characterized on Microsoft’s pathetic Express web site as being cheap, simple, and even a little crappy, but in fact they are extremely functional and capable of doing much more than “hobbyist” solutions. The suite is really very powerful and I for one believe that if Microsoft only had the Express suite and sold it as their commercial offering it would still be a powerful, viable platform for many shops. And yes, you’re allowed to use it for commercial development, and it works great for it.

However, as described above, there are ways to get the Professional and Team Suite editions of Visual Studio and SQL Server Developer Edition (full) without shelling out a lot or even any money.

• “I don't know Microsoft's specific licensing policies (I can assume they are pretty reasonable), but I can tell you that developer tools are often more pricey than you'd imagine when you start licensing for your company.
  Often when you start buying developer licenses for teams of, say, 20-50 you are starting to talk about millions of dollars up front costs. $100,000 per developer wouldn't be unheard of (not counting the often mandatory annual support fees which can double that number easily).”

Ridiculous. $10,000, which is a tenth of what this guy said, is all it costs to get everything under the sun without one of the special deals like BizSpark. And if you have a team of that size and you’re an established corporation, it would be below you to still be asking the question, “Is the Microsoft stack really more expensive?” It will be business. And I must say, Microsoft doesn’t suck at supporting its fully-paying customers.

At any rate, I must say again, BizSpark (bundled suite of everything) is completely free, with a $100 closing fee.

• “If you want to use ASP.NET you need
  • IIS
  • A server with Windows (for IIS)
  • Visual Studio
  • A work station with Windows for Visual Studio

  If you want to use PHP, Perl, Mono, Ruby... you need

  • A web server that supports the technology wanted. May be Apache, IIS...
  • An OS that supports your weberver
  • A workstation with any Linux, Window or mac”

This is silliness. If you want to use ASP.NET, you can go Mono all the way on Mac or Linux and never touch Windows or IIS. But ASP.NET wasn’t the discussion; the Microsoft stack was the discussion.

The Microsoft stack infers Microsoft being the vendor at every primary level of the software stack. So of course you need Windows. (And for the third or fourth time, statistically speaking you probably already have it.) And Mono wouldn’t count because it’s not Microsoft, so of course you need IIS. #develop (SharpDevelop) and other non-Microsoft development IDEs don’t count because they’re not Microsoft, so of course you would probably use Visual Studio.

On the other hand, “needing IIS” has no meaning because it’s a part of Windows, it’s like saying you need a hard drive, plus you need a computer (to contain the hard drive). It comes at no cost. It’s not a product, it’s a technology component of Windows.

Visual Studio is also not needed, rather it’s available as an option, and its Express flavors are free. You can also use vi, emacs, Notepad.exe, whatever you like. There is literally nothing that LAMP developers enjoy in their development lifecycle that they cannot establish with the Microsoft stack. If you want to write in vi and compile with a command line using ant and make, great, use vi and NAnt and NMake or MSBuild. If you like your command shells, great, most of the Linux command shells are available in Windows, plus Windows’ PowerShell. Have at it. But please, please don’t assume that you have to use Visual Studio if you use the Microsoft stack but you get to use simpler tools for LAMP development. The Microsoft stack has all those simpler tools at its disposal, too. (Yes, all for free, with the Windows SDK.)

• “I don't think they're talking about the time required to develop on the Microsoft stack. They're talking about the cost of:
  • tools (Visual Studio, Resharper);
  • operating systems (Windows Vista, Windows Server); and
  • databases (SQL Server 2005/2008).”

*sigh* Need I say more and repeat myself? And if Resharper was available for PHP/Ruby, and I was doing PHP/Ruby development, I’d pay for that, too.

I’ve just open-sourced my latest pet project. This project was started at around the turn of the year, and its scope has been evolving over the last several months. I started out planning on a framework for rapid development and management of a certain type of web app, but the first hurdle as with anything was picking a favorite DAL methodology. I tend to lean towards O/RMs as I hate manually managed DAL code, but I didn’t want to license anything (it’d mean sublicensing if I redistribute what I produce), I have some issues with LINQ-to-SQL and LINQ-to-Entities, I find nHibernate difficult to swallow, I have some reservations about SubSonic, and I just don’t have time nor interest to keep perusing the many others. Overall, my biggest complaint with all the O/RM offerings, including Microsoft’s, is that they’re too serious. I wanted something lightweight that I don’t have to think about much when building apps.

So as a project in itself I decided first to roll my own O/RM, in my own ideal flavor. Introducing Gemli.Data! It’s a lightweight O/RM that infers as much as possible using reflection, assumes the most basic database storage scenarios, and helps me keep things as simple as possible.

That’s hype-speak to say that this is NOT a “serious O/RM”, it’s intended more for from-scratch prototype projects for those of us who begin with C# classes and want to persist them, and don’t want to fuss with the database too much.

I got the code functioning well enough (currently 92 unit tests, all passing) that I felt it was worth it to go ahead and let other people start playing with it. Here it is!

Gemli Project Home: http://www.gemli-project.org/ 

Gemli Project Code: http://gemli.codeplex.com/

Gemli.Data is currently primarily a reflection-based mapping solution. Here’s a tidbit sample of functioning Gemli.Data code (this comes from the CodePlex home page for the project):

// attributes only used where the schema is not inferred
// inferred: [DataModelTableMapping(Schema = "dbo", Table = "SamplePoco")]
public class SamplePoco
{
    // inferred: [DataModelFieldMapping(ColumnName = "ID", IsPrimaryKey = true, IsIdentity = true, 
    //     IsNullable = false, DataType = DbType.Int32)] // note: DbType.Int32 is SQL type: int
    public int ID { get; set; }

    // inferred: [DataModelFieldMapping(ColumnName = "SampleStringValue", IsNullable = true, 
    //     DataType = DbType.String)] // note: DbType.String is SQL type: nvarchar
    public string SampleStringValue { get; set; }

    // inferred: [DataModelFieldMapping(ColumnName = "SampleDecimalValue", IsNullable = true, 
    //     DataType = DbType.Decimal)] // note: DbType.Decimal is SQL type: money
    public decimal? SampleDecimalValue { get; set; }
}

[TestMethod]
public void CreateAndDeleteEntityTest()
{
    var sqlFactory = System.Data.SqlClient.SqlClientFactory.Instance;
    var dbProvider = new DbDataProvider(sqlFactory, TestSqlConnectionString);

    // create my poco
    var poco = new SamplePoco { SampleStringValue = "abc" };

    // wrap and auto-inspect my poco
    var dew = new DataModel<SamplePoco>(poco); // data entity wrapper

    // save my poco
    dew.DataProvider = dbProvider;
    dew.Save(); // auto-synchronizes ID
    // or...
    //dbProvider.SaveModel(dew);
    //dew.SynchronizeFields(SyncTo.ClrMembers); // manually sync ID

    // now let's load it and validate that it was saved
    var mySampleQuery = DataModel<SamplePoco>.NewQuery()
        .WhereProperty["ID"].IsEqualTo(poco.ID); // poco.ID was inferred as IsIdentity so we auto-returned it on Save()
    var data = dbProvider.LoadModel(mySampleQuery);
    Assert.IsNotNull(data); // success!

    // by the way, you can go back to the POCO type, too
    SamplePoco poco2 = data.Entity; // no typecast nor "as" statement
    Assert.IsNotNull(poco2);
    Assert.IsTrue(poco2.ID > 0);
    Assert.IsTrue(poco2.SampleStringValue == "abc");

    // test passed, let's delete the test record
    data.MarkDeleted = true; 
    data.Save();

    // ... and make sure that it has been deleted
    data = dbProvider.LoadModel(mySampleQuery);
    Assert.IsNull(data);

}

Gemli.Data supports strongly typed collections and multiple records, too, of course.

var mySampleQuery = DataModel<SamplePoco>.NewQuery()
    .WhereMappedColumn["SampleStringValue"].IsLike("%bc");
var models = dbProvider.LoadModels(mySampleQuery);
SamplePoco theFirstSamplePocoEntity = models.Unwrap<SamplePoco>()[0];
// or.. SamplePoco theFirstSamplePocoEntity = models[0].Entity;

Anyway, go to the URLs above to look at more of this. It will be continually evolving.

Well we're not quite a decade yet--certainly a lot longer than five years, though--since .NET came out and promised to be the next big thing for programming. C# was supposed to put VB6 to shame. It didn't, though, because with VB6 you had such things as optional parameters and variants--the latter being an ugly beast but under the covers the flexibility that VB6 was made programming so much quicker and easier sometimes.

Now that C# 4.0 introduces optional parameters and dynamic objects, the whole playing field is changing. And now I can feel a bit freer to tinker with old-school technologies built on COM in my language of choice because the language has finally caught up with last decade's featureset in this respect.

I like this somewhat recent blog post by SamNG:

http://blogs.msdn.com/samng/archive/2009/06/16/com-interop-in-c-4-0.aspx

Lets look at a quick Office example.

static void Main()
{
    Word.Application app = new Word.Application();
    object m = Type.Missing;
    app.Documents.Add(ref m, ref m, ref m, ref m);
}

This is such typical code! I have to struggle with the type system to make it happy, just to add a simple Word document!

... [With C# 4.0] in the following code, call (1) gets transformed into call (2).

static void Main()
{
    Word.Application app = new Word.Application();
    // (1) Your initial call.
    app.Documents.Add(Type.Missing, Type.Missing, Type.Missing, Type.Missing);

    // (2) Compiler generates locals and inserts them.
    object m = Type.Missing;
    app.Documents.Add(ref m, ref m, ref m, ref m);
}

The great thing about this too, is that with the introduction of named and optional arguments, and using the fact that the feature generates Type.Missing in place of default values for object on COM types, we can simply remove the arguments altogether!

static void Main()
{
    Word.Application app = new Word.Application();
    // (1) Your optional-parameter-omitted initial call.
    app.Documents.Add();

    // (2) Compiler generates locals and inserts them.
    object m = Type.Missing;
    app.Documents.Add(ref m, ref m, ref m, ref m);
}

Pretty cool stuff huh? Definitely makes programming against the Office APIs much nicer.

Yup. Indeed.