“No need to use our MVC framework for WinForms,” I thought. “I’ll just write code-under-buttons.”

Wait - this method’s getting long and nested. I’d better refactor it.

Wait - how can I disable this button until these fields are filled?

Now I’m wishing that I had used our template and done it the right way. Even a simple application isn’t simple.

And I’m learning that I hate ceremony.

• When writing Scala, I have to enclose blocks in curly braces. I don’t in F# or Ruby. Why?
• For the Nth time, I forget to end an Erlang function with a dot. I get an obscure compiler error.

In my day job, I write mostly C#. I’m used to that - typing curly braces, ending lines with semicolons, declaring types - it’s automatic. A good IDE helps a lot.

More and more, I wonder why the compiler doesn’t do more of this. F# is also a strongly-typed .NET language, and it can infer most types.

I’m starting to appreciate the simplicity of the F#/Ruby way of doing things.

As a side note, why are Apple and Microsoft bringing back the Bad Old Days of memory management? I have no desire to code in Objective-C or C++. I don’t want to use COM. Even the Linux folks seem to have a love affair with C/C++. Give me memory management. Give me modern languages.

And give me less ceremony.

This is a language I really want to like, but it’s frustrating.

Take for example the Fibonacci sequence. Why do I have to write

fib(N,F) :-
   succ(N1,N), succ(N2,N1), fib(N1,F1), fib(N2,F2),
   plus(F1,F2,F).

instead of

F(n) = F(n-1) + F(n-2)?

(Above code is from http://www.cubbi.com/fibonacci/prolog.html)

Both expressions are recursive. One’s obvious, one isn’t.

There are classes of problems (multiple constraints, expert systems, etc.) for which Prolog is well-suited. Some of its features have been incorporated into modern languages (particularly functional languages such as F#), but only some. We need more easy-to-use declarative models - look what LINQ did for C#.

Programming languages are still overly difficult to learn and insufficiently expressive. Many are filled with “noise” that detracts from the content. Most are mired in our imperative C-based past.

Prolog is effectively an evolutionary dead-end, and it shouldn’t be. But it, and our other languages, need to be better.

Update - April 4, 2012

I’ve since seen a cleaner way to do this in Prolog; the above example may be dated.

The questions that annoy me are ones like this:

How can I moq this query against ravendb?

Don’t.

You’ve just coupled your application to the library. Yes, IDocumentSession is an interface. But it’s RavenDB’s interface. Does the class that you’re injecting it into call all of its methods? Does it use all of the properties of the interfaces returned by these methods? I doubt it.

You’re violating the Interface Segregation Principle.

Your class is also announcing, “I know I’m talking to a NoSQL database, or something like one, and that that database’s API looks exactly like RavenDB’s.”

It’s not just RavenDB. HttpContext, repositories using IQueryable<T>, interfaces of expressions of generic function delegates, you name it.

Does your class need all of that functionality?

Or does it just need a simple service?

Custom interfaces are easy to write, easy to implement (with a custom wrapper class), and easy to mock. They let you be explicit in your dependencies, specifying what a given class needs and no more. With a custom interface, you can also replace the actual implementation easily; you’re no longer wedded to a given library, technology, or product.

Time spent thinking about dependencies is time saved asking questions about mocking frameworks.

Sheer brilliance.

Mark Rendle said that on a Herding Code podcast. The context was that interfaces in APIs require that callers reference an assembly containing the interface definitions, and that versioning issues arise. A functional approach has the potential for avoiding those issues.

It’s a different way of looking at things. I wonder if he’s played Portal?