Lost In Tangent

Jun

Netflix OData Service Updates

0 Comments Categories: .NET

The Netflix OData Service (http://odata.netflix.com/Catalog) was updated this evening with some changes that might affect those of you that have written applications against it. All of the changes were additive (i.e. no properties were renamed or removed from the model), so it should be pretty simple to update your consumer code (famous last words).

There were three main changes made:

The server-side paging for each of the collections has been increased to 500. The previous limit of 20 was put in place back in the prototype stage of the service and somehow it survived. We typically recommend 500 as a good number for balancing the needs of consumers while maintaining the performance/load of the server.
1. The only reason this might be an issue for consumers is if you were requesting a large collection (e.g. Titles), relying on the server-driven paging size of 20, and you’re now being handed 500 titles at once all of a sudden. If that much data is more than you need (or want) at once, then you can just do client-side paging (via $top and $skip) to control the amount of data you get back per request.
The Title type has a new property called ShortSynopsis. As you can imagine, this property is a shortened version of the existing Synopsis property. The other useful thing about ShortSynopsis is that it doesn’t include any HTML (unlike Synopsis) in its contents, so if you’re developing a client UI that doesn’t want to parse HTML content (or can’t, as is the case with SL in-browser), ShortSynopsis is your new solution.
Each delivery format of a Title (Instant, DVD, Blu-Ray) now has its own distinct Rating and Runtime properties (e.g. Dvd/Rating, Instant/Runtime, etc.). This allows each format to differ in their MPAA rating and their overall runtime, which will happen in practice, and so that extra flexibility was needed in the data.
1. In order to maintain backwards compatibility, and keep the ease-of-use of the data, we wanted to keep the Rating and Runtime properties directly off a Title. Since a title can have multiple formats, and each of those formats can have different ratings and runtimes, we obviously had to decide on which of the three take preference in representing the “canonical” format. Basically, the Title’s “root” Rating and Runtime values will come from the first format that is available, in the following order: Blu-Ray, DVD, Instant. Therefore, if a Title is available in Blu-Ray, it’s Rating property will always be equal to its BluRay/Rating property (the same goes for the runtime). If a Title isn’t available in Blu-Ray but it is in DVD, the DVD values will be used, and so on. If you don’t like this behavior, you can use the individual specific rating and runtime values.

Those of you that are consuming the service from a dynamic language (e.g. JavaScript, Ruby), you should have nothing to worry about here. But, if you’re consuming the service from a static language (e.g. C#, Java), you will most likely need to regenerate your proxy classes. I say “most likely” because every client differs in how it treats missing properties. The .NET client for instance, by default, will throw an exception if the server returns a property that doesn’t exist on the client-side proxy type. You can get around this by setting the DataServiceContext.IgnoreMissingProperties property to true, or just re-generate the proxy.

If you run into any issues, please feel free to reach out. Also, make sure to let us know if you’re doign anything cool with the service as well.

May

Web API Roadshow

0 Comments Categories: Uncategorized

When Doug and I worked on the flow and content for the “Services Powering Experiences” keynote at MIX10, we ended up with something that would have taken hours to do it true justice. Having to cram it into a 30 minute keynote was very difficult, and as you can imagine, many details of the story weren’t able to be fully articulated, and much of the “on the fly” coding that we both prefer had to be sacrificed for the sake of time.

Fast forward a few months, the story has gotten tighter, VS2010/.NET4 has shipped, and Doug and I have decided to take the “Services Powering Experiences” love around the world. Over the next 6 weeks we’ll be hitting seven different cities, and doing a day long workshop that combines demos/discussions and interactive coding. We’ve got some pretty cool projects to discuss/show off, and a lot of lessons learned when developing web APIs using OData and Azure.

Keep in mind though, this isn’t a Microsoft/.NET lovefest. This workshop is about web APIs in general, where we just happen to be using OData/AtomPub/JSON as the primary subject matter (any general-purpose discussion has to choose a concrete example). We’ll be demoing/writing JavaScript applications, iPhone applications, and would love to have developers from any of those camps attend. It would be amazing to have some Java, Python, Ruby, Smalltalk (Doug would love this), etc. developers there, so please come by and share your thoughts/experiences.

In addition to the demo/discussion side of things, we’re also going to have an afternoon of interactive coding time, where we’d love to see attendees show off anything cool they’re building in the web API space, or experiment with consuming/exposing data via a web API. Once again, any platform is welcome. Anyone with an entrepreneurial itch should also make sure to come hang out. We’re definitely going to be discussing monetization, and what business opportunities exist in the world of web APIs.

The schedule, further description, and agenda can be found here. If you’re not able to make it, but live in one of those cities, and would like to get together for drinks or something, please e-mail me (joncart at microsoft dot com). As always, I want to make the most of the time abroad, and it’s always great to hang out with the local devs.

Feb

Impact The Planning For EF/Astoria vNext

1 Comment Categories: .NET

Now that the VS2010/NETFX4 train is about to grind to a half, the vNext discussions are ramping up for each of the encompassed technologies. Why is this interesting to you? Because it’s the perfect time to start voicing your personal opinions. If you’ve been moaning about a feature that you need, or a behavior that should be improved, you absolutely need to tell us about it. Despite what some believe, Microsoft listens very extensively to customer feedback, the trick though is knowing where to give that feedback.

I get e-mails all the time, and I read tweets every day talking about some change request that a developer would like to see made. Unfortunately, those mediums aren’t the best way for us to be able to rally behind. Don’t get me wrong, we want that communication to happen, and we take those comments into account when doing product planning, but in order to justify new features, it’s very key to have as much support behind it as possible, and this typically can’t come from a bunch of disparate e-mails, tweets, etc.

You don’t need to be BFFs with ScottGu (that certainly won’t hurt) or attend every SDR to have a voice in Microsoft. This was loudly confirmed by ASP.NET MVC, which anyone can tell you was heavily driven by customer comments. The same can be true for the Entity Framework and WCF Data Services in their vNext releases. We just recently published Connect sites for both products and are asking for all the feedback you’ve got. This can come in the form of bugs or suggestions. Both are much appreciated and will be directly taken into account. One of the main reasons using Connect is great is that it allows other people to upvote/downvote your suggestions. This makes it much easier for us to justify working on a specific feature (or not too if you’re the only person in the world that wants something added).

Entity Framework vNext Connect

WCF Data Services vNext Connect

Long story short: go make your suggestions on the Connect sites, otherwise I don’t want to hear you complain a year from now about something we didn’t add

Jan

If He Walks Like A Ruby Developer, But He Talks Like A PHP Developer, Then What Exactly Is He?

2 Comments Categories: Uncategorized

After I made my opinionated post last week on the pointlessness of debating what the “best” is in regards to programming languages, frameworks, etc., I got a rather substantial amount of feedback/whiplash from it. I really appreciated someone submitting the post to Hacker News because it ended up generating a lot of great commentary that made me rethink my thoughts on the matter. Have I changed my story? Not really. But, I need to clarify a couple of things.

One of the better responses that I saw came from Ryan McGreal who I thought made an excellent observation:

“It seems to me that the author is ignoring the relationship between experience and expertise in a language. Programmers call themselves [language/framework] developers because they’ve invested a lot of time becoming proficient in that language/framework. Of course there’s some skills transference when you pick up another language, but they’re not commodities and they’re certainly not entirely fungible.”

Ryan is totally right, and I admit that I carelessly made some rather abstract comments without mapping them back to reality. As professionals, we all need jobs, and those jobs come with a label attached to them (e.g. ASP.NET developer). In order to be valuable for those jobs we need to do our best to excel in a specific language and/or framework (most likely both). I was never trying to call out that truth or somehow sound disillusioned to the way you can become successful.

What I need to clarify though is how I view developers, their multiple personalities, and their immensely powerful ability to change between those personalities as needed. When I think about software development as a whole, I think of it as a series of different personalities that people can choose to adopt over time. For instance, if somehow along your career path, you do a stint as a DBA, you’ve acquired that personality. Done embedded development? You got another. Written ColdFusion? Eek, sorry about that (I know how you feel). Worked with functional languages? Guess what? You’re now changed forever.

As your career progresses, your “value” can be calculated in one of two ways: how many personalities you’ve acquired, and how strong some of your individual personalities are. The former is what I focused on in my previous post, the later is what I believe Ryan was referring to, and in most cases is what lands you a job in the real world. But, is that what makes you the most flexible? Or the most well-rounded? It’s hard to say.

I’ve interviewed many developers who applied to a position that was attached to a specific programming language, and didn’t even know that language, but I still gave my recommendation to hire them. The reason was that I felt comfortable enough with their current skill set that I knew I could not only mentor them to transition in another language, but they could become really strong. Truthfully speaking, I never once saw a negative recourse from one of those decisions (thank goodness!).

To me, these types of incidents have always spoken to the fact that a good developer, who has strong fundamental knowledge, paired with the right team, can easily move between languages and frameworks. Everything out there is made up of the same ideas, they’re just worded differently. Give someone the right translator and they’ll be happy to speak the language. Anyone who is running a development team, and doesn’t try to see that potential in people, is doing themselves and their team a disservice.

This anecdote doesn’t exactly hold up for contractor positions where a company is looking to hire someone with a specific skill for a specific amount of time. But, I only think my point degrades from the perspective of the company, not the developer. The next subheading will explain why.

Human Duck Typing

Besides the case of a developer who can flexibly move between languages/frameworks due to his core knowledge, what about the developers who have strong knowledge in multiple areas? I personally know some guys who are ridiculously versed in both PHP and Java, or .NET and Ruby, or both C# and Scala, etc. What do you label those people as? I don’t think that you do, but that’s just me.

If our expertise were like a base class, we could only ever have one (in most languages), but I think many of us can agree that inheritance is overused. If expertise were like attributes that a person could have, then we wouldn’t really care what they labeled themselves as, because we’d only be concerned with the fact that they can speak the language we want them to. That is exactly why “duck typing” in programming languages can be so useful, because from a programmatic perspective it allows us to not be considered with what something is, but what it can do.

When a company puts out an ad for a “Ruby developer”, the guy who has multiple different technical personalities, one of which is Ruby, could then apply for that job, and everybody wins. The company had to choose a specific attribute to ask for up front, but if they were really smart, they’d be interested in a lot more in the long run. In some ways this can also be paralleled to claims-based identity. The identity provider could have a whole ton of information on a user, but the relying party only requests the bits it needs. Likewise, a developer can contain a whole slew of technical prowess, but an employer is only “demanding” a few primary ones.

Wrap This Up For God’s Sake

If you strip out all of the ridiculous analogies and ramblings, all I was trying to say is that as a developer I love sharing ideas with other people and gleaning from them parts of their technical personalities (read my other post here). I feel like this is what makes me a better professional, and keeps my interest in the industry fresh. I appreciate other developers who have a similar interest in learning, and take the approach with their career to try to be as well-rounded as possible without sacrificing the expertise in the areas that make them valuable. At any given time we’re obviously going to have a stronger slant towards the technologies we’re using, but that doesn’t mean we have to settle ourselves in that bucket in terms of conversation. Be what you need to be for your day job, but be all that you can be for your community.

FYI, I realize that was disgustingly cheesy, but it was just too awesome an opportunity for me not to close it like that

Jan

Dear Son, Don’t Forget…Give Credit Where Credit Is Due

1 Comment Categories: Storytime with JC

My whole life growing up my mom repeatedly told me a phrase that my dad used to say (apparently a lot): “Give credit where credit is due”. If I had to pick the lessons that were reiterated to me the most as a child, that would be in the top five. The notion that giving someone appreciation isn’t enough, but rather, you should actively seek out the opportunity to give someone credit when it’s owed to them. It’s a pretty powerful thing.

It’s easy to get wrapped up in our own ideas and pursuits and not be able to see how we got where we are and who it was that helped us along the way. There are many areas in our lives for us to be appreciative, but I’ve been thinking a lot lately about the collective opinions of people around us that end up making our own. It would be haughty to think that anything we say or feel is actually of our own creation, instead of realizing that we refined or derived it from someone who ultimately inspired us (whether is be subconscious or not).

As a kid, I was in love with the Mega Man video game series. What enthralled me the most was the fact that you could absorb the abilities of your opponents upon defeating them (thereby making you the “Mega Man”). This interested me even more as I got older and thought about how this slightly paralleled our interactions with people in reality. Obviously we’re not out to defeat our friends and colleagues, but there’s no doubt that we “gain abilities” as it were by being influenced by the opinions and ideas of others. In effect, all of our individual intelligence is nothing more than a personal slant on the overall collection of ideas that we’ve absorbed throughout our entire life.

There are also a special class of people who have created unique ideas completely of their own initiative, who we would label as geniuses. But, I would argue that despite the fact that the idea in question might be unique, they absolutely were influenced by someone in some capacity. Nothing in life is new, we’re just refining the same ideas over and over again until they reach the point of satisfaction for the current state of our society. As society changes, so do the ideas.

When you think of it like that, it’s hard not to feel indebted to those people who influenced your thinking. It’s one thing to be given a tangible gift, but it’s an entirely other type to have had wisdom shared, leaving you with the opportunity to do something with it. When I say “wisdom shared”, I don’t just mean someone who is giving a talk at a conference, or doing a podcast, or writing a blog post. Any of those things on their own are just sequences of words that we interpret either visibly or audibly. Where those mediums transform between empty words and wisdom is when the person speaking is transmitting more then just words, they’re transmitting passion.

The smartest person in the world would be completely useless if they didn’t know how to articulate their ideas in a way that caused us to understand not only what they’re saying but where they’re coming from. The harder you have to work to deduce value from someone’s ideas, the less worth there is to continue listening. It’s kind of like the attempt to use ethanol as a source for fuel. Sure, ethanol is a valid fuel alternative to petroleum, but the amount of resources and effort that it takes to process corn into usable ethanol makes the whole process almost useless (not to mention the fact that you still need petroleum to operate most of the process).

The other day, Alex James (who is an incredibly smart guy) was asking on Twitter whether the best programmers are the ones who are most well-rounded. This is obviously a fairly subjective question, but my answer was yes. I say this because my interpretation of “best”, in the context of software developers, are the ones who are most capable of participating in the inspiration of the team as a whole. The more well-rounded a developer is, the more areas he is capable of sparking the idea that might lead to success. The inverse of that is that a well-rounded developer is also not going to be a roadblock for an idea permeating. In my experience, nothing kills the morale of a team like someone who doesn’t understand something, and translates that misunderstanding into disapproval of the idea.

It’s too easy to overlook those guys who strive to be as well-rounded and articulate as possible and make an effort to really share their passion for software development with others. Working at Microsoft, I have the pleasure to interact with some pretty amazing people on a daily basis and I can’t even begin to express my appreciation for it. The following is a list of people that I believe have been integral in my growth as a developer in the last year (excluding the “celebrity developers” that everyone already knows), who I’d love to see start having a broader influence:

Jason Olson
James Senior
Matias Woloski
Dave Reed
David Fowler
Pablo Costantini
Johnny Halife

In many ways, that group makes up what I would consider part of my “collective intelligence” (yes I’m overloading that term). Between language design, business/startup trends, web development, identity/security, and everything in between, I’ve learned an immense amount from those guys, and will continue to learn.

The point of this post wasn’t to namedrop, but I thought I’d throw out a couple names of people that I feel deserve a shout out, and hopefully encourage them all to blog more

Whenever I hear people complain about the state of the .NET community, I just can’t help but feel like they haven’t found the right people. Our community is absolutely loaded with the right people, unfortunately some of those folks aren’t nearly as vocal as others. I’m sure there are tons of awesome people in the .NET space that I’m missing out on by not knowing. The question is: how do we surface these people out? Simple: give credit where credit is due.