This post is a response (not a rebuttal) to: Perception is Reality – .Net OSS is DOA by Amir Rajan

note: I intentionally heaven’t read many of the linked blog’s comments so that I could get my own thoughts down. Therefore, I may be repeating some things that have already been said.

tl;dr

In my experience, OSS usage has risen slightly among internal corporate teams over the past few years. However, OSS usage has really taken off among other types of teams. Additionally, there are things that Microsoft could do to increase OSS adoption across the board.

Apigee’s API Design webinar may have just become my second choice as the go-to resource for bootstrapping developers new to HTTP/REST/Web API design. Shawn Wildermuth’s new Web API Design Pluralsight course is probably the most complete and non-biased resource for beginners on the topic. Shawn does a great job of distilling in 2.5 hours what took me countless hours to glean via scouring through blog posts and RFCs. He also carefully discusses the trade-offs of several design choices without falling into the RESTafarian vs. Pragmatic REST trap. The course also provides one of the best explanations of the most common OAuth flow (Facebook, Twitter, etc…) that I can remember.

My only minor gripe with the course is this: HATEOAS is mostly framed as a way to be friendly to humans (meaning: a way to make an API discoverable for developers). The possibilities of facilitating discoverable machine-to-machine communications isn’t really explored (vocabularies, API DNAs, etc…). However, I share his assertion that HATEOAS is still in the academic state. I will say that he does a good job of covering HAL and Collection+JSON in regards to this topic.

Bottom line: point developers who are new to Web APIs to this course.

This information comes from a post by @dblockdotorg which was down today while I was trying to set my blog up on a fresh OS install. Therefore, I’m mirroring that content here in case it is unavailable in the future.

$ git clone git@github.com:username/username.github.com.git
$ cd username.github.com
$ git checkout source
$ mkdir _deploy
$ cd _deploy
$ git init
$ git remote add origin git@github.com:username/username.github.com.git
$ git pull origin master
$ cd ..

I’m a fan of code reviews

I’ve typically used code reviews for the following benefits:

1. As a code quality measure. I think that code reviews rank right up there with TDD as a code quality practice. When I’m calling the shots on a project, I like to have “code review” being a requirement of something being considered “done”.
2. As a conversational learning experience (which can benefit both the reviewee and the reviewer).

When reviewing code as a quality check, I highly recommend that you use any tools at your disposal. In .NET land (at least for me) that means Visual Studio and Resharper. However, when doing more of a conversational code review for learning purposes, I’ve come to find that it can be handy to do the review without any tooling. To illustrate this point, I want to tell you a story about last Friday.

Because this blog is made of up link posts and original content posts, I wanted to make two customizations to Octopress to keep original content from getting lost under the volume of link posts.

I’ve been working with ASP.NET WebAPI on a day-to-day basis for about seven months now, and I have to say that I really appreciate how testable it is. Although the self-hosting capability of WebAPI seems like an obvious way to facilitate a test-first workflow, I personally favor two other methodologies.

I’ve been meaning to write about this technique for many years now, but two things have finally influenced me to put the words down:

When it comes to *nix experience, I’m kind of an odd duck. You see, I’ve been using Linux quite a bit as a desktop since Mandrake Linux came out (1998?). Also, I learned a little bit about running a *nix server in the late 90s / early 2000s when I was a Java developer. That being said, I never really tried to develop on a *nix system until late 2010 when I bought a Macbook Pro to learn Ruby. I’m still playing catch-up in many ways when it comes to fundamentals.

Reboot

It’s been over a year since I’ve written a post at Welcome to My Nerditorium. My old blog is hosted on the Blogger / Blogspot platform which I’ve never really enjoyed using.

I’ve decided to reboot my blog using the Octopress blog engine. Although I plan on slowly migrating my old posts over to this blog, I hope to jump back in the saddle and start generating new content ASAP.

What am I going to blog about now?

I plan to keep the theme of my blog roughly the same as before. It will be heavily focused on posts related to software development, but I will also be throwing in the occasional game review or editorial on various nerd related issues. The biggest change is that I plan to post lists of curated content on a semi-regular basis – not unlike The Morning Brew or The Morning Dew. I do not plan on directly competing with these two popular curation blogs. I will not be focusing solely on .NET or programming, and I don’t plan on posting lists every day. I’m simply going to curate lists of things that interest me (and hopefully people like me).

In this post by Jimmy Bogard about “dealing with non-transactional operations that must happen if some transaction succeeds,” the often embraced, but sometimes criticized, Session Per Request pattern (aka Transaction Per Request), came under fire in the comments.